firebase-contract 0.1.0-rc.12 → 0.1.0-rc.14

package/README.md

@@ -123,8 +123,9 @@ generators:
 
 `fbc generate contract.yml` materializes **all** declared outputs across the
 whole import graph in one run. Passing `-o`/`-g` switches to single-target mode
-(`fbc generate <entry> -o <dir> -g typescript,zod`), and
-`firebase-contract.json` (`entry`, `outDir`, `generators`) can hold defaults.
+(`fbc generate <entry> -o <dir> -g typescript,zod`). `firebase-contract.json`
+holds only a default `entry` — output routing lives in the yml `generators:`
+declarations, so a config file can never silently override them.
 
 
 ### Generated-file headers
@@ -193,8 +194,21 @@ firestore module is checked under `fsName ?? name` alongside doc names. A bare
 type reference therefore always resolves to exactly one definition — use
 `fbc where <Name>` to find it.
 
+**Unknown keys are errors.** Every key the parser does not consume is an
+`UNKNOWN_KEY` error (all reported in one pass), never silently dropped — a
+typo like `optionnal:` must not quietly turn into a required field. There is
+no `version:` field: nothing consumes one, so accepting it would only fake a
+compatibility mechanism that does not exist.
+
+**Out-of-vocabulary values are errors too.** A value outside a field's fixed
+set is `INVALID_VALUE` rather than a silent coercion: `auth: PUBILC` does not
+quietly become `NO_ACCESS`, `dir: Dsec` does not become `ASC`, and a mistyped
+`action` / `single` / `keyArg` / `style.*` is not dropped. The one exception is
+`where.op`, which is warned (`UNKNOWN_WHERE_OP`) not errored — it is emitted
+verbatim into GraphQL and the recognized-operator list may lag Data Connect, so
+a typo is surfaced without rejecting a valid-but-unlisted operator.
+
 ```yaml
-version: 1
 imports:
   - ./apps/shop/data-connect/schema.yml
   - some-shared-package/contract.yml
@@ -487,8 +501,11 @@ firestore:
 ```
 
 Emits Zod schemas + inferred types, mirroring a hand-written Firestore schema
-library. (The simpler `firestore-types` generator just re-types *every* model
-with the Firestore `Timestamp` and does not denormalize.)
+library. (`firestore-types` is the zero-config entry point for projects that
+have not written projections yet: it re-types *every* model with the Firestore
+`Timestamp`, no `firestore:` section needed. Once you declare projections,
+prefer the `firestore` generator — it is the one that understands
+pick/omit/fsName/denormalized fields.)
 
 With `firestore` + `split: true`, fields whose Zod chain is **identical** to the Data
 Connect schema are reused via `.pick()` — only representation changes are

package/dist/lib/_internal/generators/support/split.d.ts

@@ -18,7 +18,7 @@ export declare const collectDeps: (ir: Ir, roots: IrModel[]) => HostedDeps;
 /**
  * Assign a unique module basename to every table. Two models may share a
  * physical table name across services (e.g. both declare
- * `reconciliation_operations`); the first keeps the table-derived name and
+ * `audit_logs`); the first keeps the table-derived name and
  * later ones fall back to their model name so files never overwrite each other.
  */
 export declare const assignModuleNames: (tables: IrModel[]) => Map<string, string>;

package/dist/lib/_internal/generators/support/split.js

