Swift SDK

dependencies: [
    .package(url: "https://github.com/terrakernel/ODXProxyClient-Swift.git", from: "1.1.0")
],
targets: [
    .target(name: "YourApp", dependencies: [
        .product(name: "ODXProxyClientSwift", package: "ODXProxyClient-Swift")
    ])
]

import SwiftUI
import ODXProxyClientSwift

@main
struct MyApp: App {
    init() {
        OdxProxyClient.shared.configure(
            with: OdxProxyClientInfo(
                instance: OdxInstanceInfo(
                    url: "https://erp.example.com",
                    userId: 2,
                    db: "prod",
                    apiKey: "<odoo user api key>"
                ),
                odxApiKey: "<proxy x-api-key>",
                gatewayUrl: "https://your-proxy.example.com"   // optional
            )
        )
    }

    var body: some Scene { WindowGroup { ContentView() } }
}

struct Partner: Codable, Identifiable, Sendable {
    let id: Int
    let name: String
    let email: String?
}

struct PartnersView: View {
    @State private var partners: [Partner] = []
    @State private var errorMessage: String?

    var body: some View {
        List(partners) { Text($0.name) }
            .task { await load() }
            .refreshable { await load() }
    }

    private func load() async {
        do {
            let keyword = OdxClientKeywordRequest(
                fields: ["id", "name", "email"],
                limit: 50,
                context: OdxClientRequestContext(tz: "UTC")
            )
            // The return-type annotation is REQUIRED — see the note below.
            let response: OdxServerResponse<[Partner]> = try await OdxApi.searchRead(
                model: "res.partner",
                params: OdxParams([[["is_company", "=", true]]]),
                keyword: keyword
            )
            partners = response.result ?? []
        } catch {
            errorMessage = error.localizedDescription
        }
    }
}

async let partners: OdxServerResponse<[Partner]> = OdxApi.searchRead(...)
async let products: OdxServerResponse<[Product]> = OdxApi.searchRead(...)
let (p, q) = try await (partners, products)

// call_method — invoke any model method by name
let response: OdxServerResponse<Bool> = try await OdxApi.callMethod(
    model: "sale.order",
    functionName: "action_confirm",
    params: OdxParams([[42]] as [[Any]]),
    keyword: OdxClientKeywordRequest(context: OdxClientRequestContext(tz: "UTC"))
)

// Empty domain (match all) — the `as [[Any]]` cast is required.
OdxParams([[]] as [[Any]])

// Single filter
OdxParams([[["is_company", "=", true]]])

// OR between two filters (prefix node applies to the next two terms)
OdxParams([["|", ["email", "ilike", "@acme.com"], ["name", "ilike", "Acme"]]])

// Read by IDs — [[ids]]
OdxParams([[1, 2, 3]] as [[Any]])

// Create payload — [{ fields }]
OdxParams([["name": "Acme Inc", "is_company": true]])

// Write payload — [[ids], { fields }] (mixed types need `as [Any]`)
OdxParams([[42], ["name": "Updated"]] as [Any])

OdxProxyClient.shared.configure(
    with: OdxProxyClientInfo(
        instance: OdxInstanceInfo(url: "https://erp.example.com", userId: 2, db: "prod", apiKey: "<odoo api key>"),
        odxApiKey: "<proxy x-api-key>",
        gatewayUrl: "https://your-proxy.example.com",
        defaultContext: OdxContext(lang: "en_US", tz: "Asia/Jakarta", allowedCompanyIds: [1])
    )
)

// Reading — the domain is the list itself, with no v1-style wrapping
let partners: OdxServerResponse<[Partner]> = try await OdxApiV2.searchRead(
    model: "res.partner",
    domain: OdxParams([["is_company", "=", true]]),
    fields: ["name"],
    limit: 20,
    order: "name asc"
)
let count = try await OdxApiV2.searchCount(model: "res.partner", domain: OdxParams([]))

// Writing — values can be OdxParams or your own Encodable struct
let newIds = try await OdxApiV2.create(model: "res.partner",
                                       values: [OdxParams(["name": "Acme"]), OdxParams(["name": "Globex"])])  // [41, 42]
let one = try await OdxApiV2.createOne(model: "res.partner", values: OdxParams(["name": "Initech"]))       // 43
_ = try await OdxApiV2.write(model: "res.partner", ids: [41], values: OdxParams(["comment": "via v2"]))
_ = try await OdxApiV2.remove(model: "res.partner", ids: [41, 42])

// Any method: ids for record methods, named kwargs for the rest
let posted: OdxServerResponse<Bool> = try await OdxApiV2.callMethod(model: "account.move", method: "action_post", ids: [7])

let about = try await OdxOps.about()      // OdxServerResponse<OdxAboutInfo>
let license = try await OdxOps.license()  // OdxLicenseInfo — NOT an envelope

do {
    let response: OdxServerResponse<[Partner]> = try await OdxApi.searchRead(...)
    // use response.result
} catch OdxProxyError.authFailure(let err) {
    print("Check your proxy x-api-key: \(err.message)")
} catch OdxProxyError.odooLogic(let err) {
    showAlert(err.message)   // validation / access-rights error from Odoo
} catch OdxProxyError.notConfigured {
    fatalError("Configure OdxProxyClient.shared before calling the API")
}

do {
    _ = try await OdxApiV2.createOne(model: "res.partner", values: OdxParams([:]))
} catch let error as OdxProxyError where error.odooStatus == 422 {
    showAlert(error.localizedDescription)   // e.g. a required field is missing
} catch let error as OdxProxyError where error.odooStatus == 401 {
    promptForNewOdooKey()                   // the Odoo key expired or was revoked
}

struct Product: Codable, Sendable {
    let id: Int
    let name: String
    let categ_id: OdxMany2One      // [1, "All"], false, or null → .id / .name

    @OdxOptional var barcode: String?   // "ABC123", false, null, or missing → nil
}