firebase-contract 0.1.0-rc.0

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

@@ -0,0 +1,96 @@
+import { findModel } from '../../ir/ir.js';
+import { constantCase, pascalCase, singleQuote } 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: 'unknown',
+    id: 'string',
+};
+const isTask = (api) => api.kind === 'task' || api.kind === 'pubsub';
+const fieldTs = (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 renderMember = (ir, field) => {
+    const name = isRelation(field) ? relationFkName(field) : field.name;
+    return `  ${name}${field.optional ? '?' : ''}: ${fieldTs(ir, field)}`;
+};
+const payloadFields = (ir, payload) => payload.model ? (findModel(ir, payload.model)?.fields ?? []) : payload.fields;
+const renderEnvelope = (env) => {
+    const doc = env.description ? `/** ${env.description} */\n` : '';
+    const members = env.fields.map(field => `  ${field.name}${field.optional ? '?' : ''}: ${SCALAR_TS[field.type.kind === 'scalar' ? field.type.name : 'string']}`).join('\n');
+    return `${doc}export type ${env.name}<T> = T & {\n${members}\n}`;
+};
+const renderTask = (ir, api) => {
+    const name = pascalCase(api.name);
+    const fields = payloadFields(ir, api.request);
+    const dataBody = fields.length > 0 ? fields.map(field => renderMember(ir, field)).join('\n') : '';
+    const dataType = fields.length > 0 ? `export interface ${name}TaskData {\n${dataBody}\n}` : `export type ${name}TaskData = Record<string, never>`;
+    const envelope = api.task?.envelope;
+    const payloadType = envelope
+        ? `export type ${name}TaskPayload = ${envelope}<${name}TaskData>`
+        : `export type ${name}TaskPayload = ${name}TaskData`;
+    const constants = [];
+    const CONST = constantCase(api.name);
+    if (api.task?.maxAttempts !== undefined)
+        constants.push(`export const ${CONST}_MAX_ATTEMPTS = ${api.task.maxAttempts}`);
+    if (api.task?.timeoutSeconds !== undefined)
+        constants.push(`export const ${CONST}_TIMEOUT_SECONDS = ${api.task.timeoutSeconds}`);
+    if (api.task?.topic !== undefined)
+        constants.push(`export const ${CONST}_TOPIC = ${singleQuote(api.task.topic)}`);
+    return [dataType, payloadType, ...constants].join('\n');
+};
+const collectImports = (ir, tasks) => {
+    const names = new Set();
+    for (const api of tasks) {
+        for (const field of payloadFields(ir, api.request)) {
+            if (field.type.kind === 'enum' || (field.type.kind === 'model' && !isRelation(field))) {
+                names.add(field.type.name);
+            }
+        }
+    }
+    return [...names].sort();
+};
+/**
+ * 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 const createTaskPayloadGenerator = () => ({
+    name: 'task-payloads',
+    description: 'Cloud Task/Pub-Sub payload envelopes, data/payload types, and constants',
+    generate(ir, context) {
+        const tasks = ir.apis.filter(isTask);
+        if (ir.envelopes.length === 0 && tasks.length === 0) {
+            return [];
+        }
+        const blocks = [...headerBlocks(context)];
+        const imports = collectImports(ir, tasks);
+        if (imports.length > 0) {
+            blocks.push(`import type { ${imports.join(', ')} } from './types.js'`);
+        }
+        for (const env of ir.envelopes) {
+            blocks.push(renderEnvelope(env));
+        }
+        for (const api of tasks) {
+            blocks.push(renderTask(ir, api));
+        }
+        return [{ path: 'task-payloads.ts', content: `${blocks.join('\n\n')}\n` }];
+    },
+});

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

@@ -0,0 +1,9 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates project topology artifacts from a single source: per-service Data
+ * Connect `dataconnect.yaml`, per-connector `connector.yaml` (package/outputDir
+ * are pure string formulas), and the sync constants (`FIRESTORE_DATABASES`,
+ * `API_CODEBASES`) that would otherwise be kept in sync by hand.
+ */
+export declare const createConfigGenerator: () => Generator;
+//# sourceMappingURL=config-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/config/config-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAqD5E;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAO,SAuBvC,CAAA"}

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

@@ -0,0 +1,71 @@
+import { constantCase, singleQuote } from '../support/naming.js';
+import { headerFor } from '../support/header.js';
+const DEFAULT_LOCATION = 'asia-northeast1';
+const dataconnectYaml = (service) => {
+    const connectorDirs = service.connectors.map(c => `./connectors/${c}`);
+    return [
+        'specVersion: v1beta',
+        `serviceId: ${service.name}`,
+        `location: ${service.location ?? DEFAULT_LOCATION}`,
+        'schema:',
+        '  source: ./schema',
+        ...(service.database ? ['  datasource:', '    postgresql:', `      database: ${service.database}`] : []),
+        `connectorDirs: [${connectorDirs.map(d => `'${d}'`).join(', ')}]`,
+        '',
+    ].join('\n');
+};
+const connectorYaml = (service, connector) => [
+    `connectorId: ${connector}`,
+    'generate:',
+    '  javascriptSdk:',
+    `    outputDir: ../../../dataconnect-generated/${connector}`,
+    `    package: '@dataconnect/${service.name}-generated-${connector}'`,
+    '    react: true',
+    '',
+].join('\n');
+const constantsTs = (project, header) => {
+    const blocks = header ? [header] : [];
+    if (project.services.length > 0) {
+        const entries = project.services
+            .map(s => `  ${constantCase(s.name)}: ${singleQuote(s.database ?? s.name)},`)
+            .join('\n');
+        blocks.push(`export const FIRESTORE_DATABASES = Object.freeze({\n${entries}\n} as const)`, 'export type FirestoreDatabaseKey = keyof typeof FIRESTORE_DATABASES');
+    }
+    if (project.codebases.length > 0) {
+        const entries = project.codebases
+            .map(c => `  ${constantCase(c.service)}: ${singleQuote(c.codebase)},`)
+            .join('\n');
+        blocks.push(`export const API_CODEBASES = Object.freeze({\n${entries}\n} as const)`, 'export type ApiCodebaseKey = keyof typeof API_CODEBASES');
+    }
+    return `${blocks.join('\n\n')}\n`;
+};
+/**
+ * Generates project topology artifacts from a single source: per-service Data
+ * Connect `dataconnect.yaml`, per-connector `connector.yaml` (package/outputDir
+ * are pure string formulas), and the sync constants (`FIRESTORE_DATABASES`,
+ * `API_CODEBASES`) that would otherwise be kept in sync by hand.
+ */
+export const createConfigGenerator = () => ({
+    name: 'config',
+    description: 'Data Connect service/connector configs + project sync constants',
+    generate(ir, context) {
+        const project = ir.project;
+        if (!project) {
+            return [];
+        }
+        const files = [];
+        for (const service of project.services) {
+            files.push({ path: `${service.name}/dataconnect.yaml`, content: dataconnectYaml(service) });
+            for (const connector of service.connectors) {
+                files.push({
+                    path: `${service.name}/connectors/${connector}/connector.yaml`,
+                    content: connectorYaml(service, connector),
+                });
+            }
+        }
+        if (project.services.length > 0 || project.codebases.length > 0) {
+            files.push({ path: 'constants.ts', content: constantsTs(project, headerFor(context)) });
+        }
+        return files;
+    },
+});

package/dist/lib/_internal/generators/data-connect/adapter-generator.d.ts

@@ -0,0 +1,8 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates typed adapters that convert between a Data Connect row (json and
+ * embedded-model fields typed as `Any`) and the logical TypeScript type,
+ * restoring the logical type through the runtime `fromAny`/`toAny` helpers.
+ */
+export declare const createDataConnectAdapterGenerator: () => Generator;
+//# sourceMappingURL=adapter-generator.d.ts.map

package/dist/lib/_internal/generators/data-connect/adapter-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/data-connect/adapter-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAsI5E;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,QAAO,SAmBnD,CAAA"}

package/dist/lib/_internal/generators/data-connect/adapter-generator.js

@@ -0,0 +1,142 @@
+import { camelCase } from '../support/naming.js';
+import { headerBlocks } from '../support/header.js';
+import { isRelation, relationFkName, relationFkType } from '../support/relations.js';
+const SCALAR_TS = {
+    string: 'string',
+    int: 'number',
+    int64: 'number',
+    float: 'number',
+    boolean: 'boolean',
+    timestamp: 'string',
+    date: 'string',
+    json: 'Json',
+    id: 'string',
+};
+/**
+ * Whether the field collapses to `Any` in Data Connect (json or *embedded*
+ * model). Relations are FK id scalars, not `Any`, so they are excluded.
+ */
+const isAnyBacked = (field) => (field.type.kind === 'model' && !isRelation(field)) ||
+    field.type.kind === 'unresolved' ||
+    (field.type.kind === 'scalar' && field.type.name === 'json');
+/** The property name of the field on both the row and the logical type. */
+const fieldKey = (field) => (isRelation(field) ? relationFkName(field) : field.name);
+const logicalBase = (ref) => {
+    switch (ref.kind) {
+        case 'scalar':
+            return SCALAR_TS[ref.name];
+        case 'enum':
+        case 'model':
+            return ref.name;
+        default:
+            return 'unknown';
+    }
+};
+const withList = (base, list) => (list ? `${base}[]` : base);
+const rowFieldType = (field, ir) => {
+    if (field.literal !== undefined) {
+        return withList(`'${field.literal}'`, field.list);
+    }
+    if (isRelation(field)) {
+        return withList(SCALAR_TS[relationFkType(ir, field)], field.list);
+    }
+    const base = isAnyBacked(field) ? 'Any' : logicalBase(field.type);
+    return withList(base, field.list);
+};
+const optionalMark = (field) => (field.optional ? '?' : '');
+/** Expression that maps a Data Connect row field back to the logical value. */
+const fromExpr = (field) => {
+    const access = `row.${fieldKey(field)}`;
+    if (!isAnyBacked(field)) {
+        return access;
+    }
+    const base = logicalBase(field.type);
+    const one = (value) => `fromAny<${base}>(${value})`;
+    if (field.list) {
+        const mapped = `${access}${field.optional ? '?' : ''}.map(item => ${one('item')})`;
+        return mapped;
+    }
+    if (field.optional) {
+        return `${access} === undefined ? undefined : ${one(access)}`;
+    }
+    return one(access);
+};
+/** Expression that maps a logical value to the Data Connect row field. */
+const toExpr = (field) => {
+    const access = `value.${fieldKey(field)}`;
+    if (!isAnyBacked(field)) {
+        return access;
+    }
+    if (field.list) {
+        return `${access}${field.optional ? '?' : ''}.map(item => toAny(item))`;
+    }
+    if (field.optional) {
+        return `${access} === undefined ? undefined : toAny(${access})`;
+    }
+    return `toAny(${access})`;
+};
+const renderRowInterface = (model, ir) => {
+    const fields = model.fields
+        .map(field => `  ${fieldKey(field)}${optionalMark(field)}: ${rowFieldType(field, ir)}`)
+        .join('\n');
+    return `export interface ${model.name}Row {\n${fields}\n}`;
+};
+const renderAdapter = (model) => {
+    const adapterName = `${camelCase(model.name)}Adapter`;
+    const fromFields = model.fields.map(field => `      ${fieldKey(field)}: ${fromExpr(field)},`).join('\n');
+    const toFields = model.fields.map(field => `      ${fieldKey(field)}: ${toExpr(field)},`).join('\n');
+    return [
+        `export const ${adapterName} = {`,
+        `  fromDataConnect(row: ${model.name}Row): ${model.name} {`,
+        `    return {`,
+        fromFields,
+        `    }`,
+        `  },`,
+        `  toDataConnect(value: ${model.name}): ${model.name}Row {`,
+        `    return {`,
+        toFields,
+        `    }`,
+        `  },`,
+        `}`,
+    ].join('\n');
+};
+/** Collect the logical type names the adapter references, to import from types.ts. */
+const collectTypeImports = (ir) => {
+    const names = new Set();
+    for (const model of ir.models) {
+        names.add(model.name);
+        for (const field of model.fields) {
+            const ref = field.type;
+            // Relations become scalar FK ids, so the related model type is not imported.
+            if (ref.kind === 'enum' || (ref.kind === 'model' && !isRelation(field))) {
+                names.add(ref.name);
+            }
+            if (ref.kind === 'scalar' && ref.name === 'json') {
+                names.add('Json');
+            }
+        }
+    }
+    return [...names].sort();
+};
+/**
+ * Generates typed adapters that convert between a Data Connect row (json and
+ * embedded-model fields typed as `Any`) and the logical TypeScript type,
+ * restoring the logical type through the runtime `fromAny`/`toAny` helpers.
+ */
+export const createDataConnectAdapterGenerator = () => ({
+    name: 'data-connect-adapter',
+    description: 'Adapters between Data Connect Any rows and logical types',
+    generate(ir, context) {
+        const typeImports = collectTypeImports(ir);
+        const blocks = [...headerBlocks(context)];
+        if (typeImports.length > 0) {
+            blocks.push(`import type { ${typeImports.join(', ')} } from './types.js'`);
+        }
+        blocks.push("import { fromAny, toAny, type Any } from 'firebase-contract/runtime'");
+        for (const model of ir.models) {
+            blocks.push(renderRowInterface(model, ir));
+            blocks.push(renderAdapter(model));
+        }
+        return [{ path: 'data-connect-adapters.ts', content: `${blocks.join('\n\n')}\n` }];
+    },
+});

package/dist/lib/_internal/generators/data-connect/graphql-generator.d.ts

@@ -0,0 +1,15 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates a Data Connect GraphQL schema (`type ... @table`). JSON and embedded
+ * model fields become the `Any` scalar while retaining their logical type as a
+ * comment, matching the "JSON is Any, logical type preserved" rule.
+ */
+export declare const createDataConnectGraphqlGenerator: () => Generator;
+/**
+ * Split variant matching the real Data Connect layout: one file per table at
+ * `schema/<table_name>.gql`, with each enum co-located in the file of the first
+ * model that references it (leftover enums go to `schema/_enums.gql`). The `Any`
+ * scalar is not declared — Data Connect provides it built-in.
+ */
+export declare const createDataConnectGraphqlSplitGenerator: () => Generator;
+//# sourceMappingURL=graphql-generator.d.ts.map

package/dist/lib/_internal/generators/data-connect/graphql-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/data-connect/graphql-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AA8I5E;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,QAAO,SA+BnD,CAAA;AAaF;;;;;GAKG;AACH,eAAO,MAAM,sCAAsC,QAAO,SAmCxD,CAAA"}

package/dist/lib/_internal/generators/data-connect/graphql-generator.js

@@ -0,0 +1,209 @@
+import { headerBlocks } from '../support/header.js';
+import { constantCase, pluralize, snakeCase } from '../support/naming.js';
+import { isRelation } from '../support/relations.js';
+// Data Connect built-in scalars. `json` and embedded model objects are stored
+// as `Any` — the logical type is preserved in a comment and restored by the
+// Data Connect adapter generator.
+const SCALAR_GQL = {
+    string: 'String',
+    int: 'Int',
+    int64: 'Int64',
+    float: 'Float',
+    boolean: 'Boolean',
+    timestamp: 'Timestamp',
+    date: 'Date',
+    json: 'Any',
+    id: 'UUID',
+};
+const gqlOf = (rename, name) => rename.get(name) ?? name;
+const renderRef = (ref, rename) => {
+    switch (ref.kind) {
+        case 'scalar':
+            return { gql: SCALAR_GQL[ref.name] };
+        case 'enum':
+            return { gql: gqlOf(rename, ref.name) };
+        case 'model':
+            return { gql: 'Any', logical: ref.name };
+        default:
+            return { gql: 'Any', logical: ref.name };
+    }
+};
+const defaultExpr = (value) => {
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return `"${value}"`;
+    return `"'${String(value)}'"`;
+};
+/** Derive the Data Connect column dataType for a field, if any. */
+const colDataType = (field) => {
+    if (field.col)
+        return field.col;
+    // Int64 surrogate primary keys map to bigserial.
+    if (field.isId && field.type.kind === 'scalar' && (field.type.name === 'int' || field.type.name === 'int64'))
+        return 'bigserial';
+    return undefined;
+};
+const fieldDirectives = (field) => {
+    const parts = [];
+    const col = colDataType(field);
+    if (col)
+        parts.push(`@col(dataType: "${col}")`);
+    if (field.unique)
+        parts.push('@unique');
+    if (field.default !== undefined)
+        parts.push(`@default(expr: ${defaultExpr(field.default)})`);
+    return parts.length > 0 ? ` ${parts.join(' ')}` : '';
+};
+/** Render a (possibly multi-line) description as comment lines at `indent`. */
+const commentLines = (description, indent) => description ? description.split('\n').map(line => `${indent}# ${line}`.trimEnd()) : [];
+const renderField = (field, rename) => {
+    const nullable = field.optional ? '' : '!';
+    const directives = fieldDirectives(field);
+    // Descriptions render as full comment lines above the field (matching real
+    // Data Connect schema files), so multi-line descriptions survive verbatim.
+    const above = commentLines(field.description, '  ');
+    // Relation: emit a Data Connect relation to the related table (DC auto-creates
+    // the FK column). This is distinct from an embedded model, which becomes `Any`.
+    if (isRelation(field) && field.type.kind === 'model') {
+        const gqlName = gqlOf(rename, field.type.name);
+        const inner = field.list ? `[${gqlName}!]` : gqlName;
+        return [...above, `  ${field.name}: ${inner}${nullable}${directives}`].join('\n');
+    }
+    const { gql, logical } = renderRef(field.type, rename);
+    const inner = field.list ? `[${gql}!]` : gql;
+    const trailing = logical ? ` # logical: ${logical}${field.list ? '[]' : ''}` : '';
+    return [...above, `  ${field.name}: ${inner}${nullable}${directives}${trailing}`].join('\n');
+};
+const tableName = (model) => model.table ?? pluralize(snakeCase(model.name));
+/**
+ * Whether a model is a real table (has a primary key) as opposed to an embedded
+ * value object (jsonb shape, union variant, …) which must NOT get a `@table`.
+ */
+const buildRename = (ir) => {
+    const rename = new Map();
+    for (const m of ir.models)
+        if (m.gqlName)
+            rename.set(m.name, m.gqlName);
+    for (const e of ir.enums)
+        if (e.gqlName)
+            rename.set(e.name, e.gqlName);
+    return rename;
+};
+const isTable = (model) => model.key.length > 0 || model.fields.some(f => f.isId);
+/** The `@table(...)` directive plus any type-level `@unique`/`@index` directives. */
+const tableDirectiveList = (model) => {
+    const keyFields = model.key.length > 0 ? model.key : model.fields.filter(f => f.isId).map(f => f.name);
+    const name = tableName(model);
+    const args = [`name: "${name}"`];
+    if (keyFields.length > 0) {
+        args.push(`key: [${keyFields.map(f => `"${f}"`).join(', ')}]`);
+    }
+    const directives = [`@table(${args.join(', ')})`];
+    for (const index of model.indexes) {
+        const fieldsArg = `fields: [${index.fields.map(f => `"${f}"`).join(', ')}]`;
+        const kind = index.unique ? '@unique' : '@index';
+        const nameArg = index.unique ? 'indexName' : 'name';
+        const idxName = index.name ?? `${name}_${index.fields.join('_')}_${index.unique ? 'uidx' : 'idx'}`;
+        if (index.expand) {
+            // Expanded argument form (one per line), matching hand-written files.
+            directives.push(`${kind}(\n    ${fieldsArg}\n    ${nameArg}: "${idxName}"\n  )`);
+        }
+        else {
+            directives.push(`${kind}(${fieldsArg}, ${nameArg}: "${idxName}")`);
+        }
+    }
+    return directives;
+};
+/** `type X @table(...) {` — or the multi-line per-directive form when requested. */
+const typeHeader = (model, gqlName) => {
+    const directives = tableDirectiveList(model);
+    if (model.directives === 'multi') {
+        return `type ${gqlName}\n  ${directives.join('\n  ')} {`;
+    }
+    return `type ${gqlName} ${directives.join(' ')} {`;
+};
+const commentBanner = (header) => header
+    .split('\n')
+    .map(line => line.replace(/^\/\/ ?/, '# '))
+    .join('\n');
+/**
+ * Generates a Data Connect GraphQL schema (`type ... @table`). JSON and embedded
+ * model fields become the `Any` scalar while retaining their logical type as a
+ * comment, matching the "JSON is Any, logical type preserved" rule.
+ */
+export const createDataConnectGraphqlGenerator = () => ({
+    name: 'data-connect-graphql',
+    description: 'Data Connect GraphQL schema',
+    generate(ir, context) {
+        const blocks = [...headerBlocks(context, commentBanner)];
+        const usesAny = ir.models.some(model => model.fields.some(field => (field.type.kind === 'model' && !isRelation(field)) ||
+            (field.type.kind === 'scalar' && field.type.name === 'json')));
+        if (usesAny) {
+            blocks.push('scalar Any');
+        }
+        const rename = buildRename(ir);
+        for (const irEnum of ir.enums) {
+            blocks.push(renderEnumGql(irEnum, rename));
+        }
+        for (const model of ir.models.filter(isTable)) {
+            const fields = model.fields.map(field => renderField(field, rename)).join('\n');
+            const doc = commentLines(model.description, '');
+            blocks.push([...doc, `${typeHeader(model, gqlOf(rename, model.name))}\n${fields}\n}`].join('\n'));
+            if (model.footer)
+                blocks.push(commentLines(model.footer, '').join('\n'));
+        }
+        return [{ path: 'schema.gql', content: `${blocks.join('\n\n')}\n` }];
+    },
+});
+const renderEnumGql = (irEnum, rename) => {
+    const lines = [...commentLines(irEnum.description, '')];
+    lines.push(`enum ${gqlOf(rename, irEnum.name)} {`);
+    for (const value of irEnum.values) {
+        lines.push(...commentLines(irEnum.valueComments?.[value], '  '));
+        lines.push(`  ${constantCase(value)}`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+};
+/**
+ * Split variant matching the real Data Connect layout: one file per table at
+ * `schema/<table_name>.gql`, with each enum co-located in the file of the first
+ * model that references it (leftover enums go to `schema/_enums.gql`). The `Any`
+ * scalar is not declared — Data Connect provides it built-in.
+ */
+export const createDataConnectGraphqlSplitGenerator = () => ({
+    name: 'data-connect-graphql-split',
+    description: 'Data Connect GraphQL schema, one file per table (schema/<table>.gql)',
+    generate(ir, context) {
+        const banner = headerBlocks(context, commentBanner);
+        const rename = buildRename(ir);
+        const tables = ir.models.filter(isTable);
+        // Assign each enum to the first *table* that references it (embedded value
+        // objects do not get schema files, so they cannot host enums).
+        const enumHome = new Map();
+        for (const model of tables) {
+            for (const field of model.fields) {
+                if (field.type.kind === 'enum' && !enumHome.has(field.type.name)) {
+                    enumHome.set(field.type.name, model.name);
+                }
+            }
+        }
+        const files = [];
+        for (const model of tables) {
+            const blocks = [...banner];
+            for (const irEnum of ir.enums) {
+                if (enumHome.get(irEnum.name) === model.name) {
+                    blocks.push(renderEnumGql(irEnum, rename));
+                }
+            }
+            const fields = model.fields.map(field => renderField(field, rename)).join('\n');
+            const doc = commentLines(model.description, '');
+            blocks.push([...doc, `${typeHeader(model, gqlOf(rename, model.name))}\n${fields}\n}`].join('\n'));
+            if (model.footer)
+                blocks.push(commentLines(model.footer, '').join('\n'));
+            files.push({ path: `schema/${tableName(model)}.gql`, content: `${blocks.join('\n\n')}\n` });
+        }
+        // Enums referenced only by embedded value objects are TS/Zod-level types and
+        // do not exist in the Data Connect schema — they are intentionally skipped.
+        return files;
+    },
+});

package/dist/lib/_internal/generators/data-connect/operations-generator.d.ts

@@ -0,0 +1,18 @@
+import { Generator } from '../generator.js';
+/**
+ * Generates Data Connect operations: `.gql` files with `mutation`/`query`
+ * definitions (over the auto-generated `<table>_insert/update/upsert/delete`
+ * resolvers, with `@auth` directives) plus matching TS `Variables`/`Result`
+ * types. Operations are routed per **connector** — an operation may target
+ * several connectors (`connectors: [app, api]`) and is emitted into each, under
+ * `<connector>/operations.gql`. Operations without a connector go to the root.
+ */
+export declare const createDataConnectOperationsGenerator: () => Generator;
+/**
+ * Split variant matching the real connector layout:
+ * `<connector>/operations/<entity>/{queries,mutations}.gql` (+ one
+ * `operations-types.ts` per connector). Selectable alongside the single-file
+ * `data-connect-operations` generator.
+ */
+export declare const createDataConnectOperationsSplitGenerator: () => Generator;
+//# sourceMappingURL=operations-generator.d.ts.map

package/dist/lib/_internal/generators/data-connect/operations-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-generator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/_internal/generators/data-connect/operations-generator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,SAAS,EAAoB,MAAM,iBAAiB,CAAA;AAkf5E;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC,QAAO,SAsBtD,CAAA;AAMF;;;;;GAKG;AACH,eAAO,MAAM,yCAAyC,QAAO,SAmC3D,CAAA"}