firebase-contract 0.1.0-rc.0

package/dist/lib/_internal/compiler/compiler.js

@@ -0,0 +1,104 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { error, hasErrors } from '../diagnostics.js';
+import { buildIr } from '../ir/build-ir.js';
+import { resolveImports } from '../resolver/import-resolver.js';
+import { createFsLoader } from '../resolver/module-loader.js';
+import { validateIr } from '../validation/validate.js';
+import { createDefaultRegistry } from '../generators/index.js';
+import { toHeaderComment } from '../generators/support/header.js';
+/**
+ * Run the front end of the pipeline: resolve imports, build the IR, and run
+ * semantic validation. Generators are intentionally not involved here — the CLI
+ * and {@link generate} depend on this, keeping analysis and code emission
+ * separable and independently testable.
+ */
+export const compile = (entryPath, options = {}) => {
+    const loader = options.loader ?? createFsLoader();
+    const { documents, diagnostics: importDiagnostics } = resolveImports(entryPath, loader);
+    const { ir, diagnostics: buildDiagnostics } = buildIr(documents);
+    const validationDiagnostics = validateIr(ir);
+    return {
+        ir,
+        documents,
+        diagnostics: [...importDiagnostics, ...buildDiagnostics, ...validationDiagnostics],
+    };
+};
+/**
+ * Run every `generate:` target declared across the entry contract and its
+ * (transitive) imports — the one-command flow: each contract file states where
+ * its own outputs go, and `fbc generate <root>` materializes all of them.
+ * Output dirs resolve relative to the declaring yml file.
+ */
+export const generateAll = (entryPath, options = {}) => {
+    const { documents, diagnostics } = compile(entryPath, options);
+    if (hasErrors(diagnostics)) {
+        return { targets: [], diagnostics, ok: false };
+    }
+    const collected = [...diagnostics];
+    const targets = [];
+    let ok = true;
+    for (const doc of documents) {
+        for (const output of doc.outputs ?? []) {
+            const outDir = join(dirname(doc.filePath), output.out);
+            const result = generate(doc.filePath, {
+                outDir,
+                generators: output.generators,
+                registry: options.registry,
+                write: options.write,
+                ...(options.context ? { context: options.context } : {}),
+                ...(options.loader ? { loader: options.loader } : {}),
+            });
+            // Per-target compiles revisit shared imports; keep only new diagnostics.
+            for (const diagnostic of result.diagnostics) {
+                if (!collected.some(d => d.code === diagnostic.code && d.message === diagnostic.message)) {
+                    collected.push(diagnostic);
+                }
+            }
+            if (!result.ok)
+                ok = false;
+            targets.push({ source: doc.filePath, outDir, generators: output.generators, files: result.files });
+        }
+    }
+    return { targets, diagnostics: collected, ok };
+};
+/**
+ * Compile then emit code. Generation is skipped when compilation produced any
+ * error, so generators never see an invalid IR. The CLI is a thin wrapper over
+ * this function.
+ */
+export const generate = (entryPath, options) => {
+    const registry = options.registry ?? createDefaultRegistry();
+    const { ir, diagnostics } = compile(entryPath, options);
+    const collected = [...diagnostics];
+    if (hasErrors(collected)) {
+        return { ir, diagnostics: collected, files: [], ok: false };
+    }
+    const names = options.generators && options.generators.length > 0 ? options.generators : registry.names();
+    // CLI/options header wins; otherwise fall back to the contract's `header:`.
+    const context = { ...options.context };
+    if (context.header === undefined && ir.header !== undefined) {
+        context.header = toHeaderComment(ir.header);
+    }
+    const files = [];
+    for (const name of names) {
+        const generator = registry.get(name);
+        if (!generator) {
+            collected.push(error('UNKNOWN_GENERATOR', `Unknown generator "${name}"`));
+            continue;
+        }
+        for (const file of generator.generate(ir, context)) {
+            files.push({ path: join(options.outDir, file.path), content: file.content });
+        }
+    }
+    if (hasErrors(collected)) {
+        return { ir, diagnostics: collected, files: [], ok: false };
+    }
+    if (options.write) {
+        for (const file of files) {
+            mkdirSync(dirname(file.path), { recursive: true });
+            writeFileSync(file.path, file.content, 'utf8');
+        }
+    }
+    return { ir, diagnostics: collected, files, ok: true };
+};

