firebase-contract 0.1.0-rc.0

package/dist/lib/_internal/validation/rules.js

@@ -0,0 +1,282 @@
+import { error, warning } from '../diagnostics.js';
+import { findModel } from '../ir/ir.js';
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Every field type must resolve to a known scalar, enum, or model. */
+export const unresolvedTypes = ir => ir.models.flatMap(model => model.fields
+    .filter(field => field.type.kind === 'unresolved')
+    .map(field => error('UNRESOLVED_TYPE', `Unknown type "${field.type.name}" on ${model.name}.${field.name}`, {
+    file: model.sourceFile,
+    path: `models.${model.name}.fields.${field.name}`,
+})));
+/** Enums must declare at least one value. */
+export const emptyEnums = ir => ir.enums
+    .filter(irEnum => irEnum.values.length === 0)
+    .map(irEnum => error('EMPTY_ENUM', `Enum "${irEnum.name}" has no values`, {
+    file: irEnum.sourceFile,
+    path: `enums.${irEnum.name}`,
+}));
+/** Enum values should be unique. */
+export const duplicateEnumValues = ir => ir.enums.flatMap(irEnum => {
+    const seen = new Set();
+    const diagnostics = [];
+    for (const value of irEnum.values) {
+        if (seen.has(value)) {
+            diagnostics.push(warning('DUPLICATE_ENUM_VALUE', `Enum "${irEnum.name}" repeats value "${value}"`, {
+                file: irEnum.sourceFile,
+                path: `enums.${irEnum.name}`,
+            }));
+        }
+        seen.add(value);
+    }
+    return diagnostics;
+});
+/** Model and enum names must be valid identifiers so generators can emit them. */
+export const validNames = ir => {
+    const diagnostics = [];
+    for (const irEnum of ir.enums) {
+        if (!IDENTIFIER.test(irEnum.name)) {
+            diagnostics.push(error('INVALID_NAME', `Enum name "${irEnum.name}" is not a valid identifier`, {
+                file: irEnum.sourceFile,
+                path: `enums.${irEnum.name}`,
+            }));
+        }
+    }
+    for (const model of ir.models) {
+        if (!IDENTIFIER.test(model.name)) {
+            diagnostics.push(error('INVALID_NAME', `Model name "${model.name}" is not a valid identifier`, {
+                file: model.sourceFile,
+                path: `models.${model.name}`,
+            }));
+        }
+        for (const field of model.fields) {
+            if (!IDENTIFIER.test(field.name)) {
+                diagnostics.push(error('INVALID_NAME', `Field name "${field.name}" on ${model.name} is not a valid identifier`, {
+                    file: model.sourceFile,
+                    path: `models.${model.name}.fields.${field.name}`,
+                }));
+            }
+        }
+    }
+    return diagnostics;
+};
+/** Primary-identifier constraints: at most one, not a list, ideally required. */
+export const idFields = ir => ir.models.flatMap(model => {
+    const diagnostics = [];
+    const ids = model.fields.filter(field => field.isId);
+    if (ids.length > 1) {
+        diagnostics.push(error('MULTIPLE_IDS', `Model "${model.name}" declares ${ids.length} id fields; only one is allowed`, {
+            file: model.sourceFile,
+            path: `models.${model.name}`,
+        }));
+    }
+    for (const field of ids) {
+        if (field.list) {
+            diagnostics.push(error('INVALID_ID', `Id field "${model.name}.${field.name}" cannot be a list`, {
+                file: model.sourceFile,
+                path: `models.${model.name}.fields.${field.name}`,
+            }));
+        }
+        if (field.optional) {
+            diagnostics.push(warning('OPTIONAL_ID', `Id field "${model.name}.${field.name}" is optional`, {
+                file: model.sourceFile,
+                path: `models.${model.name}.fields.${field.name}`,
+            }));
+        }
+    }
+    return diagnostics;
+});
+/** Composite key and index field names must exist on the model. */
+export const modelKeysAndIndexes = ir => ir.models.flatMap(model => {
+    const diagnostics = [];
+    const fieldNames = new Set(model.fields.map(field => field.name));
+    // Index/unique fields may also reference a relation's FK *column* name
+    // (`ownerId` for relation field `owner`), matching real DC schemas.
+    for (const field of model.fields) {
+        if (field.relation && field.type.kind === 'model') {
+            fieldNames.add(`${field.name}Id`);
+        }
+    }
+    for (const name of model.key) {
+        if (!fieldNames.has(name)) {
+            diagnostics.push(error('UNKNOWN_KEY_FIELD', `Model "${model.name}" key references unknown field "${name}"`, {
+                file: model.sourceFile,
+                path: `models.${model.name}.key`,
+            }));
+        }
+    }
+    for (const index of model.indexes) {
+        for (const name of index.fields) {
+            if (!fieldNames.has(name)) {
+                diagnostics.push(error('UNKNOWN_INDEX_FIELD', `Model "${model.name}" index references unknown field "${name}"`, {
+                    file: model.sourceFile,
+                    path: `models.${model.name}.indexes`,
+                }));
+            }
+        }
+    }
+    return diagnostics;
+});
+/** A `relation` flag is only meaningful on a model-typed field. */
+export const relationFields = ir => ir.models.flatMap(model => model.fields
+    .filter(field => field.relation && field.type.kind !== 'model')
+    .map(field => error('INVALID_RELATION', `Field "${model.name}.${field.name}" is marked relation but its type is not a model`, {
+    file: model.sourceFile,
+    path: `models.${model.name}.fields.${field.name}`,
+})));
+/** Operations must target a known model, use valid field names, and pair type/action correctly. */
+export const operations = ir => ir.operations.flatMap(op => {
+    const diagnostics = [];
+    const model = findModel(ir, op.model);
+    const loc = { file: op.sourceFile, path: `operations.${op.name}` };
+    if (!model) {
+        diagnostics.push(error('UNKNOWN_OPERATION_MODEL', `Operation "${op.name}" targets unknown model "${op.model}"`, loc));
+        return diagnostics;
+    }
+    // Raw operations are emitted verbatim; their body is not described by
+    // inputs/where/select, so field-level checks do not apply.
+    if (op.raw !== undefined)
+        return diagnostics;
+    const fieldNames = new Set(model.fields.map(field => field.name));
+    const checkField = (kind, name) => {
+        if (!fieldNames.has(name)) {
+            diagnostics.push(error('UNKNOWN_OPERATION_FIELD', `Operation "${op.name}" ${kind} references unknown field "${name}" on ${op.model}`, loc));
+        }
+    };
+    for (const input of op.inputs)
+        checkField('inputs', input.field);
+    const relFkNames = new Set(model.fields.filter(f => f.relation && f.type.kind === 'model').map(f => `${f.name}Id`));
+    const checkWherePath = (path) => {
+        const dot = path.indexOf('.');
+        if (dot <= 0) {
+            checkField('where', path);
+            return;
+        }
+        const rel = model.fields.find(f => f.name === path.slice(0, dot));
+        if (!rel || rel.type.kind !== 'model') {
+            checkField('where', path.slice(0, dot));
+            return;
+        }
+        const related = findModel(ir, rel.type.name);
+        if (related && !related.fields.some(f => f.name === path.slice(dot + 1))) {
+            diagnostics.push(error('UNKNOWN_OPERATION_FIELD', `Operation "${op.name}" where references unknown field "${path}" on ${op.model}`, loc));
+        }
+    };
+    const checkSelect = (entries, m) => {
+        for (const entry of entries) {
+            // Reverse-join selections (x_on_y) reference the related table's side;
+            // they are rendered verbatim and not validated against this model.
+            if (entry.field.includes('_on_'))
+                continue;
+            const field = m.fields.find(f => f.name === entry.field);
+            if (!field) {
+                diagnostics.push(error('UNKNOWN_OPERATION_FIELD', `Operation "${op.name}" select references unknown field "${entry.field}" on ${m.name}`, loc));
+                continue;
+            }
+            if (entry.select && entry.select.length > 0) {
+                if (field.type.kind === 'model') {
+                    const related = findModel(ir, field.type.name);
+                    if (related)
+                        checkSelect(entry.select, related);
+                }
+            }
+        }
+    };
+    checkSelect(op.select, model);
+    for (const where of op.where)
+        checkWherePath(where.field);
+    for (const order of op.orderBy) {
+        if (!relFkNames.has(order.field))
+            checkField('orderBy', order.field);
+    }
+    for (const expr of op.exprs)
+        checkField('exprs', expr.field);
+    for (const entry of op.inc)
+        checkField('inc', entry.field);
+    if (op.operationType === 'mutation' && !op.action) {
+        diagnostics.push(error('MISSING_MUTATION_ACTION', `Mutation "${op.name}" needs an "action" (insert|update|upsert|delete)`, loc));
+    }
+    if (op.operationType === 'query' && op.action) {
+        diagnostics.push(warning('UNUSED_ACTION', `Query "${op.name}" ignores its "action"`, loc));
+    }
+    if (op.auth === 'PUBLIC' && !op.authReason) {
+        diagnostics.push(warning('MISSING_AUTH_REASON', `Operation "${op.name}" is PUBLIC without an "authReason"`, loc));
+    }
+    return diagnostics;
+});
+/** API request/response payloads that reference a model must reference a known one. */
+export const apis = ir => ir.apis.flatMap(api => {
+    const diagnostics = [];
+    const loc = { file: api.sourceFile, path: `apis.${api.name}` };
+    const checkPayload = (payload, which) => {
+        if (payload.model && !findModel(ir, payload.model)) {
+            diagnostics.push(error('UNKNOWN_API_MODEL', `Api "${api.name}" ${which} references unknown model "${payload.model}"`, loc));
+        }
+    };
+    checkPayload(api.request, 'request');
+    checkPayload(api.response, 'response');
+    return diagnostics;
+});
+/** Firestore projections must derive from a known model with valid pick/omit fields. */
+export const firestore = ir => ir.firestore.flatMap(doc => {
+    const diagnostics = [];
+    const loc = { file: doc.sourceFile, path: `firestore.${doc.name}` };
+    if (doc.pick.length > 0 && doc.omit.length > 0) {
+        diagnostics.push(warning('PICK_AND_OMIT', `Firestore doc "${doc.name}" sets both pick and omit; omit is ignored`, loc));
+    }
+    if (!doc.from) {
+        // A projection with no base model must declare its own fields.
+        if (doc.fields.length === 0) {
+            diagnostics.push(error('EMPTY_FIRESTORE_DOC', `Firestore doc "${doc.name}" has no "from" and no fields`, loc));
+        }
+        return diagnostics;
+    }
+    const model = findModel(ir, doc.from);
+    if (!model) {
+        diagnostics.push(error('UNKNOWN_FIRESTORE_MODEL', `Firestore doc "${doc.name}" derives from unknown model "${doc.from}"`, loc));
+        return diagnostics;
+    }
+    const fieldNames = new Set(model.fields.map(field => field.name));
+    for (const [kind, names] of [
+        ['pick', doc.pick],
+        ['omit', doc.omit],
+    ]) {
+        for (const name of names) {
+            if (!fieldNames.has(name)) {
+                diagnostics.push(error('UNKNOWN_FIRESTORE_FIELD', `Firestore doc "${doc.name}" ${kind} references unknown field "${name}" on ${doc.from}`, loc));
+            }
+        }
+    }
+    return diagnostics;
+});
+/** Union variants must be known models, each carrying the discriminant field. */
+export const unions = ir => ir.unions.flatMap(union => {
+    const diagnostics = [];
+    const loc = { file: union.sourceFile, path: `unions.${union.name}` };
+    if (union.variants.length === 0) {
+        diagnostics.push(error('EMPTY_UNION', `Union "${union.name}" has no variants`, loc));
+    }
+    for (const variant of union.variants) {
+        const model = findModel(ir, variant);
+        if (!model) {
+            diagnostics.push(error('UNKNOWN_UNION_VARIANT', `Union "${union.name}" references unknown model "${variant}"`, loc));
+            continue;
+        }
+        if (!model.fields.some(field => field.name === union.discriminant)) {
+            diagnostics.push(error('MISSING_DISCRIMINANT', `Union "${union.name}" variant "${variant}" lacks discriminant field "${union.discriminant}"`, loc));
+        }
+    }
+    return diagnostics;
+});
+export const DEFAULT_RULES = [
+    unresolvedTypes,
+    emptyEnums,
+    duplicateEnumValues,
+    validNames,
+    idFields,
+    modelKeysAndIndexes,
+    relationFields,
+    operations,
+    apis,
+    firestore,
+    unions,
+];

