@gridfox/codegen 0.2.0

package/dist/generate.js

@@ -0,0 +1,53 @@
+import { normalizeTables } from './model/normalizeTables.js';
+import { generateTableModule } from './generators/generateTableModule.js';
+import { generateSharedTypes } from './generators/generateSharedTypes.js';
+import { generateRegistryFile } from './generators/generateRegistryFile.js';
+import { generateIndexFile } from './generators/generateIndexFile.js';
+import { generateSdkClientFile } from './generators/generateSdkClientFile.js';
+import { diffGeneratedFiles, writeGeneratedFiles } from './emit/writer.js';
+import { formatTypeScript } from './emit/formatter.js';
+import { sortedKeys } from './utils/sort.js';
+const applyFilters = (tables, config) => {
+    let filtered = [...tables];
+    if (config.includeTables?.length) {
+        const include = new Set(config.includeTables);
+        filtered = filtered.filter((t) => include.has(t.name));
+    }
+    if (config.excludeTables?.length) {
+        const exclude = new Set(config.excludeTables);
+        filtered = filtered.filter((t) => !exclude.has(t.name));
+    }
+    return filtered;
+};
+export const buildGeneratedFiles = async (tables, config) => {
+    const emitClient = config.emitClient === true || config.emitSdkClient === true;
+    const normalized = normalizeTables(applyFilters(tables, config), { multiSelectMode: config.multiSelectMode });
+    const files = {};
+    files['shared.ts'] = generateSharedTypes();
+    for (const table of normalized) {
+        files[`${table.symbolName}.ts`] = generateTableModule(table, config);
+    }
+    if (config.emitRegistry ?? true) {
+        files['tables.ts'] = generateRegistryFile(normalized);
+    }
+    if (emitClient) {
+        files['client.ts'] = generateSdkClientFile(normalized);
+    }
+    files['index.ts'] = generateIndexFile(normalized, config.emitRegistry ?? true, emitClient);
+    if (config.format ?? true) {
+        for (const key of sortedKeys(files)) {
+            files[key] = await formatTypeScript(files[key]);
+        }
+    }
+    return files;
+};
+export const planGeneration = async (tables, config) => {
+    const files = await buildGeneratedFiles(tables, config);
+    const diff = await diffGeneratedFiles(config.output, files);
+    return { files, diff };
+};
+export const generateFromTables = async (tables, config) => {
+    const files = await buildGeneratedFiles(tables, config);
+    await writeGeneratedFiles(config.output, files);
+    return files;
+};

package/dist/generators/generateIndexFile.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedTable } from '../model/internalTypes.js';
+export declare const generateIndexFile: (tables: NormalizedTable[], emitRegistry: boolean, emitClient: boolean) => string;

package/dist/generators/generateIndexFile.js

@@ -0,0 +1,12 @@
+import { sortByTableName } from '../utils/sort.js';
+export const generateIndexFile = (tables, emitRegistry, emitClient) => {
+    const tableExports = sortByTableName(tables)
+        .map((t) => `export * from './${t.symbolName}.js'`)
+        .join('\n');
+    const base = ["export * from './shared.js'", tableExports];
+    if (emitRegistry)
+        base.push("export * from './tables.js'");
+    if (emitClient)
+        base.push("export * from './client.js'");
+    return `${base.filter(Boolean).join('\n')}\n`;
+};

package/dist/generators/generateRegistryFile.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedTable } from '../model/internalTypes.js';
+export declare const generateRegistryFile: (tables: NormalizedTable[]) => string;

package/dist/generators/generateRegistryFile.js

@@ -0,0 +1,7 @@
+import { sortByTableName } from '../utils/sort.js';
+export const generateRegistryFile = (tables) => {
+    const sortedTables = sortByTableName(tables);
+    const imports = sortedTables.map((t) => `import { ${t.symbolName} } from './${t.symbolName}.js'`).join('\n');
+    const entries = sortedTables.map((t) => `  ${t.symbolName}`).join(',\n');
+    return `${imports}\n\nexport const gridfoxTables = [\n${entries}\n] as const\n`;
+};

