primitive-admin 1.0.54 → 1.0.56

package/dist/src/lib/swift-codegen/dbGenerator.js

@@ -0,0 +1,682 @@
+/**
+ * `databases codegen --lang swift` orchestrator (issue #1547, Phase 4).
+ *
+ * The Swift counterpart of `db-codegen/dbGenerator.ts`. Reads the SAME synced
+ * `database-types/*.toml` and emits ONE `<type>.generated.swift` per database
+ * type. Each file carries the type's record structs (read shape), per-op params
+ * structs (write shape), per-op result typealiases, and a typed `<Type>Ops`
+ * factory over the additive generic `executeOperation` overload on
+ * `DatabasesAPI` (the only published SDK surface for this generator).
+ *
+ * Design decisions realized (issue #1547):
+ *   - Operation + record metadata (which ops exist, their params, their result
+ *     descriptor, and per-model fields) is read from the SHARED `describeDbType`
+ *     IR — the SAME source the TS renderer (`db-codegen/dbGenerator.ts`) reads.
+ *     The Swift renderer reconstructs none of it (binding item 5), so the two
+ *     clients can never disagree on a type's surface.
+ *   - The generic result envelopes (`DBQueryResult<T>`, `DBMutationResult`, …)
+ *     live in the JsBaoClient SDK, NOT emitted per file — a Swift package
+ *     compiles all generated files into one module, so a per-file copy would
+ *     collide. Generated files reference the SDK envelopes (mirrors how Phase 3
+ *     put the workflow result envelopes in the SDK).
+ *   - Swift has no analog of TS `Pick<M, …>` / `Partial<M>`, so a query op with
+ *     a `pick`/`partial` projection types its rows as the open `JSONValue`
+ *     rather than a narrowed record (the same Fork-4 "no clean analog →
+ *     JSONValue" fallback the emitter uses for un-descended schema nodes). A
+ *     `full` projection over a known record types as `DBQueryResult<Record>`.
+ *   - Disk lifecycle (write / `--check` / orphan cleanup) delegates to the
+ *     shared `writeOrCheckGeneratedFiles`, scoped by an ownership BANNER
+ *     distinct from both the workflow Swift banner and the model codegen's, so
+ *     a shared Swift output dir stays safe.
+ */
+import * as path from "path";
+import { writeOrCheckGeneratedFiles, } from "../codegen-shared/generatedFiles.js";
+import { describeDbType, } from "../db-codegen/dbTypeIR.js";
+import { resolveRecordInterfaceName, opParamsInterfaceName, opResultAliasName, } from "../db-codegen/dbNaming.js";
+import { GENERATED_SWIFT_FILE_SUFFIX, SWIFT_BANNER_PREFIX } from "./generator.js";
+import { assertNoRetainedSiblingCollision, assertNoForeignGeneratorSymbolCollision, } from "./siblingSymbols.js";
+import { SwiftCodegenError } from "./schemaToSwift.js";
+import { structTypeName, enumTypeName, enumCaseNames, swiftPropertyName, unescapeIdentifier, } from "./swiftNaming.js";
+import { swiftTypeForDbFieldType, swiftTypeForDbParamType, } from "./dbSwiftTypes.js";
+/**
+ * Banner prefix stamped on every CLI-emitted database `.generated.swift` file.
+ * Distinct from both the workflow Swift banner (`// AUTO-GENERATED FROM
+ * workflows/`) and the model codegen's (`// Generated by swift-bao-codegen`),
+ * so none of the three generators' stale-sweeps ever deletes another's files
+ * when they share an output dir.
+ */
+export const DB_SWIFT_BANNER_PREFIX = "// AUTO-GENERATED FROM database-types/";
+/** Swift module the generated types + factory import. */
+const CLIENT_MODULE = "JsBaoClient";
+const INDENT = "    ";
+const CONFORMANCES = "Codable, Equatable, Sendable";
+/** A Swift string literal (runtime call passes the op name verbatim). */
+function swiftStringLiteral(s) {
+    const escaped = s
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+    return `"${escaped}"`;
+}
+/** Swift record struct type name for a model (shared naming + Swift sanitize). */
+export function dbRecordSwiftTypeName(modelName, className) {
+    return structTypeName(resolveRecordInterfaceName(modelName, className));
+}
+/** `<Op>Params` Swift struct name (shared PascalCase + Swift sanitize). */
+function dbParamsSwiftTypeName(opName) {
+    return structTypeName(opParamsInterfaceName(opName));
+}
+/** `<Op>Result` Swift typealias name. */
+function dbResultSwiftTypeName(opName) {
+    return structTypeName(opResultAliasName(opName));
+}
+/**
+ * Namespace `enum` name for a database type (issue #1687). Every symbol a type
+ * emits is nested under `public enum <Type>` (`securities-ref` →
+ * `SecuritiesRef`), so two DB types can never collide on a shared op symbol.
+ * Reuses the same `structTypeName` sanitizer (keyword suffixing + digit-leading
+ * `_` guard) the old `<Type>Ops` derivation used, so the namespace name is a
+ * legal Swift type identifier.
+ */
+export function dbNamespaceName(databaseType) {
+    return structTypeName(databaseType);
+}
+/**
+ * Swift standard-library / Foundation / `JsBaoClient` SDK type names that the
+ * generated `enum <Type>` body references UNQUALIFIED. If a database type's
+ * namespace enum takes one of these names, Swift name lookup inside the enum
+ * resolves the nested namespace first and shadows the real type — e.g. a
+ * `string` database emits `public enum String { … }`, and every `String`
+ * field, `CodingKeys` raw type, and string argument inside now resolves to the
+ * empty namespace enum instead of `Swift.String`, breaking `Codable` synthesis
+ * and rejecting string values (Codex [P1], #1687). The generated code never
+ * qualifies these references (`Swift.String`, `JsBaoClient.SortDirection`), so
+ * the only safe fix is to reject the namespace name at codegen time and have
+ * the user rename the database type — consistent with #1653's "clear
+ * codegen-time error, the user renames" decision.
+ *
+ * The set is the union of every type the emitter can reference inside the enum:
+ * the scalar/collection types from `dbSwiftTypes.ts`, the protocol conformances
+ * stamped on emitted structs/enums, and the SDK envelope + factory types.
+ */
+const RESERVED_NAMESPACE_NAMES = new Set([
+    // Swift stdlib scalars emitted for record fields / op params.
+    "String",
+    "Int",
+    "Double",
+    "Bool",
+    // Foundation types a field/param mapping could resolve to (defensive: the
+    // current mappings widen date → String, but keep these reserved so a future
+    // mapping can't be silently shadowed).
+    "Data",
+    "Date",
+    // Collection types behind the `[…]` / `?` sugar the emitter uses. Sugar isn't
+    // shadowed by a nested type, but an explicit reference would be — reserved as
+    // defense-in-depth, and a database type normalizing to one of these is a
+    // dangerous name regardless.
+    "Array",
+    "Dictionary",
+    "Optional",
+    "Set",
+    // Protocol conformances stamped on every emitted struct / nested enum.
+    "Codable",
+    "Decodable",
+    "Encodable",
+    "Equatable",
+    "Hashable",
+    "Sendable",
+    "CaseIterable",
+    "CodingKey",
+    // JsBaoClient SDK types the ops factory + result typealiases reference.
+    "JsBaoClient",
+    "JSONValue",
+    "SortDirection",
+    "DBQueryResult",
+    "DBMutationResult",
+    "DBCountResult",
+    "DBAggregateResult",
+    "DBApplyToQueryResult",
+    "DBPipelineResult",
+]);
+/**
+ * Validate that a database type's derived namespace enum name is safe to emit,
+ * and return it. Throws a named `SwiftCodegenError` (with a rename hint) for
+ * the whole class of unsafe names a server-accepted database type can produce
+ * (#1687):
+ *
+ *   1. **Degenerate `_`** — a type with no retained identifier characters
+ *      (empty after sanitize, or separator/emoji/punctuation-only, e.g. `--`,
+ *      `🎉`) normalizes to `_` via `structTypeName`. Swift reserves `_` as the
+ *      wildcard and rejects `public enum _` (Codex [P2]).
+ *   2. **Stdlib/SDK shadowing** — a name in `RESERVED_NAMESPACE_NAMES` shadows
+ *      a type the generated body references unqualified (Codex [P1]).
+ *
+ * Leading-digit residue (`123` → `_123`) and Swift reserved words (`self` →
+ * `Self_`, `any` → `Any_`) are already lifted into legal, non-shadowing
+ * identifiers by `structTypeName` (digit-leading `_` guard + keyword suffix),
+ * so they need no rejection here — only names that survive that sanitizer as
+ * `_` or as a real type identifier remain unsafe. The two in-run / retained-
+ * sibling namespace-NAME collision guards (two database types whose names
+ * normalize to the SAME enum) live in `generateDbSwiftTypes`; this check
+ * covers the single-type unsafe-name class.
+ */
+export function assertSafeNamespaceName(databaseType, sourceFile) {
+    const namespaceName = dbNamespaceName(databaseType);
+    if (namespaceName === "_") {
+        throw new SwiftCodegenError(`swift db codegen: database type "${databaseType}" has no letters or ` +
+            `digits to form a Swift type identifier, so it normalizes to the ` +
+            `reserved wildcard "_" — the compiler rejects "public enum _". Rename ` +
+            `the database type to include at least one letter.`, { sourceFile });
+    }
+    if (RESERVED_NAMESPACE_NAMES.has(namespaceName)) {
+        throw new SwiftCodegenError(`swift db codegen: database type "${databaseType}" normalizes to the ` +
+            `Swift namespace "public enum ${namespaceName}", which shadows the ` +
+            `standard-library / JsBaoClient SDK type "${namespaceName}" that the ` +
+            `generated code references unqualified (record fields, op results, or ` +
+            `the ops factory). Inside the enum "${namespaceName}" would resolve to ` +
+            `the empty namespace instead of the real type, breaking compilation. ` +
+            `Rename the database type so it does not normalize to "${namespaceName}".`, { sourceFile });
+    }
+    return namespaceName;
+}
+/**
+ * Nested factory struct name inside a DB-type namespace: `Orders.Ops` (issue
+ * #1687). Fixed leaf name — the enclosing `enum <Type>` supplies the
+ * qualification, so it no longer needs the `<Type>` prefix.
+ */
+const DB_OPS_STRUCT_NAME = "Ops";
+/**
+ * Nested static factory func name: `Orders.ops(client, databaseId:)` (issue
+ * #1687). Replaces the old top-level free `<type>Ops(...)` function.
+ */
+const DB_OPS_FACTORY_NAME = "ops";
+/**
+ * Render a nested `String`-raw enum for a field/param declaring `enum = [...]`.
+ * Matches the JSON-Schema emitter's + model codegen's nested-enum shape.
+ */
+function renderStringEnum(typeName, values, indent) {
+    const pad = INDENT.repeat(indent);
+    const inner = INDENT.repeat(indent + 1);
+    const cases = enumCaseNames(values);
+    const lines = [
+        `${pad}public enum ${typeName}: String, Codable, CaseIterable, Sendable {`,
+    ];
+    for (const c of cases)
+        lines.push(`${inner}case ${c.name} = ${swiftStringLiteral(c.raw)}`);
+    lines.push(`${pad}}`);
+    return lines.join("\n");
+}
+/**
+ * Render a Swift `struct` from resolved members + nested-enum declarations. A
+ * public memberwise initializer is always emitted (the synthesized one is not
+ * public across module boundaries); `CodingKeys` only when a wire key isn't a
+ * legal/idiomatic Swift identifier. No custom Codable is needed — DB records /
+ * params have no oneOf / open-object / required-nullable cases.
+ */
+function renderStruct(typeName, members, nestedEnumDecls) {
+    const b = INDENT;
+    const needsCodingKeys = members.some((m) => unescapeIdentifier(m.swiftName) !== m.wireKey);
+    const out = [`public struct ${typeName}: ${CONFORMANCES} {`];
+    for (const decl of nestedEnumDecls)
+        out.push(decl);
+    if (nestedEnumDecls.length > 0)
+        out.push("");
+    for (const m of members) {
+        out.push(`${b}public var ${m.swiftName}: ${m.type}${m.optional ? "?" : ""}`);
+    }
+    if (members.length > 0)
+        out.push("");
+    // Public memberwise initializer.
+    if (members.length === 0) {
+        out.push(`${b}public init() {}`);
+    }
+    else {
+        out.push(`${b}public init(`);
+        members.forEach((m, i) => {
+            const type = `${m.type}${m.optional ? "?" : ""}`;
+            const def = m.optional ? " = nil" : "";
+            out.push(`${b}${b}${m.swiftName}: ${type}${def}${i < members.length - 1 ? "," : ""}`);
+        });
+        out.push(`${b}) {`);
+        for (const m of members)
+            out.push(`${b}${b}self.${m.swiftName} = ${m.swiftName}`);
+        out.push(`${b}}`);
+    }
+    if (needsCodingKeys) {
+        out.push("");
+        out.push(`${b}public enum CodingKeys: String, CodingKey {`);
+        for (const m of members) {
+            const bare = unescapeIdentifier(m.swiftName);
+            const rhs = bare !== m.wireKey ? ` = ${swiftStringLiteral(m.wireKey)}` : "";
+            out.push(`${b}${b}case ${m.swiftName}${rhs}`);
+        }
+        out.push(`${b}}`);
+    }
+    out.push(`}`);
+    return out.join("\n");
+}
+/**
+ * Render one record model. Empty (no declared fields and no stamped fields) →
+ * an open typealias (`[String: JSONValue]`), mirroring the TS empty-record
+ * `Record<string, unknown>` — a Database-DO record is schemaless, so the empty
+ * shape stays open.
+ */
+function renderRecordStruct(typeName, fields, stampedFields) {
+    const members = [];
+    const nestedEnums = [];
+    const declared = new Set();
+    for (const f of fields) {
+        declared.add(f.name);
+        let type;
+        if (f.type === "string" && Array.isArray(f.enum) && f.enum.length > 0) {
+            const enumName = enumTypeName(f.name);
+            nestedEnums.push(renderStringEnum(enumName, f.enum, 1));
+            type = enumName;
+        }
+        else {
+            type = swiftTypeForDbFieldType(f.type);
+        }
+        members.push({
+            wireKey: f.name,
+            swiftName: swiftPropertyName(f.name),
+            type,
+            optional: !f.required,
+        });
+    }
+    // Server-stamped fields → optional String props if not already declared.
+    for (const stamped of stampedFields) {
+        if (declared.has(stamped))
+            continue;
+        declared.add(stamped);
+        members.push({
+            wireKey: stamped,
+            swiftName: swiftPropertyName(stamped),
+            type: "String",
+            optional: true,
+        });
+    }
+    if (members.length === 0) {
+        return `public typealias ${typeName} = [String: JSONValue]`;
+    }
+    return renderStruct(typeName, members, nestedEnums);
+}
+/** Render one op-params struct (write shape). */
+function renderParamsStruct(typeName, op) {
+    const members = [];
+    const nestedEnums = [];
+    for (const p of op.params) {
+        let type;
+        if (p.type === "string" && Array.isArray(p.enum) && p.enum.length > 0) {
+            const enumName = enumTypeName(p.name);
+            nestedEnums.push(renderStringEnum(enumName, p.enum, 1));
+            type = swiftTypeForDbParamType(p.type, enumName, p.items);
+        }
+        else if (p.type === "array" &&
+            p.items === "string" &&
+            Array.isArray(p.enum) &&
+            p.enum.length > 0) {
+            const enumName = enumTypeName(p.name);
+            nestedEnums.push(renderStringEnum(enumName, p.enum, 1));
+            type = swiftTypeForDbParamType(p.type, enumName, p.items);
+        }
+        else {
+            type = swiftTypeForDbParamType(p.type, undefined, p.items);
+        }
+        members.push({
+            wireKey: p.name,
+            swiftName: swiftPropertyName(p.name),
+            type,
+            optional: !p.required,
+        });
+    }
+    // A no-param op still gets an empty struct so the factory can construct `()`.
+    return renderStruct(typeName, members, nestedEnums);
+}
+/**
+ * Swift `DBQueryResult<…>` element for a query op / returning pipeline step.
+ * A known record with a `full` projection → `DBQueryResult<Record>`. A
+ * `pick`/`partial` projection has no Swift Pick/Partial analog → open rows
+ * (`DBQueryResult<JSONValue>`); a null record likewise.
+ */
+function queryResultSwift(recordTypeName, projection) {
+    if (recordTypeName === null)
+        return "DBQueryResult<JSONValue>";
+    const kind = projection?.kind ?? "full";
+    return kind === "full"
+        ? `DBQueryResult<${recordTypeName}>`
+        : "DBQueryResult<JSONValue>";
+}
+/** Resolve the Swift result type expression for an op. */
+function resultSwiftType(op, recordTypeByModel) {
+    const recordFor = (model) => model ? recordTypeByModel[model] ?? null : null;
+    switch (op.opType) {
+        case "query":
+            return queryResultSwift(recordFor(op.resultModelName), op.projection);
+        case "mutation":
+            return "DBMutationResult";
+        case "count":
+            return "DBCountResult";
+        case "aggregate":
+            return "DBAggregateResult";
+        case "applyToQuery":
+            return "DBApplyToQueryResult";
+        case "pipeline": {
+            const d = op.pipelineReturn ?? { kind: "opaque" };
+            switch (d.kind) {
+                case "query":
+                    return queryResultSwift(recordFor(d.modelName), d.projection);
+                case "count":
+                    return "DBCountResult";
+                case "aggregate":
+                    return "DBAggregateResult";
+                case "opaque":
+                default:
+                    return "DBPipelineResult";
+            }
+        }
+        default:
+            // Unknown op type → the opaque JSONValue (parity with the TS `unknown`).
+            return "JSONValue";
+    }
+}
+/**
+ * Render the typed `Ops` factory nested under the type's namespace enum: a
+ * struct with one `async throws` method per op, each binding `<Op>Params` in
+ * and `<Op>Result` out over the generic `DatabasesAPI.executeOperation`
+ * overload, plus a static `ops(client, databaseId:)` factory on the namespace
+ * (issue #1687). Returns "" for a type with no operations. The emitted block is
+ * un-indented here; `renderDbTypeSwiftFile` wraps the whole per-type body in
+ * `public enum <Type> { … }` and indents it one level.
+ */
+function renderOpsFactory(databaseType, ops) {
+    if (ops.length === 0)
+        return "";
+    const namespaceName = dbNamespaceName(databaseType);
+    const b = INDENT;
+    const lines = [
+        `/// Typed accessor for \`${databaseType}\` operations. Obtain one with`,
+        `/// \`${namespaceName}.${DB_OPS_FACTORY_NAME}(client, databaseId:)\`.`,
+        `public struct ${DB_OPS_STRUCT_NAME}: Sendable {`,
+        `${b}public let client: JsBaoClient`,
+        `${b}public let databaseId: String`,
+        ``,
+        `${b}public init(client: JsBaoClient, databaseId: String) {`,
+        `${b}${b}self.client = client`,
+        `${b}${b}self.databaseId = databaseId`,
+        `${b}}`,
+    ];
+    for (const op of ops) {
+        const method = swiftPropertyName(op.opName);
+        const paramsType = dbParamsSwiftTypeName(op.opName);
+        const resultType = dbResultSwiftTypeName(op.opName);
+        const nameLiteral = swiftStringLiteral(op.opName);
+        // With params: `method(_ params:, options…)`. Without: options only, and
+        // the empty params struct is constructed for the call.
+        const paramLine = op.hasParams ? `${b}${b}_ params: ${paramsType},` : null;
+        const paramsArg = op.hasParams ? "params" : `${paramsType}()`;
+        lines.push(``, `${b}/// Execute the \`${op.opName}\` operation.`, `${b}public func ${method}(`);
+        if (paramLine)
+            lines.push(paramLine);
+        lines.push(`${b}${b}limit: Int? = nil,`, `${b}${b}cursor: String? = nil,`, `${b}${b}direction: SortDirection? = nil,`, `${b}${b}timing: Bool? = nil`, `${b}) async throws -> ${resultType} {`, `${b}${b}try await client.databases.executeOperation(`, `${b}${b}${b}databaseId: databaseId,`, `${b}${b}${b}name: ${nameLiteral},`, `${b}${b}${b}params: ${paramsArg},`, `${b}${b}${b}limit: limit,`, `${b}${b}${b}cursor: cursor,`, `${b}${b}${b}direction: direction,`, `${b}${b}${b}timing: timing`, `${b}${b})`, `${b}}`);
+    }
+    lines.push(`}`, ``);
+    lines.push(`/// Typed operations factory for the \`${databaseType}\` database type.`, `public static func ${DB_OPS_FACTORY_NAME}(_ client: JsBaoClient, databaseId: String) -> ${DB_OPS_STRUCT_NAME} {`, `${b}${DB_OPS_STRUCT_NAME}(client: client, databaseId: databaseId)`, `}`);
+    return lines.join("\n");
+}
+/**
+ * Indent every non-empty line of a rendered Swift block by `levels` levels
+ * (blank lines stay blank, preserving struct-internal spacing). Used to nest a
+ * type's declarations one level inside its `enum <Type>` namespace (#1687).
+ */
+function indentSwiftLines(text, levels) {
+    const pad = INDENT.repeat(levels);
+    return text
+        .split("\n")
+        .map((line) => (line.length === 0 ? line : pad + line))
+        .join("\n");
+}
+/**
+ * Render the full `<type>.generated.swift` content for one database-type TOML.
+ * Pure — exported so tests can assert on the string directly. Throws on a Swift
+ * record type-name collision between two models (mirrors the TS collision guard).
+ */
+export function renderDbTypeSwiftFile(input) {
+    const ir = describeDbType(input);
+    const sourceFile = `database-types/${ir.databaseType}.toml`;
+    // Reject an unsafe namespace enum name (empty/separator-only `_`, or a name
+    // that shadows a stdlib/SDK type the body references) before any rendering,
+    // with a clear rename hint (#1687). `structTypeName` already lifts leading
+    // digits and Swift keywords into legal identifiers, so only the degenerate
+    // and shadowing cases remain. The validated name is reused at emission below.
+    const namespaceName = assertSafeNamespaceName(ir.databaseType, sourceFile);
+    // Within-file collision guards (issue #1653). A single
+    // `<type>.generated.swift` compiles as one Swift file, so every TOP-LEVEL
+    // symbol it declares — record structs, per-op `<Op>Params` structs,
+    // `<Op>Result` typealiases, and (for a type with operations) the `<Type>Ops`
+    // struct plus its free-function factory — shares ONE namespace and must be
+    // unique. The earlier guards kept records and op-params in SEPARATE maps, so a
+    // record whose `class_name` resolves to `<Type>Ops` (or to an op's
+    // params/result name) slipped through uncaught (Codex [P2]). Track them all in
+    // one registry keyed on the emitted symbol.
+    //
+    // The `<Type>Ops` METHODS live in a SEPARATE (struct-member) namespace, and
+    // Swift permits overloading a method name as long as the parameter lists
+    // differ. So two ops that normalize to the same method name are tracked apart
+    // by their emitted overload SIGNATURE, not the bare method basename: `get.user`
+    // and `getuser` produce DISTINCT `<Op>Params` types (`GetUserParams` via
+    // `dbNaming.pascalCase`, which splits on `.`, vs `GetuserParams`) but the SAME
+    // `getuser` method name (via `swiftPropertyName`, which drops `.`). When both
+    // ops take params, each emits `getuser(_ params: <distinct type>, …)` — legal
+    // Swift overloads that compile, so the check must ALLOW them (issue #1704). A
+    // bare method-name check rejected them as a false positive. Two ops truly
+    // redeclare only when the method name AND the parameter signature match — e.g.
+    // two PARAM-LESS ops that both emit `getuser(limit:…)` (no `_ params:` at all).
+    // The params-type guard alone could never catch that case (Codex [P1]).
+    const recordTypeByModel = {};
+    const topLevelSymbol = new Map(); // symbol → owner description
+    const methodOwner = new Map(); // op method signature → opName
+    const registerTopLevel = (symbol, owner, schemaPath) => {
+        const prior = topLevelSymbol.get(symbol);
+        if (prior !== undefined && prior !== owner) {
+            throw new SwiftCodegenError(`swift db codegen: symbol collision in database type "${ir.databaseType}" — ` +
+                `${prior} and ${owner} both produce Swift symbol "${symbol}" in the ` +
+                `"${dbNamespaceName(ir.databaseType)}" namespace, ` +
+                `which redeclares when the file compiles. Rename one, or add a ` +
+                `class_name override, so the two differ after Swift normalization.`, { sourceFile, schemaPath });
+        }
+        topLevelSymbol.set(symbol, owner);
+    };
+    // Record structs.
+    for (const rec of ir.records) {
+        const typeName = dbRecordSwiftTypeName(rec.modelName, rec.className);
+        registerTopLevel(typeName, `record "${rec.modelName}"`, "models");
+        recordTypeByModel[rec.modelName] = typeName;
+    }
+    // Per-op params structs, result typealiases, and factory method names.
+    for (const op of ir.ops) {
+        registerTopLevel(dbParamsSwiftTypeName(op.opName), `operation "${op.opName}" params`, "operations");
+        registerTopLevel(dbResultSwiftTypeName(op.opName), `operation "${op.opName}" result`, "operations");
+        const method = swiftPropertyName(op.opName);
+        // Key on the emitted Swift overload signature, not the bare method name. All
+        // ops share the same trailing `limit`/`cursor`/`direction`/`timing` labels
+        // and types, so the only thing that distinguishes two same-named methods is
+        // the leading `_ params:` parameter: a param-taking op emits its distinct
+        // `<Op>Params` type, a param-less op emits none. Ops with distinct param
+        // structs are therefore legal overloads (issue #1704); only ops that match
+        // on BOTH the method name and this signature redeclare.
+        const signature = op.hasParams
+            ? `${method}(${dbParamsSwiftTypeName(op.opName)})`
+            : `${method}()`;
+        const priorOp = methodOwner.get(signature);
+        if (priorOp !== undefined && priorOp !== op.opName) {
+            throw new SwiftCodegenError(`swift db codegen: operation method-signature collision in database type ` +
+                `"${ir.databaseType}" — operations "${priorOp}" and "${op.opName}" ` +
+                `both emit the Swift method "${method}" with the same parameter ` +
+                `signature in the "${dbNamespaceName(ir.databaseType)}.${DB_OPS_STRUCT_NAME}" factory, which redeclares when the file ` +
+                `compiles. Rename one ` +
+                `operation, or give them distinct parameters, so the two differ ` +
+                `after Swift normalization.`, { sourceFile, schemaPath: "operations" });
+        }
+        methodOwner.set(signature, op.opName);
+    }
+    // The nested `Ops` struct + its static `ops` factory (emitted only when the
+    // type has operations — see `renderOpsFactory`). Both live inside the type's
+    // `enum <Type>` namespace alongside the records/params/results, so a record
+    // whose name resolves to `Ops` collides here instead of at `swift build`.
+    if (ir.ops.length > 0) {
+        registerTopLevel(DB_OPS_STRUCT_NAME, `the \`${DB_OPS_STRUCT_NAME}\` operations struct`, "operations");
+        registerTopLevel(DB_OPS_FACTORY_NAME, `the \`${DB_OPS_FACTORY_NAME}\` operations factory`, "operations");
+    }
+    const banner = [
+        `// AUTO-GENERATED FROM database-types/${ir.databaseType}.toml — DO NOT EDIT.`,
+        "// Run `primitive databases codegen --lang swift` to regenerate.",
+        `// fingerprint: ${ir.fingerprint}`,
+    ].join("\n");
+    const imports = ["import Foundation", `import ${CLIENT_MODULE}`].join("\n");
+    const bodyBlocks = [];
+    // Record structs, sorted by Swift type name for deterministic output.
+    const sortedRecords = [...ir.records].sort((a, b) => recordTypeByModel[a.modelName].localeCompare(recordTypeByModel[b.modelName]));
+    for (const rec of sortedRecords) {
+        bodyBlocks.push(renderRecordStruct(recordTypeByModel[rec.modelName], rec.fields, ir.stampedFields));
+    }
+    // Per-op params structs + result aliases (ops already sorted by op name).
+    for (const op of ir.ops) {
+        bodyBlocks.push(renderParamsStruct(dbParamsSwiftTypeName(op.opName), op));
+        bodyBlocks.push(`public typealias ${dbResultSwiftTypeName(op.opName)} = ${resultSwiftType(op, recordTypeByModel)}`);
+    }
+    const factory = renderOpsFactory(ir.databaseType, ir.ops);
+    if (factory)
+        bodyBlocks.push(factory);
+    // Nest every symbol under a caseless `public enum <Type>` namespace (#1687),
+    // so `Orders.ListParams` and `Invoices.ListParams` can never collide when all
+    // `.generated.swift` files compile into one module. An empty database type
+    // still emits `public enum <Type> {}` — stable, deterministic type presence
+    // (sponsor decision 2026-07-19). `namespaceName` was validated + derived at
+    // the top of this function via `assertSafeNamespaceName`.
+    const namespaced = bodyBlocks.length === 0
+        ? `public enum ${namespaceName} {}`
+        : `public enum ${namespaceName} {\n${indentSwiftLines(bodyBlocks.join("\n\n"), 1)}\n}`;
+    return [banner, imports, namespaced].join("\n\n") + "\n";
+}
+/**
+ * Run Swift database codegen end-to-end. One `<type>.generated.swift` per
+ * database type; delegates the disk lifecycle to the shared writer/checker with
+ * banner-scoped ownership so a shared Swift output dir stays safe.
+ */
+export async function generateDbSwiftTypes(options) {
+    const outAbs = path.resolve(options.outputDir);
+    // Run-scoped namespace registry: normalized namespace enum name → the
+    // database type that emitted it. Namespacing every symbol under
+    // `public enum <Type>` (issue #1687) makes cross-type symbol collisions
+    // structurally impossible — `Orders.ListParams` and `Invoices.ListParams`
+    // can never redeclare. The ONE collision that survives is two DB types whose
+    // NAMES normalize to the SAME namespace enum identifier (e.g. `my-type` and
+    // `my_type` both → `MyType`); they emit two `enum MyType` blocks that
+    // redeclare when the files compile into one module. Fork 3 (sponsor decision
+    // 2026-07-19): scope this guard to DB namespaces within the run, and drop the
+    // old cross-type OP-SYMBOL registry (that collision class no longer exists
+    // after namespacing).
+    //
+    // This in-run map only catches the namespace-name clash when BOTH colliding
+    // types are in `options.inputs` — i.e. a full run. A filtered / single-type
+    // run (`singleType: true`) has just the selected type in `inputs` and keeps
+    // its siblings on disk untouched (`fullOwnership: false`), so a retained
+    // `my_type.generated.swift` already declaring `public enum MyType` would
+    // never enter this map and would still redeclare at `swift build`. The
+    // retained-sibling guard below closes that residual for filtered runs — it
+    // compares the NAMESPACE NAME (not the old op symbols) against siblings'
+    // declared top-level symbols.
+    const namespaceOwner = new Map();
+    const filesToWrite = new Map();
+    for (const input of options.inputs) {
+        // renderDbTypeSwiftFile throws on the within-file record/op collisions
+        // (classes 2 + record guard) before we reach the namespace registry.
+        const content = renderDbTypeSwiftFile(input);
+        const namespace = dbNamespaceName(input.databaseType);
+        const prior = namespaceOwner.get(namespace);
+        if (prior !== undefined && prior !== input.databaseType) {
+            throw new SwiftCodegenError(`swift db codegen: namespace collision — database types "${prior}" and ` +
+                `"${input.databaseType}" both normalize to the Swift namespace ` +
+                `"${namespace}", so each emits a "public enum ${namespace}" that ` +
+                `redeclares when all .generated.swift files compile into one module. ` +
+                `Rename one database type so the two differ after Swift normalization.`, { sourceFile: `database-types/${input.databaseType}.toml` });
+        }
+        namespaceOwner.set(namespace, input.databaseType);
+        const filePath = path.join(outAbs, `${input.databaseType}${GENERATED_SWIFT_FILE_SUFFIX}`);
+        filesToWrite.set(filePath, content);
+    }
+    // Filtered-run retained-sibling namespace-name collision (issue #1687). A
+    // `singleType` run renders only the selected type; its sibling
+    // `.generated.swift` files stay on disk but never enter `namespaceOwner`
+    // above, so this run's `public enum <Type>` could still redeclare against a
+    // retained sibling that declares the SAME enum (e.g. this run emits
+    // `enum MyType` for `my-type` while `my_type.generated.swift` on disk already
+    // declares `enum MyType`). Each DB file nests everything under one
+    // `public enum <Type>`, so a sibling's ONLY top-level symbol IS its namespace
+    // name — comparing the run's emitted namespace names against the siblings'
+    // parsed top-level symbols is exactly the namespace-name check. `emitted` is
+    // the run's namespace-name → owning database type map; the run's own output
+    // paths are excluded, so a filtered re-run of the same type never
+    // self-collides. (Full runs are already covered by `namespaceOwner` above.)
+    if (options.singleType === true) {
+        await assertNoRetainedSiblingCollision({
+            outputDir: outAbs,
+            ownershipBanner: DB_SWIFT_BANNER_PREFIX,
+            suffix: GENERATED_SWIFT_FILE_SUFFIX,
+            emitted: namespaceOwner,
+            ownPaths: filesToWrite.keys(),
+            makeError: ({ symbol, owner, siblingStem }) => new SwiftCodegenError(`swift db codegen: namespace collision with a retained sibling — ` +
+                `database type "${owner}" (this run) and the existing ` +
+                `"${siblingStem}${GENERATED_SWIFT_FILE_SUFFIX}" both declare the ` +
+                `Swift namespace "public enum ${symbol}", which redeclares when all ` +
+                `.generated.swift files compile into one module. A filtered ` +
+                `(single-type) run does not regenerate siblings, so both files ` +
+                `coexist. Rename one database type so the two differ after Swift ` +
+                `normalization, or regenerate the whole output directory.`, { sourceFile: `database-types/${owner}.toml` }),
+        });
+    }
+    // Cross-generator namespace collision (issue #1857). A database type's
+    // namespace enum name can match a top-level symbol a WORKFLOW-generated file
+    // already declares in a shared output dir — e.g. db type `foo-input` emits
+    // `public enum FooInput` while workflow `foo` emits a top-level struct
+    // `FooInput`. Their filenames differ, so the foreign-banner WRITE guard below
+    // (path-only) never trips, and the retained-sibling guard above only scans
+    // DB-owned files. This scan reads the workflow-owned siblings' declared
+    // top-level symbols and throws if the run's namespace name collides with any.
+    // It runs on every db run (not just filtered), because a full db run does not
+    // regenerate workflow files — they coexist regardless of ordering.
+    await assertNoForeignGeneratorSymbolCollision({
+        outputDir: outAbs,
+        foreignBanner: SWIFT_BANNER_PREFIX,
+        suffix: GENERATED_SWIFT_FILE_SUFFIX,
+        emitted: namespaceOwner,
+        makeError: ({ symbol, owner, siblingStem }) => new SwiftCodegenError(`swift db codegen: namespace collision with a workflow-generated file — ` +
+            `database type "${owner}" emits the Swift namespace ` +
+            `"public enum ${symbol}", but the existing ` +
+            `"${siblingStem}${GENERATED_SWIFT_FILE_SUFFIX}" (owned by the workflow ` +
+            `Swift generator) already declares a top-level "${symbol}" in the same ` +
+            `output directory, which redeclares when all .generated.swift files ` +
+            `compile into one module. Rename the database type or the "${siblingStem}" ` +
+            `workflow so the two differ after Swift normalization, or give one ` +
+            `generator a separate --output directory.`, { sourceFile: `database-types/${owner}.toml` }),
+    });
+    return await writeOrCheckGeneratedFiles({
+        outputDir: outAbs,
+        filesToWrite,
+        check: options.check,
+        fullOwnership: options.singleType !== true,
+        generatedSuffix: GENERATED_SWIFT_FILE_SUFFIX,
+        ownershipBanner: DB_SWIFT_BANNER_PREFIX,
+        // Class 3b: never clobber a file owned by the workflow Swift generator.
+        foreignOwnershipBanners: [SWIFT_BANNER_PREFIX],
+        onForeignBannerCollision: ({ filePath, foreignBanner }) => new SwiftCodegenError(`swift codegen: output collision — this run would overwrite ` +
+            `"${path.basename(filePath)}" in the shared output directory, which ` +
+            `is already owned by a different generator (banner ` +
+            `"${foreignBanner.trim()}"). A database type and a workflow key with ` +
+            `the same name cannot share an output directory; give one generator a ` +
+            `separate --output directory.`),
+    });
+}
+//# sourceMappingURL=dbGenerator.js.map