[Custom Fields] Differentiate between raw JSON values and String values that contain valid JSON

[hichamboushaba]

Closes: #14271

@hafizrahman @selanthiraiyan not urgent, please review when you have some free time.

Description

As detailed in the above issue, the current implementation in iOS doesn't allow to differentiate between JSON values and String values that contain valid JSON, and this causes a difference with how Android and Core behaves.
This PR updates the MetaData parsing to expose information on whether the value is a String or a Json using an enum, and we store this information also when caching: the logic here is simple, we store the information as it's in the response, Strings will be stored with their quotes, and JSON values will be stored as they are without quotes. (the implementation is similar to what we did in Android, but simpler here)

While the number of affected files may seem big, the changes are quite simple actually:

1. Whenever the value is read, we read it using the property stringValue, this returns the same content as before.
2. When we save MetaData to storage, we use the property rawValue, this makes sure that String values are stored with their quotes.

Note: While the impact of these changes could be small for this specific feature, I think it could have some benefits in the future, for example if we move Subscriptions or Addons to use the MetaData class directly, then we'll have to make sure we can use JSON data with it.

Steps to reproduce

1. Open wp-admin and add a custom field with the following content: {"key":"value"}
2. Use the API to add a true JSON field like this for example:

POST {site}/wc/v3/orders/{orderId}

{
    "meta_data": [
        {
            "key": "json_object",
            "value": {
                "Key": "Value"
            }
        },
        {
            "key": "json_array",
            "value": [
                {
                    "Key": "Value"
                }
            ]
        }
    ]
}

4. Open the given product or order where the changes were made.

Testing information

• Confirm that the value added in wp-admin is editable in the app.
• Confirm that the value added using the API call is not editable.
• Smoke test the feature as a whole.

Screenshots

Simulator.Screen.Recording.-.iPhone.15.-.2024-11-01.at.18.21.44.mp4

---

• I have considered if this change warrants user-facing release notes and have added them to RELEASE-NOTES.txt if necessary.

Reviewer (or Author, in the case of optional code reviews):

Please make sure these conditions are met before approving the PR, or request changes if the PR needs improvement:

• The PR is small and has a clear, single focus, or a valid explanation is provided in the description. If needed, please request to split it into smaller PRs.
• Ensure Adequate Unit Test Coverage: The changes are reasonably covered by unit tests or an explanation is provided in the PR description.
• Manual Testing: The author listed all the tests they ran, including smoke tests when needed (e.g., for refactorings). The reviewer confirmed that the PR works as expected on all devices (phone/tablet) and no regressions are added.

[dangermattic]

	1 Error
🚫	PR is not assigned to a milestone.

Generated by 🚫 Danger

[hichamboushaba]

I think the file wasn't re-generated after some changes in a previous PR, that's why rage generate updated it.

[wpmobilebot]

📲 You can test the changes from this Pull Request in WooCommerce iOS by scanning the QR code below to install the corresponding build.

	App Name	WooCommerce iOS
	Build Number	pr14292-4f82a10
	Version	20.9
	Bundle ID	com.automattic.alpha.woocommerce
	Commit	4f82a10
	App Center Build	WooCommerce - Prototype Builds #11424

Automatticians: You can use our internal self-serve MC tool to give yourself access to App Center if needed.

[hichamboushaba]

We expose a struct instead of exposing the enum directly just to make sure we have some validation, and we no consumer can bypass it by instantiating the enum directly, ie: .json("invalid json"), this is actually because as far as I found, Swift doesn't allow to have private initializer for the enum cases (unlike Kotlin with its sealed interface feature).

[hichamboushaba]

I played with a different approach here, instead of making the backing data a String, we can have it as Codable directly, I don't have a strong opinion on which approach is best, so I kept the String based implementation.

public struct MetaDataValue: Codable, Equatable, Sendable {
    private let valueHolder: ValueHolder

    public var stringValue: String {
        valueHolder.stringValue
    }
    public var rawValue: String {
        valueHolder.rawValue
    }

    public var isJson: Bool {
        switch valueHolder {
        case .string:
            return false
        case .json:
            return true
        }
    }

    public init(rawValue: String) {
        let data = Data(rawValue.utf8)
        if let jsonObject = try? JSONDecoder().decode(AnyCodable.self, from: data) {
            valueHolder = try! ValueHolder(from: jsonObject.value)
        } else {
            valueHolder = .string(rawValue.removingPrefix("\"").removingSuffix("\""))
        }
    }

    public init(from decoder: Decoder) throws {
        valueHolder = try ValueHolder(from: decoder)
    }

    public func encode(to encoder: Encoder) throws {
        try valueHolder.encode(to: encoder)
    }
}

private extension MetaDataValue {
    private enum ValueHolder: Codable, Equatable {
        case string(_ value: String)
        case json(_ json: Codable)

        var stringValue: String {
            switch self {
            case .string(let value):
                return value
            case .json(let json):
                return json.asJSONString()
            }
        }

        var rawValue: String {
            switch self {
            case .string(let value):
                return "\"\(value)\""
            case .json(let json):
                return json.asJSONString()
            }
        }

        init(from decoder: any Decoder) throws {
            let container = try decoder.singleValueContainer()
            let value = try container.decode(AnyCodable.self)
            try self.init(from: value.value)
        }

        init(from object: Any) throws {
            switch object {
            case let value as String:
                self = .string(value)
            case is Bool:
                self = .string(String(describing: object))
            case is any Numeric:
                self = .string(String(describing: object))
            default:
                self = .json(AnyCodable(object))
            }
        }

        func encode(to encoder: Encoder) throws {
            switch self {
            case .string(let value):
                try value.encode(to: encoder)
            case .json(let json):
                try json.encode(to: encoder)
            }
        }

        static func == (lhs: ValueHolder, rhs: ValueHolder) -> Bool {
            return lhs.stringValue == rhs.stringValue
        }
    }
}

private extension Encodable {
    func asJSONString() -> String {
        if let data = try? JSONEncoder().encode(self) {
            return String(data: data, encoding: .utf8) ?? ""
        }
        return ""
    }
}