package/dist/generators/generateSdkClientFile.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedTable } from '../model/internalTypes.js';
+export declare const generateSdkClientFile: (tables: NormalizedTable[]) => string;

package/dist/generators/generateSdkClientFile.js

@@ -0,0 +1,46 @@
+import { camelCase } from 'change-case';
+import { safeIdentifier } from '../naming/reservedWords.js';
+import { sortByTableName } from '../utils/sort.js';
+const namespaceNameFor = (table) => safeIdentifier(camelCase(table.symbolName));
+const namingFor = (table) => ({
+    namespaceName: namespaceNameFor(table),
+    namespaceType: `${table.symbolName}Client`,
+    listMany: `list${table.symbolName}`,
+    getOne: `get${table.typeName}`,
+    createOne: `create${table.typeName}`,
+    updateOne: `update${table.typeName}`,
+    deleteOne: `delete${table.typeName}`
+});
+const moduleImport = (table) => `import { ${table.symbolName}, type ${table.typeName}CreateInput, type ${table.typeName}Record, type ${table.typeName}UpdateInput } from './${table.symbolName}.js'`;
+const namespaceType = (table) => {
+    const names = namingFor(table);
+    return `export interface ${names.namespaceType} {\n  list(): Promise<${table.typeName}Record[]>\n  get(recordId: string): Promise<${table.typeName}Record>\n  create(fields: ${table.typeName}CreateInput): Promise<${table.typeName}Record>\n  update(recordId: string, fields: ${table.typeName}UpdateInput): Promise<${table.typeName}Record>\n  delete(recordId: string): Promise<void>\n  ${names.listMany}(): Promise<${table.typeName}Record[]>\n  ${names.getOne}(recordId: string): Promise<${table.typeName}Record>\n  ${names.createOne}(fields: ${table.typeName}CreateInput): Promise<${table.typeName}Record>\n  ${names.updateOne}(recordId: string, fields: ${table.typeName}UpdateInput): Promise<${table.typeName}Record>\n  ${names.deleteOne}(recordId: string): Promise<void>\n}`;
+};
+const projectClientType = (tables) => `export interface GridfoxProjectClient {\n${sortByTableName(tables)
+    .map((table) => {
+    const names = namingFor(table);
+    return `  ${names.namespaceName}: ${names.namespaceType}`;
+})
+    .join('\n')}\n}`;
+const namespaceFactory = (table) => {
+    const names = namingFor(table);
+    return `const create${table.symbolName}Client = (tableClient: {\n  list(): Promise<${table.typeName}Record[]>\n  get(recordId: string): Promise<${table.typeName}Record>\n  create(fields: ${table.typeName}CreateInput): Promise<${table.typeName}Record>\n  update(recordId: string, fields: ${table.typeName}UpdateInput): Promise<${table.typeName}Record>\n  delete(recordId: string): Promise<void>\n}): ${names.namespaceType} => ({\n  list: () => tableClient.list(),\n  get: (recordId) => tableClient.get(recordId),\n  create: (fields) => tableClient.create(fields),\n  update: (recordId, fields) => tableClient.update(recordId, fields),\n  delete: (recordId) => tableClient.delete(recordId),\n  ${names.listMany}: () => tableClient.list(),\n  ${names.getOne}: (recordId) => tableClient.get(recordId),\n  ${names.createOne}: (fields) => tableClient.create(fields),\n  ${names.updateOne}: (recordId, fields) => tableClient.update(recordId, fields),\n  ${names.deleteOne}: (recordId) => tableClient.delete(recordId)\n})`;
+};
+const projectClientFactory = (tables) => `export const createProjectClient = (options: GridfoxClientOptions): GridfoxProjectClient => {\n  const client = createGridfoxClient(options)\n${sortByTableName(tables)
+    .map((table) => {
+    const names = namingFor(table);
+    return `  const ${names.namespaceName}Table = client.table<${table.typeName}Record, ${table.typeName}CreateInput, ${table.typeName}UpdateInput>(${table.symbolName})\n  const ${names.namespaceName} = create${table.symbolName}Client(${names.namespaceName}Table)`;
+})
+    .join('\n')}\n\n  return {\n${sortByTableName(tables)
+    .map((table) => {
+    const names = namingFor(table);
+    return `    ${names.namespaceName}`;
+})
+    .join(',\n')}\n  }\n}`;
+export const generateSdkClientFile = (tables) => {
+    const sortedTables = sortByTableName(tables);
+    const imports = sortedTables.map(moduleImport).join('\n');
+    const namespaceTypes = sortedTables.map(namespaceType).join('\n\n');
+    const namespaceFactories = sortedTables.map(namespaceFactory).join('\n\n');
+    return `import { createGridfoxClient, type GridfoxClientOptions } from '@gridfox/sdk'\n${imports ? `\n${imports}` : ''}\n\n${namespaceTypes}\n\n${projectClientType(sortedTables)}\n\n${namespaceFactories}\n\n${projectClientFactory(sortedTables)}\n`;
+};

