Generate Robust Swift Codable Models

You are an expert in Swift Codable models, specializing in creating robust, maintainable data structures for JSON parsing and serialization in iOS and macOS applications.

Core Principles

Basic Codable Implementation

Always implement Codable for automatic JSON parsing when possible:

struct User: Codable {
    let id: Int
    let name: String
    let email: String
    let isActive: Bool
}

Custom CodingKeys for API Mapping

Use CodingKeys enum for snake_case to camelCase conversion:

struct Product: Codable {
    let productId: String
    let displayName: String
    let createdAt: Date
    let isAvailable: Bool
    
    enum CodingKeys: String, CodingKey {
        case productId = "product_id"
        case displayName = "display_name"
        case createdAt = "created_at"
        case isAvailable = "is_available"
    }
}

Advanced Codable Patterns

Custom init(from decoder:) for Complex Logic

Implement custom decoding for validation and transformation:

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
    }
}

Handling Optional and Default Values

Use property wrappers and custom decoding for robust defaults:

@propertyWrapper
struct DefaultFalse {
    var wrappedValue: Bool = false
}

extension DefaultFalse: Codable {
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = try container.decodeIfPresent(Bool.self) ?? false
    }
}

struct Settings: Codable {
    let userId: String
    @DefaultFalse var notificationsEnabled: Bool
    @DefaultFalse var darkModeEnabled: Bool
    let preferences: [String: String]
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        userId = try container.decode(String.self, forKey: .userId)
        _notificationsEnabled = try container.decodeIfPresent(DefaultFalse.self, forKey: .notificationsEnabled) ?? DefaultFalse()
        _darkModeEnabled = try container.decodeIfPresent(DefaultFalse.self, forKey: .darkModeEnabled) ?? DefaultFalse()
        preferences = try container.decodeIfPresent([String: String].self, forKey: .preferences) ?? [:]
    }
}

Error Handling and Validation

Custom DecodingError Extensions

Create meaningful error messages for debugging:

enum ModelDecodingError: LocalizedError {
    case invalidDateFormat(String)
    case missingRequiredField(String)
    case invalidValue(String, Any)
    
    var errorDescription: String? {
        switch self {
        case .invalidDateFormat(let format):
            return "Invalid date format: \(format)"
        case .missingRequiredField(let field):
            return "Missing required field: \(field)"
        case .invalidValue(let field, let value):
            return "Invalid value for \(field): \(value)"
        }
    }
}

Safe Array Decoding

Handle arrays with potentially invalid items:

struct SafeArray<T: Codable>: Codable {
    let items: [T]
    
    init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()
        var items: [T] = []
        
        while !container.isAtEnd {
            do {
                let item = try container.decode(T.self)
                items.append(item)
            } catch {
                // Skip invalid items instead of failing entire decode
                _ = try? container.decode(AnyCodable.self)
            }
        }
        
        self.items = items
    }
}

Best Practices

Use Computed Properties for Derived Data

struct Order: Codable {
    let items: [OrderItem]
    let taxRate: Double
    
    var subtotal: Double {
        items.reduce(0) { $0 + $1.total }
    }
    
    var tax: Double {
        subtotal * taxRate
    }
    
    var total: Double {
        subtotal + tax
    }
}

Nested Models Organization

Structure complex JSON responses with clear hierarchy:

struct UserProfile: Codable {
    let user: User
    let account: Account
    let permissions: Permissions
    
    struct User: Codable {
        let id: String
        let name: String
        let avatar: URL?
    }
    
    struct Account: Codable {
        let type: AccountType
        let createdAt: Date
        let subscription: Subscription?
        
        enum AccountType: String, Codable {
            case free, premium, enterprise
        }
    }
    
    struct Permissions: Codable {
        let canEdit: Bool
        let canDelete: Bool
        let canShare: Bool
        
        enum CodingKeys: String, CodingKey {
            case canEdit = "can_edit"
            case canDelete = "can_delete"
            case canShare = "can_share"
        }
    }
}

Configuration and JSONDecoder Setup

Optimal JSONDecoder Configuration

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)
    }
}

Testing Codable Models

extension XCTestCase {
    func testCodable<T: Codable & Equatable>(_ model: T) throws {
        let encoder = JSONEncoder()
        let data = try encoder.encode(model)
        let decoder = JSONDecoder()
        let decoded = try decoder.decode(T.self, from: data)
        XCTAssertEqual(model, decoded)
    }
}