Generate Robust Swift Codable Models

This is a Swift Codable skill for building robust JSON parsing and serialization models in iOS and macOS apps, covering basic struct conformance, CodingKeys for snake_case-to-camelCase API mapping, custom init(from decoder:) implementations for validation and transformation (including a generic APIResponse<T> wrapper that decodes a nullable nested payload and falls back to the current date if a timestamp string fails ISO8601 parsing), and property-wrapper-based default values - a @DefaultFalse wrapper that decodes a missing boolean field as false rather than failing. It centralizes decoder configuration in one reusable function:

func createJSONDecoder() -> JSONDecoder {
    let decoder = JSONDecoder()
    decoder.keyDecodingStrategy = .convertFromSnakeCase
    decoder.dateDecodingStrategy = .iso8601
    decoder.dataDecodingStrategy = .base64
    return decoder
}

// Usage with error handling
func decode<T: Codable>(_ type: T.Type, from data: Data) -> Result<T, Error> {
    let decoder = createJSONDecoder()
    do {
        let result = try decoder.decode(type, from: data)
        return .success(result)
    } catch {
        return .failure(error)
    }
}

Use this skill when defining or hardening Codable models against real-world API responses that don't perfectly match Swift's defaults - missing fields, snake_case keys, nested optional data, or arrays that may contain a few malformed items, handled with a SafeArray wrapper that skips individual bad items via AnyCodable rather than failing the entire decode. It also covers a custom ModelDecodingError enum with LocalizedError conformance for meaningful debug messages, computed properties for values derived from decoded data (like an Order's subtotal, tax, and total), and a reusable XCTestCase extension that round-trips any Codable & Equatable model through encode-then-decode to assert equality. It is not a networking-layer skill - it's scoped to the model and decoding layer itself, so it isn't the right fit for URLSession request/response plumbing or API-client architecture.

Input is raw JSON data, or an API's actual field names and structure; output is typed Swift structs conforming to Codable, using custom CodingKeys where the API's field names differ from Swift naming conventions, nested model hierarchies (a UserProfile example nests User, Account, and Permissions sub-structs, with an AccountType enum and its own CodingKeys for the permissions block), and a configured JSONDecoder applying .convertFromSnakeCase key decoding, .iso8601 date decoding, and .base64 data decoding consistently.

Built entirely on Foundation's Codable, JSONDecoder/JSONEncoder, and ISO8601DateFormatter, plus XCTest for round-trip encode and decode testing.

iOS and macOS developers defining data models for JSON APIs who need consistent patterns for key mapping, safe defaults, partial-failure-tolerant array decoding, and testable round-trip encoding, rather than writing custom decoding logic ad hoc per model.