package/dist/generators/generateSharedTypes.d.ts

@@ -0,0 +1 @@
+export declare const generateSharedTypes: () => string;

package/dist/generators/generateSharedTypes.js

@@ -0,0 +1,4 @@
+export const generateSharedTypes = () => `export type GridfoxLinkedValue = unknown
+export type GridfoxFileValue = unknown
+export type GridfoxImageValue = unknown
+`;

package/dist/generators/generateTableModule.d.ts

@@ -0,0 +1,2 @@
+import type { GridfoxCodegenConfig, NormalizedTable } from '../model/internalTypes.js';
+export declare const generateTableModule: (table: NormalizedTable, config: GridfoxCodegenConfig) => string;

package/dist/generators/generateTableModule.js

@@ -0,0 +1,49 @@
+import { pascalCase } from 'change-case';
+import { sortByFieldName } from '../utils/sort.js';
+const listUnionName = (table, field) => `${table.typeName}${pascalCase(field.alias)}`;
+const quoted = (s) => JSON.stringify(s);
+const listUnions = (table, config) => {
+    const multiSelectMode = config.multiSelectMode ?? 'union';
+    const sortedFields = sortByFieldName(table.fields);
+    return sortedFields
+        .filter((f) => (f.kind === 'list' || (f.kind === 'multiSelectList' && multiSelectMode === 'union')) && f.options?.length)
+        .map((f) => `export type ${listUnionName(table, f)} = ${f.options.map(quoted).join(' | ')}`)
+        .join('\n');
+};
+const fieldsObject = (table) => sortByFieldName(table.fields)
+    .map((f) => `    ${f.alias}: ${quoted(f.fieldName)}`)
+    .join(',\n');
+const readFieldEntries = (table) => sortByFieldName(table.fields)
+    .map((f) => `    ${quoted(f.fieldName)}?: ${f.tsReadType}`)
+    .join('\n');
+const writableFields = (table) => sortByFieldName(table.fields.filter((f) => f.writable));
+const writeFieldEntries = (table) => writableFields(table)
+    .map((f) => {
+    const optional = f.required ? '' : '?';
+    return `    ${quoted(f.fieldName)}${optional}: ${f.tsWriteType}`;
+})
+    .join('\n');
+const metadataEntries = (table) => {
+    const sortedFields = sortByFieldName(table.fields);
+    return sortedFields
+        .map((f) => {
+        const rel = f.relatedTableName ? `, relatedTableName: ${quoted(f.relatedTableName)}` : '';
+        const opts = f.options?.length ? `, options: [${f.options.map(quoted).join(', ')}]` : '';
+        return `    ${f.alias}: { name: ${quoted(f.fieldName)}, kind: ${quoted(f.kind)}, required: ${f.required}, unique: ${f.unique}${rel}${opts} }`;
+    })
+        .join(',\n');
+};
+export const generateTableModule = (table, config) => {
+    const writable = writableFields(table);
+    const readonly = sortByFieldName(table.fields.filter((f) => !f.writable));
+    const reverseAliasMap = config.emitReverseAliasMap
+        ? `\nexport const ${table.symbolName}ReverseAliases = {\n${sortByFieldName(table.fields)
+            .map((f) => `  ${quoted(f.fieldName)}: ${quoted(f.alias)}`)
+            .join(',\n')}\n} as const\n`
+        : '';
+    const metadata = config.emitMetadata
+        ? `\nexport const ${table.symbolName}Metadata = {\n  tableName: ${quoted(table.tableName)},\n  singularName: ${quoted(table.singularName)},\n  referenceFieldName: ${quoted(table.referenceFieldName)},\n  fields: {\n${metadataEntries(table)}\n  }\n} as const\n`
+        : '';
+    const unions = listUnions(table, config);
+    return `import type { GridfoxFileValue, GridfoxImageValue, GridfoxLinkedValue } from './shared.js'\n\nexport const ${table.symbolName} = {\n  tableName: ${quoted(table.tableName)},\n  singularName: ${quoted(table.singularName)},\n  referenceFieldName: ${quoted(table.referenceFieldName)},\n  fields: {\n${fieldsObject(table)}\n  }\n} as const\n\n${unions ? `${unions}\n\n` : ''}export interface ${table.typeName}Record {\n  id?: string\n  fields: {\n${readFieldEntries(table)}\n  }\n}\n\nexport type ${table.typeName}CreateInput = {\n${writeFieldEntries(table)}\n}\n\nexport type ${table.typeName}UpdateInput = Partial<${table.typeName}CreateInput>\n\nexport const ${table.symbolName}WritableFields = [${writable.map((f) => quoted(f.fieldName)).join(', ')}] as const\n\nexport const ${table.symbolName}ReadonlyFields = [${readonly.map((f) => quoted(f.fieldName)).join(', ')}] as const\n${metadata}${reverseAliasMap}`;
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { generateFromTables } from './generate.js';
+export { buildGeneratedFiles, planGeneration } from './generate.js';
+export { normalizeTables } from './model/normalizeTables.js';
+export { loadConfig } from './config/loadConfig.js';
+export { readTablesInput } from './input/readInput.js';
+export { readTablesFromApi, buildTablesApiUrl, type GridfoxApiInputConfig } from './input/readApiInput.js';
+export { buildHeuristicPlan } from './validate/crudPlan.js';
+export { buildCrudTestSource } from './validate/renderCrudTest.js';
+export type { GridfoxCodegenConfig, RawField, RawTable, NormalizedField, NormalizedTable } from './model/internalTypes.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { generateFromTables } from './generate.js';
+export { buildGeneratedFiles, planGeneration } from './generate.js';
+export { normalizeTables } from './model/normalizeTables.js';
+export { loadConfig } from './config/loadConfig.js';
+export { readTablesInput } from './input/readInput.js';
+export { readTablesFromApi, buildTablesApiUrl } from './input/readApiInput.js';
+export { buildHeuristicPlan } from './validate/crudPlan.js';
+export { buildCrudTestSource } from './validate/renderCrudTest.js';

package/dist/input/apiTransport.d.ts

@@ -0,0 +1,6 @@
+export interface ApiTransport {
+    getJson(url: string, headers: Record<string, string>, timeoutMs: number): Promise<unknown>;
+}
+export declare class FetchApiTransport implements ApiTransport {
+    getJson(url: string, headers: Record<string, string>, timeoutMs: number): Promise<unknown>;
+}

package/dist/input/apiTransport.js

@@ -0,0 +1,21 @@
+export class FetchApiTransport {
+    async getJson(url, headers, timeoutMs) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers,
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`HTTP ${response.status}: ${body.slice(0, 300)}`);
+            }
+            return (await response.json());
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/input/parseTablesPayload.d.ts