package/dist/lib/_internal/validation/validate.d.ts

@@ -0,0 +1,9 @@
+import { Diagnostic } from '../diagnostics.js';
+import { Ir } from '../ir/ir.js';
+import { ValidationRule } from './rules.js';
+/**
+ * Run semantic validation over the IR. Callers may pass a custom rule set to
+ * add or replace checks; by default the built-in {@link DEFAULT_RULES} run.
+ */
+export declare const validateIr: (ir: Ir, rules?: ValidationRule[]) => Diagnostic[];
+//# sourceMappingURL=validate.d.ts.map

package/dist/lib/_internal/validation/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/lib/_internal/validation/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAEhC,OAAO,EAAiB,cAAc,EAAE,MAAM,YAAY,CAAA;AAE1D;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,IAAI,EAAE,EAAE,QAAO,cAAc,EAAkB,KAAG,UAAU,EACtD,CAAA"}

package/dist/lib/_internal/validation/validate.js

@@ -0,0 +1,6 @@
+import { DEFAULT_RULES } from './rules.js';
+/**
+ * Run semantic validation over the IR. Callers may pass a custom rule set to
+ * add or replace checks; by default the built-in {@link DEFAULT_RULES} run.
+ */
+export const validateIr = (ir, rules = DEFAULT_RULES) => rules.flatMap(rule => rule(ir));