package/dist/lib/_internal/compiler/index.d.ts

@@ -0,0 +1,3 @@
+export type { CompileOptions, CompileResult, GenerateOptions, GenerateResult } from './compiler.js';
+export { compile, generate } from './compiler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/_internal/compiler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/_internal/compiler/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnG,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA"}

package/dist/lib/_internal/compiler/index.js

@@ -0,0 +1 @@
+export { compile, generate } from './compiler.js';

package/dist/lib/_internal/diagnostics.d.ts

@@ -0,0 +1,29 @@
+export type DiagnosticSeverity = 'error' | 'warning';
+/**
+ * A single problem found while compiling a contract. Diagnostics are collected
+ * across the pipeline (import resolution, IR build, semantic validation) rather
+ * than thrown, so the CLI can report every issue at once.
+ */
+export interface Diagnostic {
+    severity: DiagnosticSeverity;
+    /** Stable machine-readable identifier, e.g. `UNRESOLVED_TYPE`. */
+    code: string;
+    message: string;
+    /** Absolute path of the source file the problem originates from. */
+    file?: string;
+    /** Logical location inside the contract, e.g. `models.User.fields.id`. */
+    path?: string;
+}
+export declare const error: (code: string, message: string, extra?: Partial<Diagnostic>) => Diagnostic;
+export declare const warning: (code: string, message: string, extra?: Partial<Diagnostic>) => Diagnostic;
+export declare const hasErrors: (diagnostics: Diagnostic[]) => boolean;
+/**
+ * Thrown for unrecoverable problems (e.g. a YAML syntax error) where producing
+ * a partial result is not meaningful. Recoverable, semantic problems are
+ * reported as {@link Diagnostic}s instead.
+ */
+export declare class ContractError extends Error {
+    readonly diagnostics: Diagnostic[];
+    constructor(message: string, diagnostics?: Diagnostic[]);
+}
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/lib/_internal/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/lib/_internal/diagnostics.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,EAAE,SAAS,MAAM,EAAE,QAAO,OAAO,CAAC,UAAU,CAAM,KAAG,UAKrF,CAAA;AAEF,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,SAAS,MAAM,EAAE,QAAO,OAAO,CAAC,UAAU,CAAM,KAAG,UAKvF,CAAA;AAEF,eAAO,MAAM,SAAS,GAAI,aAAa,UAAU,EAAE,KAAG,OACW,CAAA;AAEjE;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAA;gBAEtB,OAAO,EAAE,MAAM,EAAE,WAAW,GAAE,UAAU,EAAO;CAK5D"}

package/dist/lib/_internal/diagnostics.js

@@ -0,0 +1,26 @@
+export const error = (code, message, extra = {}) => ({
+    severity: 'error',
+    code,
+    message,
+    ...extra,
+});
+export const warning = (code, message, extra = {}) => ({
+    severity: 'warning',
+    code,
+    message,
+    ...extra,
+});
+export const hasErrors = (diagnostics) => diagnostics.some(diagnostic => diagnostic.severity === 'error');
+/**
+ * Thrown for unrecoverable problems (e.g. a YAML syntax error) where producing
+ * a partial result is not meaningful. Recoverable, semantic problems are
+ * reported as {@link Diagnostic}s instead.
+ */
+export class ContractError extends Error {
+    diagnostics;
+    constructor(message, diagnostics = []) {
+        super(message);
+        this.name = 'ContractError';
+        this.diagnostics = diagnostics;
+    }
+}

package/dist/lib/_internal/format-diagnostics.d.ts

