@topogram/cli 0.3.34

package/src/generator/surfaces/native/swiftui-templates/runtime/TodoAPIClient.swift

@@ -0,0 +1,156 @@
+import Foundation
+
+/// Dynamic capability client mirroring `src/lib/api/client.ts` (requestCapability over bundled api-contracts.json).
+public final class TodoAPIClient: @unchecked Sendable {
+    private let session: URLSession
+    let contracts: [String: Any]
+    public init(session: URLSession = .shared, contractsData: Data) throws {
+        self.session = session
+        guard let root = try JSONSerialization.jsonObject(with: contractsData) as? [String: Any] else {
+            throw TodoAPIError.invalidContracts
+        }
+        self.contracts = root
+    }
+
+    public static func loadBundledContracts() throws -> Data {
+        guard let url = Bundle.module.url(forResource: "api-contracts", withExtension: "json"),
+              let data = try? Data(contentsOf: url) else {
+            throw TodoAPIError.missingResource("api-contracts.json")
+        }
+        return data
+    }
+
+    private func apiBase() -> String {
+        let env = ProcessInfo.processInfo.environment
+        return env["PUBLIC_TOPOGRAM_API_BASE_URL"] ?? "http://localhost:3000"
+    }
+
+    private func authToken() -> String {
+        ProcessInfo.processInfo.environment["PUBLIC_TOPOGRAM_DEMO_AUTH_TOKEN"] ?? ""
+    }
+
+    private func buildPath(contract: [String: Any], input: [String: Any]) throws -> String {
+        guard let endpoint = contract["endpoint"] as? [String: Any],
+              let rawPath = endpoint["path"] as? String else {
+            throw TodoAPIError.invalidContracts
+        }
+        var path = rawPath
+        let requestContract = contract["requestContract"] as? [String: Any]
+        let transport = requestContract?["transport"] as? [String: Any]
+        let pathFields = transport?["path"] as? [[String: Any]] ?? []
+        for field in pathFields {
+            guard let name = field["name"] as? String else { continue }
+            let wire = (field["transport"] as? [String: Any])?["wireName"] as? String ?? name
+            let raw = input[name]
+            path = path.replacingOccurrences(of: ":\(wire)", with: encodePathSegment(raw))
+        }
+        var query: [String] = []
+        let queryFields = transport?["query"] as? [[String: Any]] ?? []
+        for field in queryFields {
+            guard let name = field["name"] as? String else { continue }
+            let wire = (field["transport"] as? [String: Any])?["wireName"] as? String ?? name
+            if let raw = input[name] {
+                if raw is NSNull { continue }
+                let s = String(describing: raw)
+                if !s.isEmpty {
+                    query.append("\(wire)=\(encodeQueryComponent(s))")
+                }
+            }
+        }
+        if !query.isEmpty {
+            path += "?" + query.joined(separator: "&")
+        }
+        return path
+    }
+
+    private func encodePathSegment(_ value: Any?) -> String {
+        let s = value.map { String(describing: $0) } ?? ""
+        return s.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? s
+    }
+
+    private func encodeQueryComponent(_ value: String) -> String {
+        value.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? value
+    }
+
+    public func requestCapability(
+        _ capabilityId: String,
+        input: [String: Any] = [:],
+        extraHeaders: [String: String] = [:]
+    ) async throws -> Any {
+        guard let contract = contracts[capabilityId] as? [String: Any] else {
+            throw TodoAPIError.unknownCapability(capabilityId)
+        }
+        guard let endpoint = contract["endpoint"] as? [String: Any],
+              let method = endpoint["method"] as? String else {
+            throw TodoAPIError.invalidContracts
+        }
+        let path = try buildPath(contract: contract, input: input)
+        guard let url = URL(string: path, relativeTo: URL(string: apiBase()))?.absoluteURL else {
+            throw TodoAPIError.badURL(path)
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = method
+
+        var headers = extraHeaders
+        let authz = endpoint["authz"] as? [[String: Any]] ?? []
+        if !authz.isEmpty, !authToken().isEmpty {
+            if headers["Authorization"] == nil {
+                headers["Authorization"] = "Bearer " + authToken()
+            }
+        }
+        for (k, v) in headers {
+            request.setValue(v, forHTTPHeaderField: k)
+        }
+
+        let requestContract = contract["requestContract"] as? [String: Any]
+        let transport = requestContract?["transport"] as? [String: Any]
+        let bodyFields = transport?["body"] as? [[String: Any]] ?? []
+        if !bodyFields.isEmpty {
+            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            var payload: [String: Any] = [:]
+            for field in bodyFields {
+                guard let name = field["name"] as? String else { continue }
+                let wire = (field["transport"] as? [String: Any])?["wireName"] as? String ?? name
+                if let v = input[name] {
+                    payload[wire] = v
+                }
+            }
+            request.httpBody = try JSONSerialization.data(withJSONObject: payload)
+        }
+
+        let downloadable = endpoint["download"] as? [[String: Any]] ?? []
+        let (data, response) = try await session.data(for: request)
+        guard let http = response as? HTTPURLResponse else {
+            throw TodoAPIError.invalidResponse
+        }
+        guard (200 ..< 300).contains(http.statusCode) else {
+            let text = String(data: data, encoding: .utf8) ?? ""
+            throw TodoAPIError.http(http.statusCode, text)
+        }
+        if http.statusCode == 204 {
+            return NSNull()
+        }
+        if !downloadable.isEmpty {
+            return data
+        }
+        return try JSONSerialization.jsonObject(with: data)
+    }
+
+    public func extractRows(from json: Any) -> [[String: Any]] {
+        if let rows = json as? [[String: Any]] { return rows }
+        if let dict = json as? [String: Any] {
+            if let items = dict["items"] as? [[String: Any]] { return items }
+            if let data = dict["data"] as? [[String: Any]] { return data }
+        }
+        return []
+    }
+}
+
+public enum TodoAPIError: Error {
+    case invalidContracts
+    case missingResource(String)
+    case unknownCapability(String)
+    case badURL(String)
+    case invalidResponse
+    case http(Int, String)
+}

package/src/generator/surfaces/native/swiftui-templates/runtime/TodoSwiftUIApp.swift

@@ -0,0 +1,44 @@
+import SwiftUI
+
+@main
+struct TodoSwiftUIApp: App {
+    @StateObject private var contractHolder = ContractHolder()
+
+    var body: some Scene {
+        WindowGroup {
+            Group {
+                if let contract = contractHolder.contract, let client = contractHolder.client {
+                    RootTabView(contract: contract, client: client)
+                } else if let err = contractHolder.error {
+                    Text("Failed to load Topogram UI contract: \(err)")
+                        .padding()
+                } else {
+                    ProgressView("Loading Topogram Todo…")
+                }
+            }
+            .task {
+                await contractHolder.bootstrap()
+            }
+        }
+    }
+}
+
+@MainActor
+final class ContractHolder: ObservableObject {
+    @Published var contract: TodoUiContract?
+    @Published var client: TodoAPIClient?
+    @Published var error: String?
+
+    func bootstrap() async {
+        do {
+            let uiData = try TodoUiContract.loadBundled()
+            let apiData = try TodoAPIClient.loadBundledContracts()
+            let ui = try TodoUiContract(data: uiData)
+            let cli = try TodoAPIClient(contractsData: apiData)
+            contract = ui
+            client = cli
+        } catch {
+            self.error = String(describing: error)
+        }
+    }
+}

package/src/generator/surfaces/native/swiftui-templates/runtime/Visibility.swift

@@ -0,0 +1,183 @@
+import Foundation
+
+/// Port of web `visibility.ts` predicates used by dynamic screens.
+public enum Visibility {
+    public struct Rule {
+        public let predicate: String?
+        public let value: String?
+        public let claimValue: String?
+        public let ownershipField: String?
+        public let capabilityId: String?
+    }
+
+    public struct PrincipalOverride {
+        public var userId: String?
+        public var permissions: [String]?
+        public var roles: [String]?
+        public var claims: [String: Any]?
+        public var isAdmin: Bool?
+    }
+
+    public static func canShow(
+        rule: Rule?,
+        resource: [String: Any]?,
+        overrides: PrincipalOverride? = nil
+    ) -> Bool {
+        guard let rule else { return true }
+        guard let principal = currentPrincipal(overrides: overrides) else { return true }
+
+        switch rule.predicate {
+        case "permission":
+            guard let value = rule.value else { return true }
+            return principal.permissions.contains("*") || principal.permissions.contains(value)
+        case "ownership":
+            guard let value = rule.value else { return true }
+            if value == "none" { return true }
+            if value == "owner_or_admin", principal.isAdmin { return true }
+            let owner = ownerId(from: resource, field: rule.ownershipField)
+            return owner == principal.userId
+        case "claim":
+            let claim = rule.value
+            let expected = rule.claimValue
+            guard let claim else { return true }
+            let raw = principal.claims[claim]
+            if expected == nil || expected?.isEmpty == true {
+                if raw == nil { return false }
+                if let b = raw as? Bool { return b }
+                if let s = raw as? String { return !s.isEmpty }
+                return true
+            }
+            return String(describing: raw ?? "") == expected
+        default:
+            return true
+        }
+    }
+
+    private static func env(_ key: String) -> String {
+        ProcessInfo.processInfo.environment[key] ?? ""
+    }
+
+    private static func csv(_ raw: String) -> [String] {
+        raw.split(separator: ",").map { String($0).trimmingCharacters(in: .whitespaces) }.filter { !$0.isEmpty }
+    }
+
+    private static func parseClaims(_ raw: String) -> [String: Any] {
+        guard let data = raw.data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data),
+              let dict = obj as? [String: Any] else {
+            return [:]
+        }
+        return dict
+    }
+
+    private static func decodeJwtPayload(_ token: String) -> [String: Any]? {
+        let parts = token.split(separator: ".")
+        guard parts.count > 1 else { return nil }
+        var body = String(parts[1])
+        body = body.replacingOccurrences(of: "-", with: "+").replacingOccurrences(of: "_", with: "/")
+        let pad = 4 - body.count % 4
+        if pad < 4 { body += String(repeating: "=", count: pad) }
+        guard let data = Data(base64Encoded: body),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return nil
+        }
+        return json
+    }
+
+    private static func principalFromJwt(_ token: String) -> Principal? {
+        guard let payload = decodeJwtPayload(token) else { return nil }
+        let sub = payload["sub"] as? String ?? ""
+        let permissions = Set((payload["permissions"] as? [String]) ?? [])
+        let roles = Set((payload["roles"] as? [String]) ?? [])
+        let admin = payload["admin"] as? Bool ?? false
+        return Principal(
+            userId: sub,
+            permissions: permissions,
+            roles: roles,
+            claims: payload,
+            isAdmin: admin
+        )
+    }
+
+    private struct Principal {
+        let userId: String
+        let permissions: Set<String>
+        let roles: Set<String>
+        let claims: [String: Any]
+        let isAdmin: Bool
+    }
+
+    private static func currentPrincipal(overrides: PrincipalOverride?) -> Principal? {
+        let token = env("PUBLIC_TOPOGRAM_DEMO_AUTH_TOKEN")
+        let jwtPrincipal = token.isEmpty ? nil : principalFromJwt(token)
+        let envClaims = parseClaims(env("PUBLIC_TOPOGRAM_AUTH_CLAIMS"))
+        let userId = overrides?.userId
+            ?? env("PUBLIC_TOPOGRAM_AUTH_USER_ID")
+            ?? jwtPrincipal?.userId
+            ?? ""
+
+        var permissions = Set(csv(env("PUBLIC_TOPOGRAM_AUTH_PERMISSIONS")))
+        permissions.formUnion(jwtPrincipal?.permissions ?? [])
+        permissions.formUnion(overrides?.permissions ?? [])
+
+        var roles = Set(csv(env("PUBLIC_TOPOGRAM_AUTH_ROLES")))
+        if roles.isEmpty { roles = Set(csv(env("PUBLIC_TOPOGRAM_AUTH_ROLE"))) }
+        roles.formUnion(jwtPrincipal?.roles ?? [])
+        roles.formUnion(overrides?.roles ?? [])
+
+        let adminFlag =
+            (overrides?.isAdmin ?? false)
+                || env("PUBLIC_TOPOGRAM_AUTH_ADMIN").lowercased() == "true"
+                || jwtPrincipal?.isAdmin == true
+
+        var claims = jwtPrincipal?.claims ?? [:]
+        claims.merge(envClaims) { _, new in new }
+        if let o = overrides?.claims { claims.merge(o) { _, new in new } }
+
+        if token.isEmpty && userId.isEmpty && permissions.isEmpty && roles.isEmpty && claims.isEmpty && !adminFlag {
+            return nil
+        }
+
+        return Principal(
+            userId: userId,
+            permissions: permissions,
+            roles: roles,
+            claims: claims,
+            isAdmin: adminFlag
+        )
+    }
+
+    private static func ownerId(from resource: [String: Any]?, field: String?) -> String {
+        guard let resource else { return "" }
+        if let field {
+            if let v = resource[field] as? String { return v }
+        }
+        for key in ["owner_id", "assignee_id", "author_id", "user_id", "created_by_user_id"] {
+            if let v = resource[key] as? String { return v }
+        }
+        return ""
+    }
+
+    public static func visibilityRules(from screen: [String: Any]) -> [Rule] {
+        guard let raw = screen["visibility"] as? [[String: Any]] else { return [] }
+        return raw.map { entry in
+            let cap = entry["capability"] as? [String: Any]
+            return Rule(
+                predicate: entry["predicate"] as? String,
+                value: entry["value"] as? String,
+                claimValue: entry["claimValue"] as? String,
+                ownershipField: entry["ownershipField"] as? String,
+                capabilityId: cap?["id"] as? String
+            )
+        }
+    }
+
+    public static func canShowAction(_ capabilityId: String?, screen: [String: Any], resource: [String: Any]?) -> Bool {
+        guard let capabilityId else { return true }
+        let rules = visibilityRules(from: screen).filter { $0.capabilityId == capabilityId }
+        for rule in rules {
+            if !canShow(rule: rule, resource: resource) { return false }
+        }
+        return true
+    }
+}

package/src/generator/surfaces/services/express.d.ts

@@ -0,0 +1 @@
+export function generateExpressServer(graph: any, options?: any): any;