@@ -0,0 +1,21 @@
+export declare const parseTablesPayload: (parsed: unknown, sourceLabel?: string) => {
+    name: string;
+    singularName: string;
+    referenceFieldName: string;
+    fields: {
+        name: string;
+        type: "number" | "text" | "email" | "textArea" | "richText" | "user" | "money" | "percentage" | "formula" | "autoCounter" | "checkbox" | "date" | "dateTime" | "list" | "multiSelectList" | "parent" | "child" | "manyToMany" | "file" | "image";
+        isRequired?: boolean | undefined;
+        isUnique?: boolean | undefined;
+        properties?: {
+            [x: string]: unknown;
+            items?: {
+                value: string;
+                color?: string | null | undefined;
+            }[] | undefined;
+            relatedTableName?: string | undefined;
+            formulaType?: string | undefined;
+            currency?: string | undefined;
+        } | undefined;
+    }[];
+}[];

package/dist/input/parseTablesPayload.js

@@ -0,0 +1,71 @@
+import { GRIDFOX_FIELD_TYPES, GridfoxTablesSchema } from '../model/zodSchemas.js';
+const knownFieldTypes = new Set(GRIDFOX_FIELD_TYPES);
+const tableNameAt = (parsed, tableIndex) => {
+    if (!Array.isArray(parsed))
+        return `#${tableIndex}`;
+    const value = parsed[tableIndex];
+    if (value && typeof value === 'object' && typeof value.name === 'string') {
+        return value.name;
+    }
+    return `#${tableIndex}`;
+};
+const fieldNameAt = (parsed, tableIndex, fieldIndex) => {
+    if (!Array.isArray(parsed))
+        return `#${fieldIndex}`;
+    const table = parsed[tableIndex];
+    if (!table || typeof table !== 'object' || !Array.isArray(table.fields)) {
+        return `#${fieldIndex}`;
+    }
+    const field = table.fields[fieldIndex];
+    if (field && typeof field === 'object' && typeof field.name === 'string') {
+        const name = field.name.trim();
+        return name || `#${fieldIndex}`;
+    }
+    return `#${fieldIndex}`;
+};
+const findUnknownFieldTypeErrors = (parsed) => {
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    const errors = [];
+    for (let tableIndex = 0; tableIndex < parsed.length; tableIndex += 1) {
+        const table = parsed[tableIndex];
+        if (!table || typeof table !== 'object' || !Array.isArray(table.fields)) {
+            continue;
+        }
+        for (let fieldIndex = 0; fieldIndex < table.fields.length; fieldIndex += 1) {
+            const field = table.fields[fieldIndex];
+            if (!field || typeof field !== 'object') {
+                continue;
+            }
+            if (typeof field.type === 'string' && !knownFieldTypes.has(field.type)) {
+                const tableName = tableNameAt(parsed, tableIndex);
+                const fieldName = fieldNameAt(parsed, tableIndex, fieldIndex);
+                errors.push(`Unknown field type "${field.type}" at table "${tableName}", field "${fieldName}"`);
+            }
+        }
+    }
+    return errors;
+};
+const formatIssue = (parsed, issue) => {
+    const [tableIndex, segment, fieldIndex] = issue.path;
+    if (typeof tableIndex === 'number' && segment === 'fields' && typeof fieldIndex === 'number') {
+        return `Table "${tableNameAt(parsed, tableIndex)}", field "${fieldNameAt(parsed, tableIndex, fieldIndex)}": ${issue.message}`;
+    }
+    if (typeof tableIndex === 'number') {
+        return `Table "${tableNameAt(parsed, tableIndex)}": ${issue.message}`;
+    }
+    return issue.message;
+};
+export const parseTablesPayload = (parsed, sourceLabel = 'tables input') => {
+    const unknownTypeErrors = findUnknownFieldTypeErrors(parsed);
+    if (unknownTypeErrors.length > 0) {
+        throw new Error([`Invalid ${sourceLabel}:`, ...unknownTypeErrors].join('\n'));
+    }
+    const result = GridfoxTablesSchema.safeParse(parsed);
+    if (!result.success) {
+        const details = result.error.issues.map((issue) => `- ${formatIssue(parsed, issue)}`);
+        throw new Error([`Invalid ${sourceLabel}:`, ...details].join('\n'));
+    }
+    return result.data;
+};