@@ -0,0 +1,8 @@
+import { Diagnostic } from './diagnostics.js';
+export declare const formatDiagnostic: (diagnostic: Diagnostic) => string;
+export declare const formatDiagnostics: (diagnostics: Diagnostic[]) => string;
+export declare const countBySeverity: (diagnostics: Diagnostic[]) => {
+    errors: number;
+    warnings: number;
+};
+//# sourceMappingURL=format-diagnostics.d.ts.map

package/dist/lib/_internal/format-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-diagnostics.d.ts","sourceRoot":"","sources":["../../../src/lib/_internal/format-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,eAAO,MAAM,gBAAgB,GAAI,YAAY,UAAU,KAAG,MAIzD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,aAAa,UAAU,EAAE,KAAG,MACU,CAAA;AAExE,eAAO,MAAM,eAAe,GAAI,aAAa,UAAU,EAAE,KAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAG5F,CAAA"}

package/dist/lib/_internal/format-diagnostics.js

@@ -0,0 +1,10 @@
+export const formatDiagnostic = (diagnostic) => {
+    const location = [diagnostic.file, diagnostic.path].filter(Boolean).join(' ');
+    const suffix = location ? ` (${location})` : '';
+    return `${diagnostic.severity} [${diagnostic.code}] ${diagnostic.message}${suffix}`;
+};
+export const formatDiagnostics = (diagnostics) => diagnostics.map(diagnostic => formatDiagnostic(diagnostic)).join('\n');
+export const countBySeverity = (diagnostics) => ({
+    errors: diagnostics.filter(diagnostic => diagnostic.severity === 'error').length,
+    warnings: diagnostics.filter(diagnostic => diagnostic.severity === 'warning').length,
+});

package/dist/lib/_internal/generators/api/api-dto-generator.d.ts

@@ -0,0 +1,8 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates class-validator DTO classes for API endpoint requests, mirroring the
+ * hand-written NestJS DTOs (decorators derived from field type +
+ * constraints). Complements the Zod request schemas for a NestJS ValidationPipe.
+ */
+export declare const createApiDtoGenerator: () => Generator;
+//# sourceMappingURL=api-dto-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api-dto-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/api/api-dto-generator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAiG5E;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAAO,SAgBvC,CAAA"}

package/dist/lib/_internal/generators/api/api-dto-generator.js

