Add NullCodable capabilities

[mdb1]

Some requests require the json objects to explicitly use "null", add the NullCodable struct to handle those scenarios

//
//  JSONEncoder+NullCodable.swift
//
//
//  Created by Manu on 17/05/2023.
//  Based on: https://github.com/g-mark/NullCodable

import Foundation

/// Property wrapper that encodes `nil` optional values as `null`
/// when encoded using `JSONEncoder`.
///
/// For example, adding `@NullCodable` like this:
/// ```swift
/// struct Test: Codable {
///     @NullCodable var name: String? = nil
/// }
/// ```
/// will encode as: "{\\"name\\": null}" - as opposed to the default,
/// which is to omit the property from the encoded json, like: "{}".
@propertyWrapper
public struct NullCodable<Wrapped> {
    /// The wrapper value.
    public var wrappedValue: Wrapped?

    /// Initializer.
    public init(wrappedValue: Wrapped?) {
        self.wrappedValue = wrappedValue
    }
}

extension NullCodable: Encodable where Wrapped: Encodable {
    public func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch wrappedValue {
        case let .some(value):
            try container.encode(value)
        case .none:
            try container.encodeNil()
        }
    }
}

extension NullCodable: Decodable where Wrapped: Decodable {
    public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if !container.decodeNil() {
            wrappedValue = try container.decode(Wrapped.self)
        }
    }
}

extension NullCodable: Equatable where Wrapped: Equatable {}

public extension KeyedDecodingContainer {
    /// Decoding method.
    func decode<Wrapped>(
        _: NullCodable<Wrapped>.Type,
        forKey key: KeyedDecodingContainer<K>.Key
    ) throws -> NullCodable<Wrapped> where Wrapped: Decodable {
        try decodeIfPresent(NullCodable<Wrapped>.self, forKey: key) ?? NullCodable<Wrapped>(wrappedValue: nil)
    }
}

[mdb1]

Test cases:

@testable import CoreNetworking
import XCTest

final class JSONEncoderNullCodableTests: XCTestCase {
    /// Test that `@NullCodable` applied to an attribute that doesn't have any `Codable`
    /// conformance will still compile & function properly.
    func test_noConformance() {
        // Given
        struct Test {
            @NullCodable var a: String?
        }
        struct Container {
            @NullCodable var test: Test?
        }

        // When
        var container = Container(test: nil)

        // Then
        XCTAssertNil(container.test)
        XCTAssertNil(container.test?.a)

        // When
        container.test = Test(a: nil)

        // Then
        XCTAssertNotNil(container.test)
        XCTAssertNil(container.test?.a)

        // When
        container.test = Test(a: "a")

        // Then
        XCTAssertNotNil(container.test)
        XCTAssertNotNil(container.test?.a)
        XCTAssertEqual(container.test?.a, "a")
    }

    /// Test that `@NullCodable` applied to a property type that has `Encodable` conformance
    /// properly encodes nil and non-nil values.
    func test_encodable() throws {
        // Given
        struct Test: Encodable {
            @NullCodable var a: String?
        }
        struct Container: Encodable {
            @NullCodable var test: Test?
        }

        let encoder = JSONEncoder()

        // When
        var container = Container(test: nil)
        var data = try encoder.encode(container)
        var str = try XCTUnwrap(String(data: data, encoding: .utf8))

        // Then
        XCTAssertEqual(str, "{\"test\":null}")

        // When
        container.test = Test(a: nil)
        data = try encoder.encode(container)
        str = try XCTUnwrap(String(data: data, encoding: .utf8))

        // Then
        XCTAssertEqual(str, "{\"test\":{\"a\":null}}")

        // When
        container.test = Test(a: "a")
        data = try encoder.encode(container)
        str = try XCTUnwrap(String(data: data, encoding: .utf8))

        // Then
        XCTAssertEqual(str, "{\"test\":{\"a\":\"a\"}}")
    }

    /// Test that `@NullCodable` applied to a property type that has `Decodable` conformance
    /// properly decodes `null` and non-nil values.
    func test_decodable() throws {
        // Given
        struct Test: Decodable {
            @NullCodable var a: String?
            @NullCodable var b: Int?
        }
        struct Container: Decodable {
            @NullCodable var test: Test?
        }

        let decoder = JSONDecoder()

        // When
        var data = try XCTUnwrap("{\"test\":null}".data(using: .utf8))
        var container = try decoder.decode(Container.self, from: data)

        // Then
        XCTAssertNil(container.test)

        // When
        data = try XCTUnwrap("{\"test\":{\"a\":null,\"b\":null}}".data(using: .utf8))
        container = try decoder.decode(Container.self, from: data)

        // Then
        XCTAssertNotNil(container.test)
        XCTAssertNil(container.test?.a)
        XCTAssertNil(container.test?.b)

        // When
        data = try XCTUnwrap("{\"test\":{\"a\":\"a\",\"b\":42}}".data(using: .utf8))
        container = try decoder.decode(Container.self, from: data)

        // Then
        XCTAssertEqual(container.test?.a, "a")
        XCTAssertEqual(container.test?.b, 42)

        // When
        data = try XCTUnwrap("{}".data(using: .utf8))
        container = try decoder.decode(Container.self, from: data)

        // Then
        XCTAssertNil(container.test)

        // When
        data = try XCTUnwrap("{\"b\":42}".data(using: .utf8))
        let test = try decoder.decode(Test.self, from: data)

        // Then
        XCTAssertNil(test.a)
        XCTAssertEqual(test.b, 42)
    }
}