@@ -52,7 +52,7 @@ export const collectDeps = (ir, roots) => {
 /**
  * Assign a unique module basename to every table. Two models may share a
  * physical table name across services (e.g. both declare
- * `reconciliation_operations`); the first keeps the table-derived name and
+ * `audit_logs`); the first keeps the table-derived name and
  * later ones fall back to their model name so files never overwrite each other.
  */
 export const assignModuleNames = (tables) => {

package/dist/lib/_internal/generators/typescript/render.d.ts

@@ -0,0 +1,15 @@
+import { Ir, IrEnum, IrField, IrModel, ScalarType } from '../../ir/ir.js';
+/**
+ * Rendering shared by the bundled and split TypeScript layouts. Both layouts
+ * MUST go through these helpers so a contract setting (valueKeys, nullable,
+ * multi-line descriptions, …) means the same thing regardless of layout.
+ */
+export declare const SCALAR_TS: Record<ScalarType, string>;
+export declare const JSON_TYPE: string;
+export declare const docLines: (description: string | undefined, indent: string) => string[];
+export declare const renderField: (field: IrField, ir: Ir) => string;
+export declare const renderEnumConst: (irEnum: IrEnum) => string;
+export declare const renderEnumUnion: (irEnum: IrEnum) => string;
+export declare const renderModel: (model: IrModel, ir: Ir) => string;
+export declare const usesJson: (models: IrModel[]) => boolean;
+//# sourceMappingURL=render.d.ts.map

package/dist/lib/_internal/generators/typescript/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/typescript/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAa,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAIpF;;;;GAIG;AAEH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAUhD,CAAA;AAED,eAAO,MAAM,SAAS,QAQV,CAAA;AAcZ,eAAO,MAAM,QAAQ,GAAI,aAAa,MAAM,GAAG,SAAS,EAAE,QAAQ,MAAM,KAAG,MAAM,EAKhF,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,EAAE,IAAI,EAAE,KAAG,MAiBpD,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,KAAG,MAchD,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,KAAG,MAIhD,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,EAAE,IAAI,EAAE,KAAG,MAIpD,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,QAAQ,OAAO,EAAE,KAAG,OACiE,CAAA"}

package/dist/lib/_internal/generators/typescript/render.js

@@ -0,0 +1,92 @@
+import { constantCase, singleQuote } from '../support/naming.js';
+import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
+/**
+ * Rendering shared by the bundled and split TypeScript layouts. Both layouts
+ * MUST go through these helpers so a contract setting (valueKeys, nullable,
+ * multi-line descriptions, …) means the same thing regardless of layout.
+ */
+export const SCALAR_TS = {
+    string: 'string',
+    int: 'number',
+    int64: 'number',
+    float: 'number',
+    boolean: 'boolean',
+    timestamp: 'string',
+    date: 'string',
+    json: 'Json',
+    id: 'string',
+};
+export const JSON_TYPE = [
+    'export type Json =',
+    '  | string',
+    '  | number',
+    '  | boolean',
+    '  | null',
+    '  | Json[]',
+    '  | { [key: string]: Json }',
+].join('\n');
+const renderRef = (ref) => {
+    switch (ref.kind) {
+        case 'scalar':
+            return SCALAR_TS[ref.name];
+        case 'enum':
+        case 'model':
+            return ref.name;
+        default:
+            return 'unknown';
+    }
+};
+export const docLines = (description, indent) => {
+    if (!description)
+        return [];
+    const lines = description.split('\n');
+    if (lines.length === 1)
+        return [`${indent}/** ${lines[0]} */`];
+    return [`${indent}/**`, ...lines.map(line => `${indent} * ${line}`.trimEnd()), `${indent} */`];
+};
+export const renderField = (field, ir) => {
+    const optional = field.optional ? '?' : '';
+    const doc = docLines(field.description, '  ');
+    let entry;
+    if (field.literal !== undefined) {
+        const type = field.list ? `${singleQuote(field.literal)}[]` : singleQuote(field.literal);
+        entry = `  ${field.name}${optional}: ${type}`;
+    }
+    else if (isRelation(field)) {
+        const base = SCALAR_TS[relationFkType(ir, field)];
+        entry = `  ${relationFkName(field)}${optional}: ${field.list ? `${base}[]` : base}`;
+    }
+    else {
+        const base = renderRef(field.type);
+        const type = field.list ? `${base}[]` : base;
+        const nullable = field.nullable ? ' | null' : '';
+        entry = `  ${field.name}${optional}: ${type}${nullable}`;
+    }
+    return [...doc, entry].join('\n');
+};
+export const renderEnumConst = (irEnum) => {
+    const doc = docLines(irEnum.description, '');
+    const constName = constantCase(irEnum.name);
+    const entries = irEnum.values
+        .map(value => `  ${irEnum.valueKeys?.[value] ?? constantCase(value)}: ${singleQuote(value)},`)
+        .join('\n');
+    return [
+        ...doc,
+        `export const ${constName} = Object.freeze({`,
+        entries,
+        `} as const)`,
+        `export type ${irEnum.name}Key = keyof typeof ${constName}`,
+        `export type ${irEnum.name} = (typeof ${constName})[${irEnum.name}Key]`,
+    ].join('\n');
+};
+export const renderEnumUnion = (irEnum) => {
+    const doc = docLines(irEnum.description, '');
+    const union = irEnum.values.map(value => singleQuote(value)).join(' | ') || 'never';
+    return [...doc, `export type ${irEnum.name} = ${union}`].join('\n');
+};
+export const renderModel = (model, ir) => {
+    const doc = docLines(model.description, '');
+    const fields = model.fields.map(field => renderField(field, ir)).join('\n');
+    return [...doc, `export interface ${model.name} {`, fields, '}'].join('\n');
+};
+export const usesJson = (models) => models.some(model => model.fields.some(field => field.type.kind === 'scalar' && field.type.name === 'json'));

package/dist/lib/_internal/generators/typescript/typescript-generator.d.ts

@@ -12,7 +12,8 @@ export interface TypeScriptGeneratorOptions {
  * Generates TypeScript types: an interface per model and, per enum, either a
  * frozen const object (default — runtime values + `Key`/value types) or a
  * plain string-literal union. This is the highest-priority
- * generator and the shape other TS-facing generators reference.
+ * generator and the shape other TS-facing generators reference. Rendering is
+ * shared with the split layout (./render.js) so both emit identical members.
  */
 export declare const createTypeScriptGenerator: (options?: TypeScriptGeneratorOptions) => Generator;
 //# sourceMappingURL=typescript-generator.d.ts.map

package/dist/lib/_internal/generators/typescript/typescript-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/typescript/typescript-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAQ5E,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CAC9B;AA+ED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GAAI,UAAS,0BAA+B,KAAG,SA4BpF,CAAA"}
+{"version":3,"file":"typescript-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/typescript/typescript-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAO5E,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CAC9B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GAAI,UAAS,0BAA+B,KAAG,SA0BpF,CAAA"}

package/dist/lib/_internal/generators/typescript/typescript-generator.js

@@ -1,82 +1,14 @@
 import { headerBlocks } from '../support/header.js';
 import { withSplitVariant } from '../support/split-variant.js';
 import { createTypeScriptSplitLayout } from './typescript-split-generator.js';
-import { constantCase, singleQuote } from '../support/naming.js';
-import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
 import { outputFile } from '../support/templates.js';
-const SCALAR_TS = {
-    string: 'string',
-    int: 'number',
-    int64: 'number',
-    float: 'number',
-    boolean: 'boolean',
-    timestamp: 'string',
-    date: 'string',
-    json: 'Json',
-    id: 'string',
-};
-const JSON_TYPE = [
-    'export type Json =',
-    '  | string',
-    '  | number',
-    '  | boolean',
-    '  | null',
-    '  | Json[]',
-    '  | { [key: string]: Json }',
-].join('\n');
-const renderRef = (ref) => {
-    switch (ref.kind) {
-        case 'scalar':
-            return SCALAR_TS[ref.name];
-        case 'enum':
-        case 'model':
-            return ref.name;
-        default:
-            return 'unknown';
-    }
-};
-const renderFieldType = (field) => {
-    const base = renderRef(field.type);
-    return field.list ? `${base}[]` : base;
-};
-const renderField = (field, ir) => {
-    const optional = field.optional ? '?' : '';
-    const doc = field.description ? `  /** ${field.description} */\n` : '';
-    if (field.literal !== undefined) {
-        const type = field.list ? `${singleQuote(field.literal)}[]` : singleQuote(field.literal);
-        return `${doc}  ${field.name}${optional}: ${type}`;
-    }
-    // Relation: expose the foreign-key id (matching the persisted/projected shape).
-    if (isRelation(field)) {
-        const base = SCALAR_TS[relationFkType(ir, field)];
-        const type = field.list ? `${base}[]` : base;
-        return `${doc}  ${relationFkName(field)}${optional}: ${type}`;
-    }
-    return `${doc}  ${field.name}${optional}: ${renderFieldType(field)}`;
-};
-const usesJson = (ir) => ir.models.some(model => model.fields.some(field => field.type.kind === 'scalar' && field.type.name === 'json'));
-const renderEnumUnion = (irEnum) => {
-    const doc = irEnum.description ? `/** ${irEnum.description} */\n` : '';
-    const union = irEnum.values.map(value => singleQuote(value)).join(' | ') || 'never';
-    return `${doc}export type ${irEnum.name} = ${union}`;
-};
-const renderEnumConst = (irEnum) => {
-    const doc = irEnum.description ? `/** ${irEnum.description} */\n` : '';
-    const constName = constantCase(irEnum.name);
-    const entries = irEnum.values.map(value => `  ${constantCase(value)}: ${singleQuote(value)},`).join('\n');
-    return [
-        `${doc}export const ${constName} = Object.freeze({`,
-        entries,
-        `} as const)`,
-        `export type ${irEnum.name}Key = keyof typeof ${constName}`,
-        `export type ${irEnum.name} = (typeof ${constName})[${irEnum.name}Key]`,
-    ].join('\n');
-};
+import { JSON_TYPE, renderEnumConst, renderEnumUnion, renderModel, usesJson } from './render.js';
 /**
  * Generates TypeScript types: an interface per model and, per enum, either a
  * frozen const object (default — runtime values + `Key`/value types) or a
  * plain string-literal union. This is the highest-priority
- * generator and the shape other TS-facing generators reference.
+ * generator and the shape other TS-facing generators reference. Rendering is
+ * shared with the split layout (./render.js) so both emit identical members.
  */
 export const createTypeScriptGenerator = (options = {}) => {
     const enumStyle = options.enumStyle ?? 'const';
@@ -85,16 +17,14 @@ export const createTypeScriptGenerator = (options = {}) => {
         description: 'TypeScript interfaces and enum const/union types',
         generate(ir, context) {
             const blocks = [...headerBlocks(context)];
-            if (usesJson(ir)) {
+            if (usesJson(ir.models)) {
                 blocks.push(JSON_TYPE);
             }
             for (const irEnum of ir.enums) {
                 blocks.push(enumStyle === 'const' ? renderEnumConst(irEnum) : renderEnumUnion(irEnum));
             }
             for (const model of ir.models) {
-                const doc = model.description ? `/** ${model.description} */\n` : '';
-                const fields = model.fields.map(field => renderField(field, ir)).join('\n');
-                blocks.push(`${doc}export interface ${model.name} {\n${fields}\n}`);
+                blocks.push(renderModel(model, ir));
             }
             return [{ path: outputFile(context, 'types.ts'), content: `${blocks.join('\n\n')}\n` }];
         },

package/dist/lib/_internal/generators/typescript/typescript-split-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript-split-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/typescript/typescript-split-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AA4F5E;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,QAAO,SA0E7C,CAAA"}
+{"version":3,"file":"typescript-split-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/typescript/typescript-split-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAO5E;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,QAAO,SA0E7C,CAAA"}

package/dist/lib/_internal/generators/typescript/typescript-split-generator.js

@@ -1,89 +1,9 @@
 import { findEnum, findModel } from '../../ir/ir.js';
 import { headerBlocks } from '../support/header.js';
-import { constantCase, singleQuote } from '../support/naming.js';
-import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
+import { isRelation } from '../support/relations.js';
 import { assignModuleNames, collectDeps, splitGroups } from '../support/split.js';
 import { outputFile } from '../support/templates.js';
-const SCALAR_TS = {
-    string: 'string',
-    int: 'number',
-    int64: 'number',
-    float: 'number',
-    boolean: 'boolean',
-    timestamp: 'string',
-    date: 'string',
-    json: 'Json',
-    id: 'string',
-};
-const JSON_TYPE = [
-    'export type Json =',
-    '  | string',
-    '  | number',
-    '  | boolean',
-    '  | null',
-    '  | Json[]',
-    '  | { [key: string]: Json }',
-].join('\n');
-const renderRef = (ref) => {
-    switch (ref.kind) {
-        case 'scalar':
-            return SCALAR_TS[ref.name];
-        case 'enum':
-        case 'model':
-            return ref.name;
-        default:
-            return 'unknown';
-    }
-};
-const docLines = (description, indent) => {
-    if (!description)
-        return [];
-    const lines = description.split('\n');
-    if (lines.length === 1)
-        return [`${indent}/** ${lines[0]} */`];
-    return [`${indent}/**`, ...lines.map(line => `${indent} * ${line}`.trimEnd()), `${indent} */`];
-};
-const renderField = (field, ir) => {
-    const optional = field.optional ? '?' : '';
-    const doc = docLines(field.description, '  ');
-    let entry;
-    if (field.literal !== undefined) {
-        const type = field.list ? `${singleQuote(field.literal)}[]` : singleQuote(field.literal);
-        entry = `  ${field.name}${optional}: ${type}`;
-    }
-    else if (isRelation(field)) {
-        const base = SCALAR_TS[relationFkType(ir, field)];
-        entry = `  ${relationFkName(field)}${optional}: ${field.list ? `${base}[]` : base}`;
-    }
-    else {
-        const base = renderRef(field.type);
-        const type = field.list ? `${base}[]` : base;
-        const nullable = field.nullable ? ' | null' : '';
-        entry = `  ${field.name}${optional}: ${type}${nullable}`;
-    }
-    return [...doc, entry].join('\n');
-};
-const renderEnumConst = (irEnum) => {
-    const doc = docLines(irEnum.description, '');
-    const constName = constantCase(irEnum.name);
-    const entries = irEnum.values
-        .map(value => `  ${irEnum.valueKeys?.[value] ?? constantCase(value)}: ${singleQuote(value)},`)
-        .join('\n');
-    return [
-        ...doc,
-        `export const ${constName} = Object.freeze({`,
-        entries,
-        `} as const)`,
-        `export type ${irEnum.name}Key = keyof typeof ${constName}`,
-        `export type ${irEnum.name} = (typeof ${constName})[${irEnum.name}Key]`,
-    ].join('\n');
-};
-const renderModel = (model, ir) => {
-    const doc = docLines(model.description, '');
-    const fields = model.fields.map(field => renderField(field, ir)).join('\n');
-    return [...doc, `export interface ${model.name} {`, fields, '}'].join('\n');
-};
-const usesJson = (models) => models.some(model => model.fields.some(field => field.type.kind === 'scalar' && field.type.name === 'json'));
+import { JSON_TYPE, renderEnumConst, renderModel, usesJson } from './render.js';
 /**
  * Split variant of the TypeScript generator: one file per table at
  * `types/<table-name>.ts` (kebab-case), with enums and embedded value objects

package/dist/lib/_internal/generators/zod/render.d.ts

@@ -0,0 +1,12 @@
+import { Ir, IrEnum, IrField, IrModel, ScalarType } from '../../ir/ir.js';
+/**
+ * Rendering shared by the bundled and split Zod layouts. Both layouts MUST go
+ * through these helpers so a contract setting (nullable, constraints, …) means
+ * the same thing regardless of layout.
+ */
+export declare const SCALAR_ZOD: Record<ScalarType, string>;
+export declare const schemaName: (name: string) => string;
+export declare const renderFieldSchema: (field: IrField, ir: Ir) => string;
+export declare const renderEnum: (irEnum: IrEnum) => string;
+export declare const renderModel: (model: IrModel, ir: Ir) => string;
+//# sourceMappingURL=render.d.ts.map

package/dist/lib/_internal/generators/zod/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/zod/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAa,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAKpF;;;;GAIG;AAEH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAUjD,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,MAAyB,CAAA;AAgBnE,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,EAAE,IAAI,EAAE,KAAG,MAa1D,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,KAAG,MAM3C,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,EAAE,IAAI,EAAE,KAAG,MAMpD,CAAA"}

package/dist/lib/_internal/generators/zod/render.js

@@ -0,0 +1,59 @@
+import { zodConstraints } from '../support/constraints.js';
+import { singleQuote } from '../support/naming.js';
+import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
+/**
+ * Rendering shared by the bundled and split Zod layouts. Both layouts MUST go
+ * through these helpers so a contract setting (nullable, constraints, …) means
+ * the same thing regardless of layout.
+ */
+export const SCALAR_ZOD = {
+    string: 'z.string()',
+    int: 'z.number().int()',
+    int64: 'z.number().int()',
+    float: 'z.number()',
+    boolean: 'z.boolean()',
+    timestamp: 'z.string().datetime()',
+    date: 'z.string()',
+    json: 'z.unknown()',
+    id: 'z.string()',
+};
+export const schemaName = (name) => `${name}Schema`;
+const renderRef = (ref) => {
+    switch (ref.kind) {
+        case 'scalar':
+            return SCALAR_ZOD[ref.name];
+        case 'enum':
+            return schemaName(ref.name);
+        case 'model':
+            // Wrapped in z.lazy so declaration order and (cross-file) cycles never matter.
+            return `z.lazy(() => ${schemaName(ref.name)})`;
+        default:
+            return 'z.unknown()';
+    }
+};
+export const renderFieldSchema = (field, ir) => {
+    const isRel = isRelation(field);
+    const name = isRel ? relationFkName(field) : field.name;
+    const base = field.literal !== undefined
+        ? `z.literal(${singleQuote(field.literal)})`
+        : isRel
+            ? SCALAR_ZOD[relationFkType(ir, field)]
+            : renderRef(field.type);
+    const cons = zodConstraints(field);
+    let schema = field.list ? `z.array(${base})${cons}` : `${base}${cons}`;
+    if (field.nullable)
+        schema = `${schema}.nullable()`;
+    if (field.optional)
+        schema = `${schema}.optional()`;
+    return `  ${name}: ${schema},`;
+};
+export const renderEnum = (irEnum) => {
+    const values = irEnum.values.map(singleQuote).join(', ');
+    return (`export const ${schemaName(irEnum.name)} = z.enum([${values}])\n` +
+        `export type ${irEnum.name} = z.infer<typeof ${schemaName(irEnum.name)}>`);
+};
+export const renderModel = (model, ir) => {
+    const fields = model.fields.map(field => renderFieldSchema(field, ir)).join('\n');
+    return (`export const ${schemaName(model.name)} = z.object({\n${fields}\n})\n` +
+        `export type ${model.name} = z.infer<typeof ${schemaName(model.name)}>`);
+};

package/dist/lib/_internal/generators/zod/zod-generator.d.ts

@@ -1,7 +1,8 @@
 import { Generator } from '../generator.js';
 /**
  * Generates Zod schemas and the types inferred from them. Model references use
- * `z.lazy` so the output is order- and cycle-independent.
+ * `z.lazy` so the output is order- and cycle-independent. Rendering is shared
+ * with the split layout (./render.js) so both emit identical members.
  */
 export declare const createZodGenerator: () => Generator;
 //# sourceMappingURL=zod-generator.d.ts.map

package/dist/lib/_internal/generators/zod/zod-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/zod/zod-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAuD5E;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAO,SA4BnC,CAAA"}
+{"version":3,"file":"zod-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/zod/zod-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAO5E;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,QAAO,SAoBnC,CAAA"}

package/dist/lib/_internal/generators/zod/zod-generator.js

@@ -1,55 +1,12 @@
 import { headerBlocks } from '../support/header.js';
 import { withSplitVariant } from '../support/split-variant.js';
 import { createZodSplitLayout } from './zod-split-generator.js';
-import { singleQuote } from '../support/naming.js';
-import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
-import { zodConstraints } from '../support/constraints.js';
 import { outputFile } from '../support/templates.js';
-const SCALAR_ZOD = {
-    string: 'z.string()',
-    int: 'z.number().int()',
-    int64: 'z.number().int()',
-    float: 'z.number()',
-    boolean: 'z.boolean()',
-    timestamp: 'z.string().datetime()',
-    date: 'z.string()',
-    json: 'z.unknown()',
-    id: 'z.string()',
-};
-const schemaName = (name) => `${name}Schema`;
-const renderRef = (ref) => {
-    switch (ref.kind) {
-        case 'scalar':
-            return SCALAR_ZOD[ref.name];
-        case 'enum':
-            // Enums are declared before models, so a direct reference is safe.
-            return schemaName(ref.name);
-        case 'model':
-            // Model references are wrapped in z.lazy so declaration order and cycles
-            // never matter.
-            return `z.lazy(() => ${schemaName(ref.name)})`;
-        default:
-            return 'z.unknown()';
-    }
-};
-const renderFieldSchema = (field, ir) => {
-    const isRel = isRelation(field);
-    const name = isRel ? relationFkName(field) : field.name;
-    const base = field.literal !== undefined
-        ? `z.literal(${singleQuote(field.literal)})`
-        : isRel
-            ? SCALAR_ZOD[relationFkType(ir, field)]
-            : renderRef(field.type);
-    const cons = zodConstraints(field);
-    let schema = field.list ? `z.array(${base})${cons}` : `${base}${cons}`;
-    if (field.optional) {
-        schema = `${schema}.optional()`;
-    }
-    return `  ${name}: ${schema},`;
-};
+import { renderEnum, renderModel } from './render.js';
 /**
  * Generates Zod schemas and the types inferred from them. Model references use
- * `z.lazy` so the output is order- and cycle-independent.
+ * `z.lazy` so the output is order- and cycle-independent. Rendering is shared
+ * with the split layout (./render.js) so both emit identical members.
  */
 export const createZodGenerator = () => withSplitVariant({
     name: 'zod',
@@ -57,14 +14,10 @@ export const createZodGenerator = () => withSplitVariant({
     generate(ir, context) {
         const blocks = [...headerBlocks(context), "import { z } from 'zod'"];
         for (const irEnum of ir.enums) {
-            const values = irEnum.values.map(singleQuote).join(', ');
-            blocks.push(`export const ${schemaName(irEnum.name)} = z.enum([${values}])\n` +
-                `export type ${irEnum.name} = z.infer<typeof ${schemaName(irEnum.name)}>`);
+            blocks.push(renderEnum(irEnum));
         }
         for (const model of ir.models) {
-            const fields = model.fields.map(field => renderFieldSchema(field, ir)).join('\n');
-            blocks.push(`export const ${schemaName(model.name)} = z.object({\n${fields}\n})\n` +
-                `export type ${model.name} = z.infer<typeof ${schemaName(model.name)}>`);
+            blocks.push(renderModel(model, ir));
         }
         return [{ path: outputFile(context, 'schemas.ts'), content: `${blocks.join('\n\n')}\n` }];
     },

package/dist/lib/_internal/generators/zod/zod-split-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod-split-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/zod/zod-split-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAmE5E;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,QAAO,SAmEtC,CAAA"}
+{"version":3,"file":"zod-split-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/zod/zod-split-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAO5E;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,QAAO,SAmEtC,CAAA"}

package/dist/lib/_internal/generators/zod/zod-split-generator.js

@@ -1,61 +1,9 @@
 import { findEnum, findModel } from '../../ir/ir.js';
-import { zodConstraints } from '../support/constraints.js';
 import { headerBlocks } from '../support/header.js';
-import { singleQuote } from '../support/naming.js';
-import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
+import { isRelation } from '../support/relations.js';
 import { assignModuleNames, collectDeps, splitGroups } from '../support/split.js';
 import { outputFile } from '../support/templates.js';
-const SCALAR_ZOD = {
-    string: 'z.string()',
-    int: 'z.number().int()',
-    int64: 'z.number().int()',
-    float: 'z.number()',
-    boolean: 'z.boolean()',
-    timestamp: 'z.string().datetime()',
-    date: 'z.string()',
-    json: 'z.unknown()',
-    id: 'z.string()',
-};
-const schemaName = (name) => `${name}Schema`;
-const renderRef = (ref) => {
-    switch (ref.kind) {
-        case 'scalar':
-            return SCALAR_ZOD[ref.name];
-        case 'enum':
-            return schemaName(ref.name);
-        case 'model':
-            // Wrapped in z.lazy so declaration order and (cross-file) cycles never matter.
-            return `z.lazy(() => ${schemaName(ref.name)})`;
-        default:
-            return 'z.unknown()';
-    }
-};
-const renderFieldSchema = (field, ir) => {
-    const isRel = isRelation(field);
-    const name = isRel ? relationFkName(field) : field.name;
-    const base = field.literal !== undefined
-        ? `z.literal(${singleQuote(field.literal)})`
-        : isRel
-            ? SCALAR_ZOD[relationFkType(ir, field)]
-            : renderRef(field.type);
-    const cons = zodConstraints(field);
-    let schema = field.list ? `z.array(${base})${cons}` : `${base}${cons}`;
-    if (field.nullable)
-        schema = `${schema}.nullable()`;
-    if (field.optional)
-        schema = `${schema}.optional()`;
-    return `  ${name}: ${schema},`;
-};
-const renderEnum = (irEnum) => {
-    const values = irEnum.values.map(singleQuote).join(', ');
-    return (`export const ${schemaName(irEnum.name)} = z.enum([${values}])\n` +
-        `export type ${irEnum.name} = z.infer<typeof ${schemaName(irEnum.name)}>`);
-};
-const renderModel = (model, ir) => {
-    const fields = model.fields.map(field => renderFieldSchema(field, ir)).join('\n');
-    return (`export const ${schemaName(model.name)} = z.object({\n${fields}\n})\n` +
-        `export type ${model.name} = z.infer<typeof ${schemaName(model.name)}>`);
-};
+import { renderEnum, renderModel, schemaName } from './render.js';
 /**
  * Split variant of the Zod generator: one file per table at
  * `schemas/<table-name>.ts` (kebab-case) with enums and embedded value objects

package/dist/lib/_internal/ir/build-ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-ir.d.ts","sourceRoot":"","sources":["../../../../src/lib/_internal/ir/build-ir.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAS,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAGL,WAAW,EAIZ,MAAM,2BAA2B,CAAA;AAElC,OAAO,EAGL,EAAE,EAgBH,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,EAAE,CAAA;IACN,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B;AAqLD;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,WAAW,WAAW,EAAE,KAAG,aAqQlD,CAAA"}
+{"version":3,"file":"build-ir.d.ts","sourceRoot":"","sources":["../../../../src/lib/_internal/ir/build-ir.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAkB,MAAM,mBAAmB,CAAA;AAC9D,OAAO,EAGL,WAAW,EAIZ,MAAM,2BAA2B,CAAA;AAElC,OAAO,EAGL,EAAE,EAgBH,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,EAAE,CAAA;IACN,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B;AAyPD;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,WAAW,WAAW,EAAE,KAAG,aAkQlD,CAAA"}