@@ -0,0 +1,134 @@
+import { findModel } from '../../ir/ir.js';
+import { pascalCase, singleQuote } from '../support/naming.js';
+import { isRelation, relationFkName } from '../support/relations.js';
+import { headerBlocks } from '../support/header.js';
+const SCALAR_TS = {
+    string: 'string',
+    int: 'number',
+    int64: 'number',
+    float: 'number',
+    boolean: 'boolean',
+    timestamp: 'string',
+    date: 'string',
+    json: 'unknown',
+    id: 'string',
+};
+const payloadFields = (ir, payload) => payload.model ? (findModel(ir, payload.model)?.fields ?? []) : payload.fields;
+const propType = (ir, field) => {
+    let base;
+    if (isRelation(field)) {
+        base = 'string';
+    }
+    else if (field.type.kind === 'scalar') {
+        base = SCALAR_TS[field.type.name];
+    }
+    else if (field.type.kind === 'enum') {
+        const enumName = field.type.name;
+        const irEnum = ir.enums.find(e => e.name === enumName);
+        base = irEnum ? irEnum.values.map(singleQuote).join(' | ') : 'string';
+    }
+    else {
+        base = 'unknown';
+    }
+    return field.list ? `${base}[]` : base;
+};
+/** Emit class-validator decorators for a field, tracking which need importing. */
+const decoratorsFor = (ir, field, used) => {
+    const c = field.constraints;
+    const each = field.list ? '{ each: true }' : '';
+    const add = (name, args = '') => {
+        used.add(name);
+        return `  @${name}(${args})`;
+    };
+    const out = [];
+    if (field.optional)
+        out.push(add('IsOptional'));
+    if (field.list)
+        out.push(add('IsArray'));
+    if (isRelation(field) || (field.type.kind === 'scalar' && (field.type.name === 'string' || field.type.name === 'id'))) {
+        out.push(add('IsString', each));
+    }
+    else if (field.type.kind === 'scalar' && (field.type.name === 'int' || field.type.name === 'int64')) {
+        out.push(add('IsInt', each));
+    }
+    else if (field.type.kind === 'scalar' && field.type.name === 'float') {
+        out.push(add('IsNumber', each ? `{}, ${each}` : ''));
+    }
+    else if (field.type.kind === 'scalar' && field.type.name === 'boolean') {
+        out.push(add('IsBoolean', each));
+    }
+    else if (field.type.kind === 'scalar' && (field.type.name === 'timestamp' || field.type.name === 'date')) {
+        out.push(add('IsDateString', each));
+    }
+    else if (field.type.kind === 'enum') {
+        const enumName = field.type.name;
+        const irEnum = ir.enums.find(e => e.name === enumName);
+        const values = irEnum ? `[${irEnum.values.map(singleQuote).join(', ')}]` : '[]';
+        out.push(add('IsIn', each ? `${values}, ${each}` : values));
+    }
+    if (field.list) {
+        if (c.nonempty)
+            out.push(add('ArrayNotEmpty'));
+        if (c.minLength !== undefined)
+            out.push(add('ArrayMinSize', String(c.minLength)));
+        if (c.maxLength !== undefined)
+            out.push(add('ArrayMaxSize', String(c.maxLength)));
+    }
+    else {
+        if (c.nonempty)
+            out.push(add('IsNotEmpty'));
+        if (c.minLength !== undefined)
+            out.push(add('MinLength', String(c.minLength)));
+        if (c.maxLength !== undefined)
+            out.push(add('MaxLength', String(c.maxLength)));
+        if (c.min !== undefined)
+            out.push(add('Min', String(c.min)));
+        if (c.max !== undefined)
+            out.push(add('Max', String(c.max)));
+        if (c.email)
+            out.push(add('IsEmail'));
+        if (c.url)
+            out.push(add('IsUrl'));
+        if (c.pattern)
+            out.push(add('Matches', `/${c.pattern}/`));
+    }
+    return out;
+};
+const renderDto = (ir, api, used) => {
+    const fields = payloadFields(ir, api.request);
+    const className = `${pascalCase(api.name)}Dto`;
+    if (api.request.isVoid || fields.length === 0) {
+        return `export class ${className} {}`;
+    }
+    const members = fields
+        .map(field => {
+        const name = isRelation(field) ? relationFkName(field) : field.name;
+        const decorators = decoratorsFor(ir, field, used).join('\n');
+        const mark = field.optional ? '?' : '!';
+        return `${decorators}\n  ${name}${mark}: ${propType(ir, field)}`;
+    })
+        .join('\n\n');
+    return `export class ${className} {\n${members}\n}`;
+};
+/**
+ * Generates class-validator DTO classes for API endpoint requests, mirroring the
+ * hand-written NestJS DTOs (decorators derived from field type +
+ * constraints). Complements the Zod request schemas for a NestJS ValidationPipe.
+ */
+export const createApiDtoGenerator = () => ({
+    name: 'api-dto',
+    description: 'class-validator DTO classes for API requests',
+    generate(ir, context) {
+        if (ir.apis.length === 0) {
+            return [];
+        }
+        const used = new Set();
+        const dtoBlocks = ir.apis.map(api => renderDto(ir, api, used));
+        const blocks = [...headerBlocks(context)];
+        if (used.size > 0) {
+            blocks.push(`import { ${[...used].sort().join(', ')} } from 'class-validator'`);
+        }
+        blocks.push(...dtoBlocks);
+        return [{ path: 'api-dtos.ts', content: `${blocks.join('\n\n')}\n` }];
+    },
+});

package/dist/lib/_internal/generators/api/api-types-generator.d.ts