package/dist/lib/cli/commands/generate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const registerGenerate: (program: Command) => void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/lib/cli/commands/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/lib/cli/commands/generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAenC,eAAO,MAAM,gBAAgB,GAAI,SAAS,OAAO,KAAG,IAqEnD,CAAA"}

package/dist/lib/cli/commands/generate.js

@@ -0,0 +1,66 @@
+import { generate, generateAll } from '../../_internal/compiler/compiler.js';
+import { DEFAULT_HEADER, toHeaderComment } from '../../_internal/generators/support/header.js';
+import { countBySeverity, formatDiagnostics } from '../../_internal/format-diagnostics.js';
+import { createDefaultRegistry } from '../../_internal/generators/index.js';
+import { loadConfig } from '../config.js';
+export const registerGenerate = (program) => {
+    program
+        .command('generate')
+        .description('Generate outputs from a contract')
+        .argument('[entry]', 'entry contract file')
+        .option('-o, --out-dir <dir>', 'output directory')
+        .option('-g, --generators <list>', 'comma-separated generator names')
+        .option('--header [text]', 'prepend a comment header to generated files (bare --header = default banner; omitted = contract `header:` or none)')
+        .action((entryArg, flags) => {
+        const config = loadConfig();
+        const entry = entryArg ?? config.entry ?? 'contract.yml';
+        const outDir = flags.outDir ?? config.outDir ?? 'generated';
+        const generators = flags.generators?.split(',').map(name => name.trim()).filter(Boolean) ?? config.generators;
+        const header = flags.header === true ? DEFAULT_HEADER : typeof flags.header === 'string' ? toHeaderComment(flags.header) : undefined;
+        const registry = createDefaultRegistry();
+        const context = header !== undefined ? { header } : undefined;
+        // Without -o/-g, run every `generate:` target declared in the contract
+        // graph — the one-command flow. Flags switch back to single-target mode.
+        const explicit = flags.outDir !== undefined || flags.generators !== undefined || config.outDir !== undefined || config.generators !== undefined;
+        if (!explicit) {
+            const all = generateAll(entry, { registry, write: true, ...(context ? { context } : {}) });
+            if (all.targets.length > 0 || !all.ok) {
+                if (all.diagnostics.length > 0) {
+                    console.log(formatDiagnostics(all.diagnostics));
+                }
+                if (!all.ok) {
+                    const { errors } = countBySeverity(all.diagnostics);
+                    console.error(`\n✖ generation aborted: ${errors} error(s)`);
+                    process.exit(1);
+                }
+                let total = 0;
+                for (const target of all.targets) {
+                    total += target.files.length;
+                    console.log(`✔ ${target.files.length} file(s) → ${target.outDir} (${target.generators.join(', ')})`);
+                }
+                console.log(`\n✔ ${total} file(s) written from ${all.targets.length} target(s)`);
+                return;
+            }
+            // No declared targets anywhere: fall through to single-target mode.
+        }
+        const result = generate(entry, {
+            outDir,
+            generators,
+            registry,
+            write: true,
+            ...(context ? { context } : {}),
+        });
+        if (result.diagnostics.length > 0) {
+            console.log(formatDiagnostics(result.diagnostics));
+        }
+        if (!result.ok) {
+            const { errors } = countBySeverity(result.diagnostics);
+            console.error(`\n✖ generation aborted: ${errors} error(s)`);
+            process.exit(1);
+        }
+        for (const file of result.files) {
+            console.log(`generated ${file.path}`);
+        }
+        console.log(`\n✔ ${result.files.length} file(s) written to ${outDir}`);
+    });
+};

