Generate Robust Swift Codable Models

Swift Codable Model Expert provides expert guidance on creating robust, maintainable Swift Codable models for JSON parsing and serialization in iOS and macOS applications, covering basic Codable structs, custom key mapping, complex decoding logic, and error handling. Core patterns include basic Codable structs for automatic JSON parsing, a CodingKeys enum for mapping snake_case API fields to camelCase Swift properties, custom init(from decoder:) implementations for validation and transformation (such as parsing a nested generic API-response wrapper with a custom date format and a null-safe optional payload), and property wrappers like DefaultFalse that give a decoded field a safe default when the API omits it rather than failing the whole decode.

Use it when modeling API responses in Swift: mapping snake_case JSON keys to camelCase properties via CodingKeys, writing a custom decoder initializer for nested or conditionally-null data with a specific date format, giving optional API fields safe defaults through property wrappers, defining a LocalizedError-conforming custom decoding-error type with meaningful messages for debugging, building a SafeArray wrapper that skips individual invalid array items instead of failing the entire decode, computing derived properties (like order subtotal, tax, and total) rather than storing them redundantly in the model, organizing nested JSON responses as nested Swift types for clear hierarchy, configuring a shared JSONDecoder with convertFromSnakeCase, .iso8601, and .base64 strategies, and writing a round-trip encode/decode test helper for XCTestCase. It is specific to Swift's Codable protocol for iOS/macOS data modeling, not a general-purpose JSON schema or validation library.

Input is a JSON API response shape (or an existing malformed/inconsistent one) that needs a corresponding Swift model. Output is Swift code: Codable structs with CodingKeys mappings, custom init(from decoder:) implementations handling nested, optional, or date-formatted fields, property-wrapper types providing safe defaults, a custom LocalizedError type for decoding failures, a generic SafeArray<T> wrapper that decodes what it can and skips invalid entries, nested type hierarchies mirroring a complex response, a configured JSONDecoder factory function, and an XCTestCase extension for round-trip Codable testing.

struct APIResponse<T: Codable>: Codable {
    let data: T?
    let success: Bool
    let message: String
    let timestamp: Date
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        // Handle nested data that might be null
        data = try container.decodeIfPresent(T.self, forKey: .data)
        success = try container.decode(Bool.self, forKey: .success)
        message = try container.decodeIfPresent(String.self, forKey: .message) ?? ""
        
        // Custom date parsing
        let timestampString = try container.decode(String.self, forKey: .timestamp)
        let formatter = ISO8601DateFormatter()
        timestamp = formatter.date(from: timestampString) ?? Date()
    }
    
    enum CodingKeys: String, CodingKey {
        case data, success, message, timestamp
    }
}

Documented Foundation and XCTest APIs include JSONDecoder/JSONEncoder with keyDecodingStrategy, dateDecodingStrategy, and dataDecodingStrategy configuration, ISO8601DateFormatter for custom date parsing, Swift's @propertyWrapper feature for default-value wrapping, and XCTAssertEqual for round-trip Codable test assertions. No third-party JSON or networking library is documented; everything shown uses Swift's standard Codable protocol and Foundation.

iOS and macOS developers modeling API responses in Swift who need robust handling of inconsistent JSON (snake_case keys, missing fields, malformed array items, non-standard date formats) with meaningful decoding errors, rather than brittle models that crash on the first unexpected API response.