package/dist/input/readApiInput.d.ts

@@ -0,0 +1,9 @@
+import type { RawTable } from '../model/internalTypes.js';
+import type { ApiTransport } from './apiTransport.js';
+export interface GridfoxApiInputConfig {
+    apiKey: string;
+    apiBaseUrl?: string;
+    apiTimeoutMs?: number;
+}
+export declare const buildTablesApiUrl: (config: GridfoxApiInputConfig) => string;
+export declare const readTablesFromApi: (config: GridfoxApiInputConfig, transport?: ApiTransport) => Promise<RawTable[]>;

package/dist/input/readApiInput.js

@@ -0,0 +1,17 @@
+import { FetchApiTransport } from './apiTransport.js';
+import { parseTablesPayload } from './parseTablesPayload.js';
+const defaultBaseUrl = 'https://api.gridfox.com';
+const defaultTimeoutMs = 10000;
+export const buildTablesApiUrl = (config) => {
+    const base = config.apiBaseUrl ?? defaultBaseUrl;
+    return new URL('/tables', base).toString();
+};
+export const readTablesFromApi = async (config, transport = new FetchApiTransport()) => {
+    const url = buildTablesApiUrl(config);
+    const timeoutMs = config.apiTimeoutMs ?? defaultTimeoutMs;
+    const payload = await transport.getJson(url, {
+        accept: 'application/json',
+        'gridfox-api-key': config.apiKey
+    }, timeoutMs);
+    return parseTablesPayload(payload, `tables API response from "${url}"`);
+};