package/dist/lib/cli/commands/index.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+/** Register every CLI command on the program. */
+export declare const registerCommands: (program: Command) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/cli/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/cli/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAOnC,iDAAiD;AACjD,eAAO,MAAM,gBAAgB,GAAI,SAAS,OAAO,KAAG,IAKnD,CAAA"}

package/dist/lib/cli/commands/index.js

@@ -0,0 +1,11 @@
+import { registerGenerate } from './generate.js';
+import { registerInit } from './init.js';
+import { registerInspect } from './inspect.js';
+import { registerValidate } from './validate.js';
+/** Register every CLI command on the program. */
+export const registerCommands = (program) => {
+    registerInit(program);
+    registerValidate(program);
+    registerGenerate(program);
+    registerInspect(program);
+};

package/dist/lib/cli/commands/init.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const registerInit: (program: Command) => void;
+//# sourceMappingURL=init.d.ts.map

package/dist/lib/cli/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/lib/cli/commands/init.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAgEnC,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,KAAG,IAgB/C,CAAA"}

package/dist/lib/cli/commands/init.js

@@ -0,0 +1,72 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { CONFIG_FILENAME } from '../config.js';
+const EXAMPLE_CONTRACT = `version: 1
+
+enums:
+  ProductStatus:
+    description: Lifecycle state of a product
+    values:
+      - todo
+      - in_progress
+      - done
+
+models:
+  User:
+    description: An application user
+    fields:
+      id: { type: id, id: true }
+      name: string
+      email: string
+
+  Product:
+    description: A unit of work
+    fields:
+      id: { type: id, id: true }
+      title: string
+      status: ProductStatus
+      priority: { type: int, optional: true }
+      tags: { type: string, list: true }
+      assignee: { type: User, optional: true }
+      metadata: { type: json, optional: true }
+      createdAt: timestamp
+`;
+const EXAMPLE_CONFIG = JSON.stringify({
+    entry: 'contract.yml',
+    outDir: 'generated',
+    generators: [
+        'typescript',
+        'zod',
+        'data-connect-graphql',
+        'data-connect-operations',
+        'data-connect-adapter',
+        'firestore-types',
+        'firestore',
+        'api-types',
+        'api-validation',
+    ],
+}, null, 2) + '\n';
+const writeIfAbsent = (path, content, force) => {
+    if (existsSync(path) && !force) {
+        return false;
+    }
+    writeFileSync(path, content, 'utf8');
+    return true;
+};
+export const registerInit = (program) => {
+    program
+        .command('init')
+        .description('Scaffold a starter contract.yml and firebase-contract.json')
+        .option('-f, --force', 'overwrite existing files', false)
+        .action((options) => {
+        const cwd = process.cwd();
+        const targets = [
+            [resolve(cwd, 'contract.yml'), EXAMPLE_CONTRACT],
+            [resolve(cwd, CONFIG_FILENAME), EXAMPLE_CONFIG],
+        ];
+        for (const [path, content] of targets) {
+            const written = writeIfAbsent(path, content, Boolean(options.force));
+            console.log(written ? `created ${path}` : `skipped ${path} (already exists)`);
+        }
+    });
+};