@@ -0,0 +1,8 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates request/response TypeScript types for each API endpoint. A payload
+ * can reference an existing model or declare inline fields; a void response maps
+ * to `void`. This mirrors the shared producer/consumer contract pattern.
+ */
+export declare const createApiTypesGenerator: () => Generator;
+//# sourceMappingURL=api-types-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api-types-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/api/api-types-generator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AA6E5E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAAO,SAwBzC,CAAA"}

package/dist/lib/_internal/generators/api/api-types-generator.js

@@ -0,0 +1,105 @@
+import { pascalCase } from '../support/naming.js';
+import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
+import { headerBlocks } from '../support/header.js';
+const SCALAR_TS = {
+    string: 'string',
+    int: 'number',
+    int64: 'number',
+    float: 'number',
+    boolean: 'boolean',
+    timestamp: 'string',
+    date: 'string',
+    json: 'Json',
+    id: 'string',
+};
+const renderFieldTsType = (ir, field) => {
+    let base;
+    if (isRelation(field)) {
+        base = SCALAR_TS[relationFkType(ir, field)];
+    }
+    else if (field.type.kind === 'scalar') {
+        base = SCALAR_TS[field.type.name];
+    }
+    else if (field.type.kind === 'enum' || field.type.kind === 'model') {
+        base = field.type.name;
+    }
+    else {
+        base = 'unknown';
+    }
+    return field.list ? `${base}[]` : base;
+};
+const renderField = (ir, field) => {
+    const name = isRelation(field) ? relationFkName(field) : field.name;
+    const optional = field.optional ? '?' : '';
+    const doc = field.description ? `  /** ${field.description} */\n` : '';
+    return `${doc}  ${name}${optional}: ${renderFieldTsType(ir, field)}`;
+};
+const renderPayloadType = (ir, payload, typeName) => {
+    if (payload.isVoid) {
+        return `export type ${typeName} = void`;
+    }
+    if (payload.model) {
+        return `export type ${typeName} = ${payload.model}`;
+    }
+    if (payload.fields.length === 0) {
+        return `export type ${typeName} = Record<string, never>`;
+    }
+    const fields = payload.fields.map(field => renderField(ir, field)).join('\n');
+    return `export interface ${typeName} {\n${fields}\n}`;
+};
+const collectImports = (ir) => {
+    const names = new Set();
+    const add = (payload) => {
+        if (payload.model)
+            names.add(payload.model);
+        for (const field of payload.fields) {
+            if (field.type.kind === 'enum' || (field.type.kind === 'model' && !isRelation(field))) {
+                names.add(field.type.name);
+            }
+            if (field.type.kind === 'scalar' && field.type.name === 'json') {
+                names.add('Json');
+            }
+        }
+    };
+    for (const api of ir.apis) {
+        add(api.request);
+        add(api.response);
+    }
+    return [...names].sort();
+};
+const apiComment = (api) => {
+    const bits = [`kind: ${api.kind}`];
+    if (api.method)
+        bits.push(`method: ${api.method}`);
+    if (api.description)
+        bits.unshift(api.description);
+    return `// ${api.name} — ${bits.join(' | ')}`;
+};
+/**
+ * Generates request/response TypeScript types for each API endpoint. A payload
+ * can reference an existing model or declare inline fields; a void response maps
+ * to `void`. This mirrors the shared producer/consumer contract pattern.
+ */
+export const createApiTypesGenerator = () => ({
+    name: 'api-types',
+    description: 'API request/response TypeScript types',
+    generate(ir, context) {
+        if (ir.apis.length === 0) {
+            return [];
+        }
+        const blocks = [...headerBlocks(context)];
+        const imports = collectImports(ir);
+        if (imports.length > 0) {
+            blocks.push(`import type { ${imports.join(', ')} } from './types.js'`);
+        }
+        for (const api of ir.apis) {
+            const pascal = pascalCase(api.name);
+            blocks.push([
+                apiComment(api),
+                renderPayloadType(ir, api.request, `${pascal}Request`),
+                renderPayloadType(ir, api.response, `${pascal}Response`),
+            ].join('\n'));
+        }
+        return [{ path: 'api-types.ts', content: `${blocks.join('\n\n')}\n` }];
+    },
+});