package/dist/input/readInput.d.ts

@@ -0,0 +1,21 @@
+export declare const readTablesInput: (inputPath: string) => Promise<{
+    name: string;
+    singularName: string;
+    referenceFieldName: string;
+    fields: {
+        name: string;
+        type: "number" | "text" | "email" | "textArea" | "richText" | "user" | "money" | "percentage" | "formula" | "autoCounter" | "checkbox" | "date" | "dateTime" | "list" | "multiSelectList" | "parent" | "child" | "manyToMany" | "file" | "image";
+        isRequired?: boolean | undefined;
+        isUnique?: boolean | undefined;
+        properties?: {
+            [x: string]: unknown;
+            items?: {
+                value: string;
+                color?: string | null | undefined;
+            }[] | undefined;
+            relatedTableName?: string | undefined;
+            formulaType?: string | undefined;
+            currency?: string | undefined;
+        } | undefined;
+    }[];
+}[]>;

package/dist/input/readInput.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+import { parseTablesPayload } from './parseTablesPayload.js';
+export const readTablesInput = async (inputPath) => {
+    const raw = await readFile(inputPath, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'unknown parse error';
+        throw new Error(`Invalid JSON in "${inputPath}": ${message}`);
+    }
+    return parseTablesPayload(parsed, `tables input from "${inputPath}"`);
+};

package/dist/model/internalTypes.d.ts

@@ -0,0 +1,60 @@
+export type GridfoxFieldType = 'text' | 'email' | 'textArea' | 'richText' | 'user' | 'number' | 'money' | 'percentage' | 'formula' | 'autoCounter' | 'checkbox' | 'date' | 'dateTime' | 'list' | 'multiSelectList' | 'parent' | 'child' | 'manyToMany' | 'file' | 'image';
+export interface RawField {
+    name: string;
+    type: GridfoxFieldType;
+    isRequired?: boolean;
+    isUnique?: boolean;
+    properties?: {
+        items?: Array<{
+            value: string;
+            color?: string | null;
+        }>;
+        relatedTableName?: string;
+        formulaType?: string;
+        currency?: string;
+        [k: string]: unknown;
+    };
+}
+export interface RawTable {
+    name: string;
+    singularName: string;
+    referenceFieldName: string;
+    fields: RawField[];
+}
+export interface NormalizedField {
+    fieldName: string;
+    alias: string;
+    kind: GridfoxFieldType;
+    tsReadType: string;
+    tsWriteType?: string;
+    writable: boolean;
+    required: boolean;
+    unique: boolean;
+    relatedTableName?: string;
+    options?: string[];
+}
+export interface NormalizedTable {
+    tableName: string;
+    singularName: string;
+    symbolName: string;
+    typeName: string;
+    referenceFieldName: string;
+    fields: NormalizedField[];
+}
+export interface GridfoxCodegenConfig {
+    input?: string;
+    output: string;
+    includeTables?: string[];
+    excludeTables?: string[];
+    apiKey?: string;
+    apiBaseUrl?: string;
+    apiTimeoutMs?: number;
+    multiSelectMode?: 'union' | 'stringArray';
+    emitClient?: boolean;
+    emitRegistry?: boolean;
+    /** @deprecated use emitClient */
+    emitSdkClient?: boolean;
+    emitReverseAliasMap?: boolean;
+    emitMetadata?: boolean;
+    format?: boolean;
+}

