Output a file per object (Swift)

[rjstelling]

Is it possible to out put a file per object when generating Swift?

I have JSON Schema files that refer to each other, but the referenced schema is creating in the same file, thus causing duplicate symbols when compiled.

The User.swift file generated has a User and Address struct in it, I'd like them to be separate files.

E.g

User Schema: User.schema

{
    "$ref": "#/definitions/User",
    "$schema": "http://json-schema.org/draft-06/schema#",
    "definitions": {
        "User": {
            "additionalProperties": false,
            "properties": {
                "basket_value": {
                    "type": "integer"
                },
                "default_address": {
                    "$ref": "./Address.schema"
                },
                "first_name": {
                    "type": "string"
                },
                "last_name": {
                    "type": "string"
                },
                "user_id": {
                    "type": "integer"
                }
            },
            "required": [
                "default_address",
                "first_name",
                "last_name",
                "user_id"
            ],
            "title": "user",
            "type": "object"
        }
    }
}

Address Schema: Address.schema

{
    "$ref": "#/definitions/Address",
    "$schema": "http://json-schema.org/draft-06/schema#",
    "definitions": {
        "Address": {
            "additionalProperties": false,
            "properties": {
                "address_id": {
                    "type": "integer"
                },
                "city": {
                    "type": "string"
                },
                "postcode": {
                    "type": "string"
                }
            },
            "required": [
                "address_id",
                "city",
                "postcode"
            ],
            "title": "address",
            "type": "object"
        }
    }
}

[schani]

You can just put your schemas in a directory and then run quicktype on the directory to generate one top-level type for each schema file, without any duplication:

Marks-iMac:quicktype schani$ ls /tmp/issue687

Address.schema	User.schema

Marks-iMac:quicktype schani$ quicktype --src-lang schema --lang swift /tmp/issue687

// To parse the JSON, add this file to your project and do:
//
//   let address = try Address(json)
//   let user = try User(json)

import Foundation

struct User: Codable {
    let basketValue: Int?
    let defaultAddress: Address
    let firstName, lastName: String
    let userID: Int

    enum CodingKeys: String, CodingKey {
        case basketValue = "basket_value"
        case defaultAddress = "default_address"
        case firstName = "first_name"
        case lastName = "last_name"
        case userID = "user_id"
    }
}

struct Address: Codable {
    let addressID: Int
    let city, postcode: String

    enum CodingKeys: String, CodingKey {
        case addressID = "address_id"
        case city, postcode
    }
}

// MARK: Convenience initializers

extension User {
    init(data: Data) throws {
        self = try JSONDecoder().decode(User.self, from: data)
    }

    init(_ json: String, using encoding: String.Encoding = .utf8) throws {
        guard let data = json.data(using: encoding) else {
            throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
        }
        try self.init(data: data)
    }

    init(fromURL url: URL) throws {
        try self.init(data: try Data(contentsOf: url))
    }

    func jsonData() throws -> Data {
        return try JSONEncoder().encode(self)
    }

    func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
        return String(data: try self.jsonData(), encoding: encoding)
    }
}

extension Address {
    init(data: Data) throws {
        self = try JSONDecoder().decode(Address.self, from: data)
    }

    init(_ json: String, using encoding: String.Encoding = .utf8) throws {
        guard let data = json.data(using: encoding) else {
            throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil)
        }
        try self.init(data: data)
    }

    init(fromURL url: URL) throws {
        try self.init(data: try Data(contentsOf: url))
    }

    func jsonData() throws -> Data {
        return try JSONEncoder().encode(self)
    }

    func jsonString(encoding: String.Encoding = .utf8) throws -> String? {
        return String(data: try self.jsonData(), encoding: encoding)
    }
}