primitive-admin 1.1.0-alpha.47 → 1.1.0-alpha.49

package/dist/src/lib/db-codegen/dbTypeIR.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Shared database-type operation IR (issue #1547, Phase 4).
+ *
+ * `describeDbType` resolves ONE database-type TOML into a naming-neutral
+ * descriptor of its record models and operations — the record fields (with
+ * inferred required-ness), the per-op input params, and the per-op result
+ * descriptor (query projection #1439, mutation, count, aggregate,
+ * applyToQuery, pipeline return #1437). It performs NO language-specific
+ * naming: the TS renderer (`dbGenerator.ts`) and the Swift renderer
+ * (`swift-codegen/dbGenerator.ts`) both consume this SAME IR and each apply
+ * their own identifier rules. Neither renderer re-walks the op definitions, so
+ * the two clients can never disagree on which operations a database type
+ * exposes, what params they take, or what shape they return (issue #1547
+ * binding item 5 — the same "shared operation IR, no metadata reconstruction"
+ * contract Phase 3's `describeWorkflowInvoker` gives the workflow invoker).
+ *
+ * The resolution logic here was lifted verbatim from `renderDbTypeFile`'s
+ * former inline body; the only change is that result descriptors reference a
+ * MODEL NAME (naming-neutral) rather than a resolved TS interface name, so the
+ * Swift renderer can map the same model to its own type name.
+ */
+import type { RecordField, ParamField, ProjectionClassification } from "./dbTemplates.js";
+export interface DbCodegenInput {
+    /** Database type name (drives the output filename). */
+    databaseType: string;
+    /** Path to the source `database-types/<type>.toml` file. */
+    tomlPath: string;
+    /** Raw TOML content (already read from disk). */
+    tomlContent: string;
+}
+/**
+ * Naming-neutral form of a pipeline op's resolved `return` step (#1437). Same
+ * shape as `dbTemplates.PipelineReturnDescriptor` but keyed on the returning
+ * step's MODEL NAME instead of a resolved interface name, so each renderer maps
+ * it to its own record type. `opaque` → the generic pipeline-result envelope.
+ */
+export type PipelineReturnIR = {
+    kind: "query";
+    modelName: string | null;
+    projection: ProjectionClassification;
+} | {
+    kind: "count";
+} | {
+    kind: "aggregate";
+} | {
+    kind: "opaque";
+};
+/** One record model on a database type (read shape), naming-neutral. */
+export interface DbRecordIR {
+    /** TOML model name (e.g. `accounts`). */
+    modelName: string;
+    /** Optional `class_name` override from the schema (naming input). */
+    className?: string;
+    /**
+     * Record fields with required-ness already resolved (schema `required`,
+     * `id` auto-assign, and op-params inference #842 folded in). Rendered into a
+     * struct/interface member per field.
+     */
+    fields: RecordField[];
+}
+/** One operation on a database type, naming-neutral. */
+export interface DbOpIR {
+    /** Exact operation name (the `executeOperation` string argument). */
+    opName: string;
+    /** Operation type (`query|mutation|count|aggregate|pipeline|applyToQuery`). */
+    opType: string;
+    /** Declared input params (sorted by name), write shape. */
+    params: ParamField[];
+    /** Whether the op declares any params (a param-less op is callable bare). */
+    hasParams: boolean;
+    /**
+     * For a `query` op, the model its result rows are typed over — or null when
+     * the op has no model or the model has no record schema (the result falls
+     * back to an open/untyped row).
+     */
+    resultModelName: string | null;
+    /** For a `query` op, how its static `projection` narrows the record (#1439). */
+    projection?: ProjectionClassification;
+    /** For a `pipeline` op, the resolved `return`-step shape (#1437). */
+    pipelineReturn?: PipelineReturnIR;
+}
+/**
+ * One realtime subscription on a database type (#1544 Phase 2), naming-neutral.
+ *
+ * `modelName` is guaranteed to name a model that has a record schema on this
+ * type (`describeDbType` throws otherwise — a subscription can't be typed
+ * against a model the type doesn't declare; matches the server's
+ * `modelName is required` create validation). `select` fields, when present,
+ * are each guaranteed to be a known member of that record (declared field or
+ * stamped field) unless the record is the open `Record<string, unknown>` form,
+ * so the renderer can emit a valid `Pick<Record, …>` without a further guard.
+ */
+export interface DbSubscriptionIR {
+    /** Subscription key (the `subscribe()` string argument). */
+    subscriptionKey: string;
+    /** Model whose record type binds the delivered change payload. */
+    modelName: string;
+    /**
+     * Projected field names when the subscription declares `select` (→ the event
+     * record narrows to `Pick<Record, …fields>`), else null (→ the full record).
+     * Sorted + de-duplicated for deterministic output.
+     */
+    select: string[] | null;
+}
+/** The shared, naming-neutral descriptor of one database type. */
+export interface DbTypeIR {
+    /** Database type name (drives the output filename). */
+    databaseType: string;
+    /** Content fingerprint stamped in the generated header. */
+    fingerprint: string;
+    /** Server-stamped field names appended as OPTIONAL props on every record. */
+    stampedFields: string[];
+    /** Record models (schema order; renderers sort by their own type name). */
+    records: DbRecordIR[];
+    /** Operations, sorted by op name for deterministic output. */
+    ops: DbOpIR[];
+    /** Subscriptions, sorted by subscription key for deterministic output. */
+    subscriptions: DbSubscriptionIR[];
+}
+/**
+ * Resolve a database-type TOML into the shared, naming-neutral IR. Pure: no
+ * I/O beyond parsing the passed content. Both the TS and Swift renderers call
+ * this so their op/record metadata can never diverge.
+ */
+export declare function describeDbType(input: DbCodegenInput): DbTypeIR;
+/**
+ * Infer the scalar element type for op params consumed by a `$in`/`$nin`
+ * filter operator (#1488). See the original doc in `dbGenerator.ts` — moved
+ * here unchanged. Returns a map of param name → element TS type
+ * (`"unknown"` sentinel → widen to an untyped element).
+ */
+export declare function inferArrayParamElementTypes(op: any, fieldTypesByModel: Map<string, Map<string, string>>): Map<string, string>;
+/**
+ * Per-model result of {@link inferRequiredRecordFields}. Shaped as an object so
+ * it can grow additional inferred metadata later without changing callers.
+ */
+export interface InferredRecordModelInfo {
+    /** Record field names promoted to non-optional by op-params inference. */
+    fields: Set<string>;
+}
+/**
+ * Infer which record fields are always supplied at create time from `save` op
+ * params (#842). See the original doc in `dbGenerator.ts` — moved here
+ * unchanged.
+ */
+export declare function inferRequiredRecordFields(operations: any[]): Map<string, InferredRecordModelInfo>;

package/dist/src/lib/db-codegen/dbTypeIR.js

@@ -0,0 +1,517 @@
+/**
+ * Shared database-type operation IR (issue #1547, Phase 4).
+ *
+ * `describeDbType` resolves ONE database-type TOML into a naming-neutral
+ * descriptor of its record models and operations — the record fields (with
+ * inferred required-ness), the per-op input params, and the per-op result
+ * descriptor (query projection #1439, mutation, count, aggregate,
+ * applyToQuery, pipeline return #1437). It performs NO language-specific
+ * naming: the TS renderer (`dbGenerator.ts`) and the Swift renderer
+ * (`swift-codegen/dbGenerator.ts`) both consume this SAME IR and each apply
+ * their own identifier rules. Neither renderer re-walks the op definitions, so
+ * the two clients can never disagree on which operations a database type
+ * exposes, what params they take, or what shape they return (issue #1547
+ * binding item 5 — the same "shared operation IR, no metadata reconstruction"
+ * contract Phase 3's `describeWorkflowInvoker` gives the workflow invoker).
+ *
+ * The resolution logic here was lifted verbatim from `renderDbTypeFile`'s
+ * former inline body; the only change is that result descriptors reference a
+ * MODEL NAME (naming-neutral) rather than a resolved TS interface name, so the
+ * Swift renderer can map the same model to its own type name.
+ */
+import { parseConfigToml, stringifyConfigToml } from "../config-toml.js";
+import { loadSchemaFromTomlString } from "js-bao";
+import { parseDatabaseTypeToml } from "../../commands/sync.js";
+import { fingerprintToml } from "./dbFingerprint.js";
+import { tsTypeForDbFieldType } from "./dbTsTypes.js";
+/**
+ * Resolve a database-type TOML into the shared, naming-neutral IR. Pure: no
+ * I/O beyond parsing the passed content. Both the TS and Swift renderers call
+ * this so their op/record metadata can never diverge.
+ */
+export function describeDbType(input) {
+    const { tomlContent } = input;
+    const fingerprint = fingerprintToml(tomlContent);
+    // Parse the raw TOML once for the [type] / [[operations]] data, and route
+    // the [models.*] subtree through the shared js-bao loader (same path the
+    // server uses to validate the schema).
+    const tomlData = parseConfigToml(tomlContent);
+    const { typeConfig, operations, subscriptions } = parseDatabaseTypeToml(tomlData);
+    const schemas = tomlData.models
+        ? loadSchemaFromTomlString(stringifyConfigToml({ models: tomlData.models }), {
+            strict: false,
+        })
+        : [];
+    const stampedFields = collectStampedFields(typeConfig);
+    // model → record fields that op params prove are always supplied at create
+    // time; OR'd with the schema-level `required` flag below (#842).
+    const inferredRequired = inferRequiredRecordFields(operations);
+    // model → the field names on its record (declared + stamped), used to guard
+    // projection `pick` against unknown keys (#1439).
+    const recordFieldsByModel = new Map();
+    // model → declared field name → field type, feeding array-param element-type
+    // inference (#1488).
+    const fieldTypesByModel = new Map();
+    for (const schema of schemas) {
+        const ftypes = new Map();
+        for (const [fname, fopts] of Object.entries(schema.fields)) {
+            const t = fopts?.type;
+            if (typeof t === "string")
+                ftypes.set(fname, t);
+        }
+        fieldTypesByModel.set(schema.name, ftypes);
+        const memberNames = new Set(Object.keys(schema.fields));
+        for (const stamped of stampedFields)
+            memberNames.add(stamped);
+        recordFieldsByModel.set(schema.name, memberNames);
+    }
+    const modelsWithRecord = new Set(schemas.map((s) => s.name));
+    // Record IRs (schema order — renderers sort by their own type name).
+    const records = schemas.map((schema) => {
+        const inferredForModel = inferredRequired.get(schema.name)?.fields;
+        const fields = Object.entries(schema.fields).map(([name, opts]) => ({
+            name,
+            type: opts.type,
+            required: opts.required === true ||
+                (opts.autoAssign === true && name === "id") ||
+                inferredForModel?.has(name) === true,
+            enum: opts.enum,
+        }));
+        return {
+            modelName: schema.name,
+            className: schema.options?.className,
+            fields,
+        };
+    });
+    // Operation IRs, sorted by op name for deterministic output.
+    const sortedOps = [...operations]
+        .filter((op) => op && typeof op.name === "string")
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const ops = sortedOps.map((op) => {
+        const inferredArrays = inferArrayParamElementTypes(op, fieldTypesByModel);
+        const params = paramsToFields(op.params, inferredArrays);
+        const resultModelName = op.type === "query" && op.modelName && modelsWithRecord.has(op.modelName)
+            ? op.modelName
+            : null;
+        const projection = op.type === "query"
+            ? classifyProjection(op.definition?.projection, (op.modelName && recordFieldsByModel.get(op.modelName)) ||
+                new Set())
+            : undefined;
+        const pipelineReturn = op.type === "pipeline"
+            ? resolvePipelineReturn(op.definition, recordFieldsByModel, modelsWithRecord)
+            : undefined;
+        return {
+            opName: op.name,
+            opType: op.type,
+            params,
+            hasParams: params.length > 0,
+            resultModelName,
+            projection,
+            pipelineReturn,
+        };
+    });
+    // Subscription IRs (#1544 Phase 2), sorted by subscription key for
+    // deterministic output. Each is bound to its declared `modelName`'s record
+    // type; `select` narrows that to a projection.
+    const subscriptionIRs = describeSubscriptions(subscriptions, input.databaseType, modelsWithRecord, recordFieldsByModel);
+    return {
+        databaseType: input.databaseType,
+        fingerprint,
+        stampedFields,
+        records,
+        ops,
+        subscriptions: subscriptionIRs,
+    };
+}
+/**
+ * Resolve the parsed `[[subscriptions]]` rows into naming-neutral IR
+ * (#1544 Phase 2). Sorted by subscription key.
+ *
+ * Precise per-subscription typing (maintainer decision, Fork 2 amended): each
+ * subscription is bound to its declared `modelName`. A subscription whose
+ * `modelName` is missing or names a model this type declares no record schema
+ * for is an authoring error the generator surfaces by THROWING — there is no
+ * silent `Record<string, unknown>` fallback and no discriminated-union fallback
+ * (the server has required `modelName` on every subscription since the feature
+ * shipped in #740, so no legacy no-`modelName` rows exist).
+ *
+ * `select` narrows the event record to a `Pick`; each selected field must be a
+ * known member of the record (or the record must be the open
+ * `Record<string, unknown>` form), else the generator throws rather than emit
+ * an invalid `Pick`.
+ */
+function describeSubscriptions(subscriptions, databaseType, modelsWithRecord, recordFieldsByModel) {
+    const result = (subscriptions ?? [])
+        .filter((sub) => sub && typeof sub.subscriptionKey === "string")
+        .map((sub) => {
+        const subscriptionKey = sub.subscriptionKey;
+        const modelName = sub.modelName;
+        if (typeof modelName !== "string" || modelName === "") {
+            throw new Error(`Subscription "${subscriptionKey}" on database type ` +
+                `"${databaseType}" has no modelName. Every subscription must ` +
+                `declare the model whose changes it delivers.`);
+        }
+        if (!modelsWithRecord.has(modelName)) {
+            throw new Error(`Subscription "${subscriptionKey}" on database type ` +
+                `"${databaseType}" names model "${modelName}", which has no ` +
+                `[models.${modelName}] schema block. Declare the model's schema ` +
+                `so its change payload can be typed.`);
+        }
+        // `select` present (non-empty array) → Pick over those fields. Guard each
+        // field against the record's known members unless the record is the open
+        // `Record<string, unknown>` form (no declared/stamped members), where any
+        // key is valid.
+        let select = null;
+        if (Array.isArray(sub.select) && sub.select.length > 0) {
+            const members = recordFieldsByModel.get(modelName) ?? new Set();
+            const recordIsOpen = members.size === 0;
+            for (const field of sub.select) {
+                if (typeof field !== "string" || field === "") {
+                    throw new Error(`Subscription "${subscriptionKey}" on database type ` +
+                        `"${databaseType}" has a non-string select entry.`);
+                }
+                if (!recordIsOpen && !members.has(field)) {
+                    throw new Error(`Subscription "${subscriptionKey}" on database type ` +
+                        `"${databaseType}" selects field "${field}", which is not ` +
+                        `declared on model "${modelName}". Add it to ` +
+                        `[models.${modelName}] or remove it from select.`);
+                }
+            }
+            select = [...new Set(sub.select)].sort();
+        }
+        return { subscriptionKey, modelName, select };
+    });
+    result.sort((a, b) => a.subscriptionKey.localeCompare(b.subscriptionKey));
+    return result;
+}
+/**
+ * Classify a query op's static `projection` into how it narrows the record type
+ * (#1439). Kept private to the generator: the returned `{ kind, fields }` shape
+ * is what the template needs, and the field-guard / `id`-folding / sorting live
+ * here so the template stays a pure string-emitter.
+ *
+ * `recordFieldNames` is the set of members on the record interface (declared +
+ * stamped). A projected key that is not a member (a nested `"a.b"` path, or a
+ * field absent from the schema) makes the whole projection fall back to
+ * `Partial<M>` rather than emit an invalid `Pick`. Reused for a pipeline
+ * op's returning `query` step (#1437).
+ *
+ * Rules (projection values are validated server-side to be `1` or `0`, mixing
+ * rejected — codegen runs pre-push, so it still guards):
+ *   - absent / not an object / empty `{}`      → `full` (whole record `M`).
+ *   - all `1` (inclusion), keys all known      → `pick` (with `id` folded in,
+ *                                                since inclusion always retains
+ *                                                `id` at runtime).
+ *   - all `0` (exclusion), keys all known       → `omit` (over the excluded set
+ *                                                minus `id`/`type`). The DO strips
+ *                                                excluded fields server-side
+ *                                                (#1493 / issue #1456), so the
+ *                                                rows genuinely omit them and
+ *                                                `Omit<M, …>` is truthful. Falls
+ *                                                back to `partial` when the set is
+ *                                                empty after dropping `id`/`type`.
+ *   - mixed / dynamic / non-`1|0` / unknown /   → `partial` (honest fallback).
+ *     nested-key exclusion
+ */
+function classifyProjection(projection, recordFieldNames) {
+    if (!projection ||
+        typeof projection !== "object" ||
+        Array.isArray(projection)) {
+        return { kind: "full" };
+    }
+    const entries = Object.entries(projection);
+    if (entries.length === 0)
+        return { kind: "full" };
+    let allInclude = true;
+    let allExclude = true;
+    const included = [];
+    const excluded = [];
+    for (const [field, val] of entries) {
+        if (val === 1) {
+            included.push(field);
+            allExclude = false;
+        }
+        else if (val === 0) {
+            excluded.push(field);
+            allInclude = false;
+        }
+        else {
+            // A dynamic (`$params.x`) or otherwise non-`1|0` value — can't resolve
+            // statically. Fall back rather than emit garbage.
+            allInclude = false;
+            allExclude = false;
+        }
+    }
+    if (allInclude && included.length > 0) {
+        if (!included.every((f) => recordFieldNames.has(f)))
+            return { kind: "partial" };
+        // Inclusion always retains `id` at runtime (the DO unshifts it), so fold it
+        // into the union when the model has an `id` field.
+        const fields = new Set(included);
+        if (recordFieldNames.has("id"))
+            fields.add("id");
+        return { kind: "pick", fields: [...fields].sort() };
+    }
+    if (allExclude && excluded.length > 0) {
+        // Static all-exclusion projection (e.g. `{ secret: 0 }`). Since #1493 (issue
+        // #1456) the DO's `_applyProjection` deletes excluded keys server-side, so
+        // the returned rows genuinely omit them and `Omit<M, …>` is the truthful,
+        // tighter type — reading an excluded field off the result is now a compile
+        // error rather than a value that silently existed.
+        //
+        // `id`/`type` are always returned (the validator 400s on excluding them and
+        // the DO force-keeps them), so they can never be in the Omit set — drop them
+        // first. Dropping them is defensive handling of invalid local/unpushed TOML,
+        // not a supported projection shape.
+        const omitKeys = excluded.filter((f) => f !== "id" && f !== "type");
+        // Every remaining key must be a known member so `Omit<M, union>` is valid TS.
+        // A nested `"a.b"` path or an off-schema key falls back to the honest
+        // `Partial`, and an exclusion set that is only `id`/`type` reduces to empty
+        // after filtering (op rejected server-side) → also `Partial`.
+        if (omitKeys.length > 0 && omitKeys.every((f) => recordFieldNames.has(f))) {
+            return { kind: "omit", fields: [...new Set(omitKeys)].sort() };
+        }
+        return { kind: "partial" };
+    }
+    return { kind: "partial" };
+}
+/**
+ * Resolve a pipeline op's `return`-step shape (#1437), naming-neutral (keyed on
+ * model name). Never throws — one odd op must not break codegen for the file.
+ */
+function resolvePipelineReturn(definition, recordFieldsByModel, modelsWithRecord) {
+    if (!definition || typeof definition !== "object")
+        return { kind: "opaque" };
+    const def = definition;
+    const ret = def.return ?? "all";
+    if (ret === "all" || typeof ret !== "string")
+        return { kind: "opaque" };
+    if (!Array.isArray(def.steps))
+        return { kind: "opaque" };
+    const step = def.steps.find((s) => s && typeof s === "object" && s.name === ret);
+    if (!step)
+        return { kind: "opaque" };
+    if (step.type === "query") {
+        const modelName = typeof step.modelName === "string" ? step.modelName : undefined;
+        const resultModelName = modelName && modelsWithRecord.has(modelName) ? modelName : null;
+        const fieldNames = (modelName && recordFieldsByModel.get(modelName)) || new Set();
+        const projection = classifyProjection(step.projection, fieldNames);
+        return { kind: "query", modelName: resultModelName, projection };
+    }
+    if (step.type === "count")
+        return { kind: "count" };
+    if (step.type === "aggregate")
+        return { kind: "aggregate" };
+    return { kind: "opaque" };
+}
+/**
+ * Collect server-stamped field names from the parsed [type] config: timestamp
+ * field names + auto-populated field names. These render as OPTIONAL record
+ * props.
+ */
+function collectStampedFields(typeConfig) {
+    const names = [];
+    const ts = typeConfig?.timestamps;
+    if (ts && typeof ts === "object") {
+        if (typeof ts.create === "string")
+            names.push(ts.create);
+        if (typeof ts.update === "string")
+            names.push(ts.update);
+    }
+    const apf = typeConfig?.autoPopulatedFields;
+    if (apf && typeof apf === "object") {
+        for (const key of Object.keys(apf))
+            names.push(key);
+    }
+    return [...new Set(names)];
+}
+/**
+ * Convert the normalized op `params` map into a sorted `ParamField[]`. See the
+ * original doc in `dbGenerator.ts`. `inferredArrayElements` (#1488) narrows a
+ * `$in`/`$nin`-bound untyped/object param to its array element type.
+ */
+function paramsToFields(params, inferredArrayElements) {
+    if (!params || typeof params !== "object")
+        return [];
+    return Object.entries(params)
+        .map(([name, def]) => {
+        const rawType = def?.type;
+        const declaredType = rawType ?? "object";
+        const declaredItems = def?.items;
+        let type = declaredType;
+        let items = declaredItems;
+        const inferred = inferredArrayElements?.get(name);
+        if (declaredType === "object" && inferred !== undefined) {
+            type = "array";
+            items = inferred === "unknown" ? undefined : inferred;
+        }
+        return {
+            name,
+            type,
+            required: def?.required === true,
+            enum: def?.enum,
+            items,
+        };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Infer the scalar element type for op params consumed by a `$in`/`$nin`
+ * filter operator (#1488). See the original doc in `dbGenerator.ts` — moved
+ * here unchanged. Returns a map of param name → element TS type
+ * (`"unknown"` sentinel → widen to an untyped element).
+ */
+export function inferArrayParamElementTypes(op, fieldTypesByModel) {
+    const result = new Map();
+    if (!op || typeof op !== "object")
+        return result;
+    const def = op.definition;
+    if (!def || typeof def !== "object")
+        return result;
+    const arrayElems = new Map();
+    const scalarRefs = new Set();
+    const addArrayElem = (param, elem) => {
+        let s = arrayElems.get(param);
+        if (!s) {
+            s = new Set();
+            arrayElems.set(param, s);
+        }
+        s.add(elem);
+    };
+    const paramRef = (v) => {
+        if (typeof v !== "string")
+            return null;
+        const m = v.match(/^\$params\.([A-Za-z0-9_]+)$/);
+        return m ? m[1] : null;
+    };
+    const elemTypeForField = (field, fields) => {
+        const ftype = fields?.get(field);
+        if (ftype === undefined)
+            return "unknown";
+        if (ftype === "stringset")
+            return "string";
+        const ts = tsTypeForDbFieldType(ftype);
+        return ts === "string" || ts === "number" || ts === "boolean"
+            ? ts
+            : "unknown";
+    };
+    const modelFields = (name) => typeof name === "string" ? fieldTypesByModel.get(name) : undefined;
+    const walkFilter = (filter, fields) => {
+        if (!filter || typeof filter !== "object" || Array.isArray(filter))
+            return;
+        for (const [key, value] of Object.entries(filter)) {
+            if (key === "$and" || key === "$or") {
+                if (Array.isArray(value)) {
+                    for (const sub of value)
+                        walkFilter(sub, fields);
+                }
+                continue;
+            }
+            if (key === "$not") {
+                walkFilter(value, fields);
+                continue;
+            }
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                for (const [operator, opVal] of Object.entries(value)) {
+                    const p = paramRef(opVal);
+                    if (!p)
+                        continue;
+                    if (operator === "$in" || operator === "$nin") {
+                        addArrayElem(p, elemTypeForField(key, fields));
+                    }
+                    else {
+                        scalarRefs.add(p);
+                    }
+                }
+            }
+            else {
+                const p = paramRef(value);
+                if (p)
+                    scalarRefs.add(p);
+            }
+        }
+    };
+    walkFilter(def.filter, modelFields(op.modelName));
+    if (def.source && typeof def.source === "object") {
+        walkFilter(def.source.filter, modelFields(def.source.modelName ?? op.modelName));
+    }
+    if (Array.isArray(def.operations)) {
+        for (const inner of def.operations) {
+            if (inner && typeof inner === "object") {
+                walkFilter(inner.filter, modelFields(inner.modelName ?? op.modelName));
+            }
+        }
+    }
+    if (Array.isArray(def.steps)) {
+        for (const step of def.steps) {
+            if (step && typeof step === "object") {
+                walkFilter(step.filter, modelFields(step.modelName ?? op.modelName));
+            }
+        }
+    }
+    for (const [param, elems] of arrayElems) {
+        if (scalarRefs.has(param) || elems.size !== 1) {
+            result.set(param, "unknown");
+        }
+        else {
+            result.set(param, [...elems][0]);
+        }
+    }
+    return result;
+}
+/**
+ * Infer which record fields are always supplied at create time from `save` op
+ * params (#842). See the original doc in `dbGenerator.ts` — moved here
+ * unchanged.
+ */
+export function inferRequiredRecordFields(operations) {
+    const verdicts = new Map();
+    for (const op of operations ?? []) {
+        if (!op || op.type !== "mutation")
+            continue;
+        const innerOps = op.definition?.operations;
+        if (!Array.isArray(innerOps))
+            continue;
+        const params = op.params && typeof op.params === "object" ? op.params : {};
+        for (const inner of innerOps) {
+            if (!inner || inner.op !== "save")
+                continue;
+            const data = inner.data;
+            if (!data || typeof data !== "object" || Array.isArray(data))
+                continue;
+            const modelName = inner.modelName ?? op.modelName;
+            if (typeof modelName !== "string" || modelName === "")
+                continue;
+            let fieldVerdicts = verdicts.get(modelName);
+            if (!fieldVerdicts) {
+                fieldVerdicts = new Map();
+                verdicts.set(modelName, fieldVerdicts);
+            }
+            for (const [field, value] of Object.entries(data)) {
+                const match = typeof value === "string"
+                    ? value.match(/^\$params\.([A-Za-z0-9_]+)$/)
+                    : null;
+                if (!match) {
+                    fieldVerdicts.set(field, false);
+                    continue;
+                }
+                const paramName = match[1];
+                const required = params[paramName]?.required === true;
+                const prior = fieldVerdicts.get(field);
+                fieldVerdicts.set(field, prior === false ? false : required);
+            }
+        }
+    }
+    const result = new Map();
+    for (const [modelName, fieldVerdicts] of verdicts) {
+        const fields = new Set();
+        for (const [field, verdict] of fieldVerdicts) {
+            if (verdict)
+                fields.add(field);
+        }
+        if (fields.size > 0)
+            result.set(modelName, { fields });
+    }
+    return result;
+}
+//# sourceMappingURL=dbTypeIR.js.map