package/dist/lib/cli/commands/inspect.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const registerInspect: (program: Command) => void;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/lib/cli/commands/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../../src/lib/cli/commands/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAOnC,eAAO,MAAM,eAAe,GAAI,SAAS,OAAO,KAAG,IAmBlD,CAAA"}

package/dist/lib/cli/commands/inspect.js

@@ -0,0 +1,23 @@
+import { compile } from '../../_internal/compiler/compiler.js';
+import { formatDiagnostics } from '../../_internal/format-diagnostics.js';
+import { hasErrors } from '../../_internal/diagnostics.js';
+import { loadConfig } from '../config.js';
+export const registerInspect = (program) => {
+    program
+        .command('inspect')
+        .description('Print the normalized IR for a contract (for debugging)')
+        .argument('[entry]', 'entry contract file')
+        .action((entryArg) => {
+        const config = loadConfig();
+        const entry = entryArg ?? config.entry ?? 'contract.yml';
+        const { ir, diagnostics } = compile(entry);
+        if (diagnostics.length > 0) {
+            console.error(formatDiagnostics(diagnostics));
+            console.error('');
+        }
+        console.log(JSON.stringify(ir, null, 2));
+        if (hasErrors(diagnostics)) {
+            process.exit(1);
+        }
+    });
+};