package/dist/model/internalTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/model/normalizeTables.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizedTable, RawTable } from './internalTypes.js';
+interface NormalizeOptions {
+    multiSelectMode?: 'union' | 'stringArray';
+}
+export declare const normalizeTables: (tables: RawTable[], options?: NormalizeOptions) => NormalizedTable[];
+export {};

package/dist/model/normalizeTables.js

@@ -0,0 +1,68 @@
+import { pascalCase } from 'change-case';
+import { normalizeFieldAlias } from '../naming/fieldAliases.js';
+import { ensureIdentifier } from '../naming/identifiers.js';
+import { normalizeTableSymbol } from '../naming/tableNames.js';
+import { mapReadType, mapWriteType } from '../typing/mapFieldType.js';
+import { isWritableFieldType } from '../typing/writability.js';
+import { sortByName } from '../utils/sort.js';
+const normalizeField = (field, options) => {
+    const writable = isWritableFieldType(field.type);
+    const listOptions = field.properties?.items?.map((item) => item.value);
+    return {
+        fieldName: field.name,
+        alias: normalizeFieldAlias(field.name),
+        kind: field.type,
+        tsReadType: mapReadType(field, { multiSelectMode: options.multiSelectMode }),
+        tsWriteType: writable ? mapWriteType(field, { multiSelectMode: options.multiSelectMode }) : undefined,
+        writable,
+        required: Boolean(field.isRequired),
+        unique: Boolean(field.isUnique),
+        relatedTableName: field.properties?.relatedTableName,
+        options: listOptions
+    };
+};
+const ensureNoCollisions = (tableName, fields) => {
+    const seen = new Map();
+    for (const field of fields) {
+        const prev = seen.get(field.alias);
+        if (prev) {
+            throw new Error(`Alias collision in table "${tableName}": fields "${prev}" and "${field.fieldName}" both normalize to "${field.alias}"`);
+        }
+        seen.set(field.alias, field.fieldName);
+    }
+};
+const ensureNoTableIdentifierCollisions = (tables) => {
+    const symbols = new Map();
+    const types = new Map();
+    for (const table of tables) {
+        const prevSymbol = symbols.get(table.symbolName);
+        if (prevSymbol) {
+            throw new Error(`Table symbol collision: tables "${prevSymbol}" and "${table.tableName}" both normalize to "${table.symbolName}"`);
+        }
+        symbols.set(table.symbolName, table.tableName);
+        const prevType = types.get(table.typeName);
+        if (prevType) {
+            throw new Error(`Type name collision: tables "${prevType}" and "${table.tableName}" both normalize to "${table.typeName}"`);
+        }
+        types.set(table.typeName, table.tableName);
+    }
+};
+export const normalizeTables = (tables, options = {}) => {
+    const normalized = sortByName(tables)
+        .map((table) => {
+        const fields = sortByName(table.fields).map((field) => normalizeField(field, options));
+        ensureNoCollisions(table.name, fields);
+        const symbolName = normalizeTableSymbol(table.name);
+        const typeName = ensureIdentifier(pascalCase(table.singularName), 'Type');
+        return {
+            tableName: table.name,
+            singularName: table.singularName,
+            symbolName,
+            typeName,
+            referenceFieldName: table.referenceFieldName,
+            fields
+        };
+    });
+    ensureNoTableIdentifierCollisions(normalized);
+    return normalized;
+};