package/dist/lib/_internal/generators/api/api-validation-generator.d.ts

@@ -0,0 +1,7 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates Zod schemas that validate each endpoint's *request*. Model-backed
+ * requests are expanded to the model's fields so the schema is self-contained.
+ */
+export declare const createApiValidationGenerator: () => Generator;
+//# sourceMappingURL=api-validation-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api-validation-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/api/api-validation-generator.ts"],"names":[],"mappings":"AAIA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAqD5E;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAO,SAa9C,CAAA"}

package/dist/lib/_internal/generators/api/api-validation-generator.js

@@ -0,0 +1,73 @@
+import { findModel } from '../../ir/ir.js';
+import { pascalCase, singleQuote } from '../support/naming.js';
+import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
+import { zodConstraints } from '../support/constraints.js';
+import { headerBlocks } from '../support/header.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()',
+};
+/** Resolve a payload to its concrete field list (inline fields or a referenced model). */
+const payloadFields = (ir, payload) => {
+    if (payload.model) {
+        return findModel(ir, payload.model)?.fields ?? [];
+    }
+    return payload.fields;
+};
+const fieldSchema = (ir, field) => {
+    const name = isRelation(field) ? relationFkName(field) : field.name;
+    let schema;
+    if (isRelation(field)) {
+        schema = SCALAR_ZOD[relationFkType(ir, field)];
+    }
+    else if (field.type.kind === 'scalar') {
+        schema = SCALAR_ZOD[field.type.name];
+    }
+    else if (field.type.kind === 'enum') {
+        const enumName = field.type.name;
+        const irEnum = ir.enums.find(e => e.name === enumName);
+        schema = irEnum ? `z.enum([${irEnum.values.map(singleQuote).join(', ')}])` : 'z.string()';
+    }
+    else {
+        schema = 'z.unknown()';
+    }
+    const cons = zodConstraints(field);
+    schema = field.list ? `z.array(${schema})${cons}` : `${schema}${cons}`;
+    if (field.optional)
+        schema = `${schema}.optional()`;
+    return `  ${name}: ${schema},`;
+};
+const renderRequestSchema = (ir, api) => {
+    const name = `${pascalCase(api.name)}RequestSchema`;
+    const fields = payloadFields(ir, api.request);
+    if (api.request.isVoid || fields.length === 0) {
+        return `export const ${name} = z.object({})`;
+    }
+    const body = fields.map(field => fieldSchema(ir, field)).join('\n');
+    return `export const ${name} = z.object({\n${body}\n})`;
+};
+/**
+ * Generates Zod schemas that validate each endpoint's *request*. Model-backed
+ * requests are expanded to the model's fields so the schema is self-contained.
+ */
+export const createApiValidationGenerator = () => ({
+    name: 'api-validation',
+    description: 'API request-validation Zod schemas',
+    generate(ir, context) {
+        if (ir.apis.length === 0) {
+            return [];
+        }
+        const blocks = [...headerBlocks(context), "import { z } from 'zod'"];
+        for (const api of ir.apis) {
+            blocks.push(renderRequestSchema(ir, api));
+        }
+        return [{ path: 'api-validation.ts', content: `${blocks.join('\n\n')}\n` }];
+    },
+});

package/dist/lib/_internal/generators/api/task-payload-generator.d.ts

@@ -0,0 +1,9 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates Cloud Task / Pub/Sub payload contracts: a generic envelope type per
+ * declared envelope (`RetryTaskPayload<T> = T & { … }`), plus per-task
+ * `<Name>TaskData` + `<Name>TaskPayload` and delivery constants (max attempts,
+ * timeout, topic) — the shared payload contracts an app otherwise hand-writes.
+ */
+export declare const createTaskPayloadGenerator: () => Generator;
+//# sourceMappingURL=task-payload-generator.d.ts.map

package/dist/lib/_internal/generators/api/task-payload-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-payload-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/api/task-payload-generator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAuE5E;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,QAAO,SAqB5C,CAAA"}