package/dist/lib/cli/commands/validate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const registerValidate: (program: Command) => void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/lib/cli/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/lib/cli/commands/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAMnC,eAAO,MAAM,gBAAgB,GAAI,SAAS,OAAO,KAAG,IAoBnD,CAAA"}

package/dist/lib/cli/commands/validate.js

@@ -0,0 +1,23 @@
+import { compile } from '../../_internal/compiler/compiler.js';
+import { countBySeverity, formatDiagnostics } from '../../_internal/format-diagnostics.js';
+import { loadConfig } from '../config.js';
+export const registerValidate = (program) => {
+    program
+        .command('validate')
+        .description('Parse, resolve imports, and semantically validate a contract')
+        .argument('[entry]', 'entry contract file')
+        .action((entryArg) => {
+        const config = loadConfig();
+        const entry = entryArg ?? config.entry ?? 'contract.yml';
+        const { diagnostics } = compile(entry);
+        if (diagnostics.length > 0) {
+            console.log(formatDiagnostics(diagnostics));
+        }
+        const { errors, warnings } = countBySeverity(diagnostics);
+        if (errors > 0) {
+            console.error(`\n✖ ${errors} error(s), ${warnings} warning(s)`);
+            process.exit(1);
+        }
+        console.log(`✔ ${entry} is valid${warnings > 0 ? ` (${warnings} warning(s))` : ''}`);
+    });
+};

package/dist/lib/cli/config.d.ts

@@ -0,0 +1,12 @@
+export declare const CONFIG_FILENAME = "firebase-contract.json";
+export interface FbcConfig {
+    entry?: string;
+    outDir?: string;
+    generators?: string[];
+}
+/**
+ * Load `firebase-contract.json` from `cwd` if present. CLI flags override these
+ * values; the config only supplies defaults so common invocations stay short.
+ */
+export declare const loadConfig: (cwd?: string) => FbcConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/lib/cli/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/config.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,2BAA2B,CAAA;AAEvD,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,MAAK,MAAsB,KAAG,SAWxD,CAAA"}

package/dist/lib/cli/config.js

@@ -0,0 +1,20 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+export const CONFIG_FILENAME = 'firebase-contract.json';
+/**
+ * Load `firebase-contract.json` from `cwd` if present. CLI flags override these
+ * values; the config only supplies defaults so common invocations stay short.
+ */
+export const loadConfig = (cwd = process.cwd()) => {
+    const path = resolve(cwd, CONFIG_FILENAME);
+    if (!existsSync(path)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return parsed ?? {};
+    }
+    catch {
+        return {};
+    }
+};

package/dist/lib/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/index.ts"],"names":[],"mappings":""}

package/dist/lib/cli/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { registerCommands } from './commands/index.js';
+import { getVersion } from './version.js';
+program
+    .name('firebase-contract')
+    .description('Generate types, validation, and Firebase artifacts from a YAML contract')
+    .version(getVersion());
+registerCommands(program);
+program.parseAsync(process.argv).catch((cause) => {
+    console.error(cause instanceof Error ? cause.message : String(cause));
+    process.exit(1);
+});

package/dist/lib/cli/version.d.ts

@@ -0,0 +1,3 @@
+/** Read the package version from package.json relative to the built CLI file. */
+export declare const getVersion: () => string;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/cli/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/version.ts"],"names":[],"mappings":"AAIA,iFAAiF;AACjF,eAAO,MAAM,UAAU,QAAO,MAS7B,CAAA"}

package/dist/lib/cli/version.js

@@ -0,0 +1,15 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Read the package version from package.json relative to the built CLI file. */
+export const getVersion = () => {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        // dist/lib/cli/version.js -> package root is three levels up.
+        const pkg = JSON.parse(readFileSync(join(here, '../../../package.json'), 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+};

package/dist/lib/modules/runtime.d.ts

@@ -0,0 +1,2 @@
+export * from '../_internal/runtime/index.js';
+//# sourceMappingURL=runtime.d.ts.map

package/dist/lib/modules/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/lib/modules/runtime.ts"],"names":[],"mappings":"AAEA,cAAc,4BAA4B,CAAA"}

package/dist/lib/modules/runtime.js

@@ -0,0 +1,3 @@
+// Public entry for `firebase-contract/runtime`. Thin re-export of the internal
+// implementation, used by generated Data Connect adapters.
+export * from '../_internal/runtime/index.js';