@gridfox/codegen 0.2.0

package/dist/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/main.js

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+import path from 'node:path';
+// If users pass a TypeScript config file directly (e.g. --config foo.ts), Node
+// can't import it by default. Ensure we run under tsx so the config can be loaded.
+// We use an env var to avoid infinite respawn loops.
+const shouldRespawnWithTsx = () => {
+    if (process.env.GRIDFOX_CODEGEN_TSX === '1')
+        return false;
+    const argv = process.argv.slice(2);
+    const configFlagIndex = argv.findIndex((arg) => arg === '--config');
+    if (configFlagIndex === -1)
+        return false;
+    const configPath = argv[configFlagIndex + 1];
+    if (typeof configPath !== 'string')
+        return false;
+    return !!configPath.match(/\.(?:mts|cts|ts)$/i);
+};
+if (shouldRespawnWithTsx()) {
+    const { spawn } = await import('node:child_process');
+    const args = ['--import', 'tsx', ...process.argv.slice(1)];
+    const child = spawn(process.execPath, args, {
+        stdio: 'inherit',
+        env: { ...process.env, GRIDFOX_CODEGEN_TSX: '1' }
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+        child.on('exit', (code) => resolve(code ?? 0));
+        child.on('error', (err) => reject(err));
+    });
+    process.exit(exitCode);
+}
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { cac } from 'cac';
+import { execa } from 'execa';
+import { loadConfig } from '../config/loadConfig.js';
+import { readTablesInput } from '../input/readInput.js';
+import { readTablesFromApi } from '../input/readApiInput.js';
+import { generateFromTables, planGeneration } from '../generate.js';
+import { sortedKeys } from '../utils/sort.js';
+import { buildHeuristicPlan } from '../validate/crudPlan.js';
+import { buildCrudTestSource } from '../validate/renderCrudTest.js';
+import { canPrompt, promptConfirm, promptSecret, promptText } from './prompt.js';
+const cli = cac('@gridfox/codegen');
+const summarize = (statuses) => statuses.reduce((acc, status) => {
+    acc[status] += 1;
+    return acc;
+}, { new: 0, changed: 0, unchanged: 0 });
+const printError = (error) => {
+    if (error instanceof Error) {
+        const [headline, ...details] = error.message.split('\n');
+        console.error(`Error: ${headline}`);
+        if (details.length > 0) {
+            console.error(details.join('\n'));
+        }
+    }
+    else {
+        console.error('Error: unknown failure');
+    }
+};
+const parsePositiveNumber = (value, label) => {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid ${label} value. Expected a positive number.`);
+    }
+    return parsed;
+};
+const compileRegex = (pattern, flagName) => {
+    if (!pattern) {
+        return undefined;
+    }
+    try {
+        return new RegExp(pattern);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'invalid regex';
+        throw new Error(`Invalid ${flagName} regex: ${message}`);
+    }
+};
+const resolveApiKey = async (apiKeyFlag) => {
+    if (apiKeyFlag && apiKeyFlag.trim().length > 0) {
+        return apiKeyFlag.trim();
+    }
+    const fromEnv = process.env.GRIDFOX_API_KEY;
+    if (fromEnv && fromEnv.trim().length > 0) {
+        return fromEnv.trim();
+    }
+    const prompted = await promptSecret('Gridfox API key: ');
+    if (!prompted) {
+        throw new Error('Missing API key. Provide --api-key, set GRIDFOX_API_KEY, or enter a key at the prompt.');
+    }
+    return prompted;
+};
+const buildTempTsConfig = (workspaceDir) => JSON.stringify({
+    compilerOptions: {
+        target: 'ES2022',
+        module: 'NodeNext',
+        moduleResolution: 'NodeNext',
+        strict: true,
+        outDir: path.join(workspaceDir, '.compiled'),
+        rootDir: workspaceDir,
+        skipLibCheck: true,
+        lib: ['ES2022', 'DOM']
+    },
+    include: [path.join(workspaceDir, 'generated', '**/*.ts'), path.join(workspaceDir, 'src', '**/*.ts')]
+}, null, 2);
+cli
+    .command('generate', 'Generate TypeScript artifacts from Gridfox tables JSON')
+    .option('--input <path>', 'Path to tables JSON file')
+    .option('--output <path>', 'Output directory for generated files')
+    .option('--config <path>', 'Path to config file (.json, .ts, .mts, .cts, .mjs, .cjs)')
+    .option('--api-key <key>', 'Gridfox API key (or GRIDFOX_API_KEY)')
+    .option('--api-base-url <url>', 'Override Gridfox API base URL (or GRIDFOX_API_BASE_URL)')
+    .option('--api-timeout-ms <ms>', 'HTTP timeout for Gridfox API requests (or GRIDFOX_API_TIMEOUT_MS)')
+    .option('--multi-select-mode <mode>', 'Set multiSelect typing mode: union | stringArray')
+    .option('--client', 'Generate client.ts SDK wrapper (imports @gridfox/sdk)')
+    .option('--emit-sdk-client', 'Deprecated alias for --client')
+    .option('--emit-registry', 'Generate tables.ts registry')
+    .option('--emit-reverse-alias-map', 'Generate reverse alias map constants')
+    .option('--dry-run', 'Show planned file writes without writing files')
+    .option('--check', 'Exit non-zero when generated output is outdated')
+    .option('--no-format', 'Disable prettier formatting')
+    .action(async (flags) => {
+    try {
+        const interactive = canPrompt();
+        let outputFlag = typeof flags.output === 'string' ? flags.output : undefined;
+        let inputFlag = typeof flags.input === 'string' ? flags.input : undefined;
+        let apiKeyFlag = typeof flags.apiKey === 'string' ? flags.apiKey : undefined;
+        let clientFlag = flags.client ?? flags.emitSdkClient;
+        if (interactive && !flags.config) {
+            if (!outputFlag) {
+                outputFlag = await promptText('Output directory: ');
+            }
+            if (!inputFlag && !apiKeyFlag) {
+                const useApi = await promptConfirm('Use Gridfox API as input source?', Boolean(process.env.GRIDFOX_API_KEY?.trim()));
+                if (useApi) {
+                    if (!process.env.GRIDFOX_API_KEY?.trim()) {
+                        apiKeyFlag = await resolveApiKey(undefined);
+                    }
+                }
+                else {
+                    inputFlag = await promptText('Path to tables JSON input file: ');
+                }
+            }
+            if (clientFlag === undefined) {
+                clientFlag = await promptConfirm('Emit typed SDK client wrapper (client.ts)?', false);
+            }
+        }
+        const config = await loadConfig(flags.config, {
+            input: inputFlag,
+            output: outputFlag,
+            apiKey: apiKeyFlag,
+            apiBaseUrl: flags.apiBaseUrl,
+            apiTimeoutMs: flags.apiTimeoutMs !== undefined ? Number(flags.apiTimeoutMs) : undefined,
+            multiSelectMode: flags.multiSelectMode,
+            emitClient: clientFlag,
+            emitRegistry: flags.emitRegistry,
+            emitReverseAliasMap: flags.emitReverseAliasMap,
+            format: flags.format
+        });
+        const hasApiConfig = Boolean(config.apiKey);
+        let tables;
+        if (config.input) {
+            tables = await readTablesInput(config.input);
+        }
+        else if (hasApiConfig) {
+            tables = await readTablesFromApi({
+                apiKey: config.apiKey,
+                apiBaseUrl: config.apiBaseUrl,
+                apiTimeoutMs: config.apiTimeoutMs
+            });
+        }
+        else {
+            throw new Error('Missing input source. Provide --input/config.input or --api-key (or GRIDFOX_API_KEY)');
+        }
+        if (flags.dryRun || flags.check) {
+            const { diff } = await planGeneration(tables, config);
+            const totals = summarize(diff.map((entry) => entry.status));
+            const statusesByPath = Object.fromEntries(diff.map((entry) => [entry.path, entry.status]));
+            console.log(`Planned files: ${diff.length} (new: ${totals.new}, changed: ${totals.changed}, unchanged: ${totals.unchanged})`);
+            for (const outputPath of sortedKeys(statusesByPath)) {
+                console.log(`[${statusesByPath[outputPath]}] ${outputPath}`);
+            }
+            if (flags.check && (totals.new > 0 || totals.changed > 0)) {
+                console.error('Error: generated files are out of date');
+                process.exitCode = 1;
+            }
+            return;
+        }
+        await generateFromTables(tables, config);
+    }
+    catch (error) {
+        printError(error);
+        process.exitCode = 1;
+    }
+});
+cli
+    .command('validate', 'Run live CRUD validation against a Gridfox project')
+    .option('--api-key <key>', 'Gridfox API key (or GRIDFOX_API_KEY; prompts if missing)')
+    .option('--key <key>', 'Alias for --api-key')
+    .option('--api-base-url <url>', 'Override Gridfox API base URL (or GRIDFOX_API_BASE_URL)')
+    .option('--api-timeout-ms <ms>', 'HTTP timeout for Gridfox API requests (or GRIDFOX_API_TIMEOUT_MS)')
+    .option('--table <name>', 'Pin to a specific table name')
+    .option('--allow-table-regex <pattern>', 'Allow only table names matching regex when auto-selecting')
+    .option('--deny-table-regex <pattern>', 'Deny table names matching regex when auto-selecting')
+    .option('--plan-only', 'Compute and print plan without writing any records')
+    .option('--yes-live-writes', 'Acknowledge that validate will create/update/delete real records')
+    .option('--json', 'Emit machine-readable JSON output')
+    .option('--keep-temp', 'Keep temp workspace after run')
+    .option('--verbose', 'Print detailed progress information')
+    .action(async (flags) => {
+    const jsonOutput = Boolean(flags.json);
+    const interactive = canPrompt() && !jsonOutput;
+    const log = (...values) => {
+        if (!flags.verbose) {
+            return;
+        }
+        const line = `[validate] ${values.map((value) => String(value)).join(' ')}`;
+        if (jsonOutput) {
+            console.error(line);
+        }
+        else {
+            console.log(line);
+        }
+    };
+    const emitJson = (payload) => {
+        console.log(JSON.stringify(payload, null, 2));
+    };
+    const defaultDenyRegex = /audit|log|event|history/i;
+    let workspaceDir = null;
+    try {
+        let tableName = typeof flags.table === 'string' ? flags.table : process.env.GRIDFOX_REAL_TEST_TABLE;
+        const allowRegex = compileRegex(flags.allowTableRegex, '--allow-table-regex');
+        const denyRegex = compileRegex(flags.denyTableRegex, '--deny-table-regex');
+        let planOnly = Boolean(flags.planOnly);
+        let yesLiveWrites = Boolean(flags.yesLiveWrites);
+        if (!tableName && !allowRegex && !interactive) {
+            throw new Error('Validate requires either --table or --allow-table-regex for auto table selection');
+        }
+        if (!planOnly && !yesLiveWrites && !interactive) {
+            throw new Error('Live validation writes data. Re-run with --yes-live-writes or use --plan-only');
+        }
+        const apiKey = await resolveApiKey(flags.apiKey ?? flags.key);
+        const apiBaseUrl = flags.apiBaseUrl ?? process.env.GRIDFOX_API_BASE_URL;
+        const apiTimeoutMs = parsePositiveNumber(flags.apiTimeoutMs ?? process.env.GRIDFOX_API_TIMEOUT_MS, 'API timeout');
+        log('fetching tables from Gridfox API');
+        const tables = await readTablesFromApi({
+            apiKey,
+            apiBaseUrl,
+            apiTimeoutMs
+        });
+        if (!tableName && !allowRegex) {
+            if (!interactive) {
+                throw new Error('Validate requires either --table or --allow-table-regex for auto table selection');
+            }
+            const availableTables = tables.map((table) => table.name).sort((left, right) => left.localeCompare(right));
+            if (availableTables.length > 0) {
+                console.log(`Available tables: ${availableTables.join(', ')}`);
+            }
+            tableName = await promptText('Table name: ');
+            if (!tableName) {
+                throw new Error('Missing table name. Provide --table/--allow-table-regex or enter a table name at the prompt.');
+            }
+        }
+        if (!planOnly && !yesLiveWrites && interactive) {
+            planOnly = await promptConfirm('Run in plan-only mode (no live writes)?', true);
+            if (!planOnly) {
+                yesLiveWrites = await promptConfirm('This will create/update/delete real records in your project. Continue?', false);
+            }
+        }
+        if (!planOnly && !yesLiveWrites) {
+            throw new Error('Live validation writes data. Re-run with --yes-live-writes or use --plan-only');
+        }
+        const candidateTables = tableName
+            ? tables
+            : tables
+                .filter((table) => allowRegex.test(table.name))
+                .filter((table) => !(denyRegex ?? defaultDenyRegex).test(table.name));
+        if (candidateTables.length === 0) {
+            const allowText = allowRegex ? allowRegex.toString() : '<none>';
+            const denyText = (denyRegex ?? defaultDenyRegex).toString();
+            throw new Error(`No tables remain after applying filters (allow: ${allowText}, deny: ${denyText})`);
+        }
+        const plan = buildHeuristicPlan(candidateTables, {
+            tableName
+        });
+        if (!jsonOutput) {
+            console.log(`[validate] Selected table: ${plan.tableName}`);
+            console.log('[validate] CRUD plan:');
+            console.log(JSON.stringify(plan, null, 2));
+        }
+        if (planOnly) {
+            if (jsonOutput) {
+                emitJson({
+                    command: 'validate',
+                    status: 'planned',
+                    planOnly: true,
+                    table: plan.tableName,
+                    plan
+                });
+            }
+            return;
+        }
+        workspaceDir = await mkdtemp(path.join(tmpdir(), 'gridfox-validate-'));
+        const generatedDir = path.join(workspaceDir, 'generated');
+        const srcDir = path.join(workspaceDir, 'src');
+        const compiledDir = path.join(workspaceDir, '.compiled');
+        const tsconfigPath = path.join(workspaceDir, 'tsconfig.json');
+        const testFilePath = path.join(srcDir, 'realCrudTest.ts');
+        log('temp workspace:', workspaceDir);
+        await mkdir(generatedDir, { recursive: true });
+        await mkdir(srcDir, { recursive: true });
+        log('generating TypeScript schema files');
+        await generateFromTables(candidateTables, {
+            output: generatedDir,
+            emitRegistry: true,
+            emitMetadata: true,
+            format: true
+        });
+        log('writing temp validation test source');
+        await writeFile(tsconfigPath, buildTempTsConfig(workspaceDir), 'utf8');
+        await writeFile(testFilePath, buildCrudTestSource(plan), 'utf8');
+        log('typechecking generated + validation test files');
+        await execa('npx', ['tsc', '-p', tsconfigPath], {
+            cwd: process.cwd(),
+            stdio: 'inherit'
+        });
+        log('running live CRUD validation');
+        await execa('node', [path.join(compiledDir, 'src', 'realCrudTest.js')], {
+            cwd: process.cwd(),
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                GRIDFOX_API_KEY: apiKey,
+                GRIDFOX_API_BASE_URL: apiBaseUrl
+            }
+        });
+        if (jsonOutput) {
+            emitJson({
+                command: 'validate',
+                status: 'passed',
+                table: plan.tableName,
+                plan
+            });
+        }
+        else {
+            console.log(`[validate] Passed for table "${plan.tableName}"`);
+        }
+    }
+    catch (error) {
+        if (jsonOutput) {
+            const message = error instanceof Error ? error.message : 'unknown failure';
+            emitJson({
+                command: 'validate',
+                status: 'failed',
+                error: message
+            });
+        }
+        else {
+            printError(error);
+        }
+        process.exitCode = 1;
+    }
+    finally {
+        if (workspaceDir) {
+            if (flags.keepTemp) {
+                const message = `Kept temp workspace: ${workspaceDir}`;
+                if (jsonOutput) {
+                    console.error(`[validate] ${message}`);
+                }
+                else {
+                    console.log(message);
+                }
+            }
+            else {
+                await rm(workspaceDir, { recursive: true, force: true });
+                log('cleaned temp workspace');
+            }
+        }
+    }
+});
+cli.help();
+if (process.argv.slice(2).length === 0) {
+    if (canPrompt()) {
+        process.argv.push('generate');
+    }
+    else {
+        cli.outputHelp();
+        process.exitCode = 1;
+    }
+}
+cli.parse();

package/dist/cli/prompt.d.ts

@@ -0,0 +1,4 @@
+export declare const canPrompt: () => boolean;
+export declare const promptText: (question: string) => Promise<string>;
+export declare const promptConfirm: (question: string, defaultValue?: boolean) => Promise<boolean>;
+export declare const promptSecret: (question: string) => Promise<string>;

package/dist/cli/prompt.js

@@ -0,0 +1,89 @@
+import readline from 'node:readline';
+export const canPrompt = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const ensurePromptSupported = (message) => {
+    if (!canPrompt()) {
+        throw new Error(message);
+    }
+};
+export const promptText = async (question) => {
+    ensurePromptSupported('Cannot prompt in non-interactive mode.');
+    return new Promise((resolve, reject) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true
+        });
+        const onSigint = () => {
+            rl.close();
+            reject(new Error('Prompt cancelled'));
+        };
+        rl.once('SIGINT', onSigint);
+        rl.question(question, (answer) => {
+            rl.off('SIGINT', onSigint);
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+};
+export const promptConfirm = async (question, defaultValue = false) => {
+    const suffix = defaultValue ? ' [Y/n]: ' : ' [y/N]: ';
+    while (true) {
+        const answer = (await promptText(`${question}${suffix}`)).toLowerCase();
+        if (!answer) {
+            return defaultValue;
+        }
+        if (answer === 'y' || answer === 'yes') {
+            return true;
+        }
+        if (answer === 'n' || answer === 'no') {
+            return false;
+        }
+        console.log('Please answer yes or no.');
+    }
+};
+export const promptSecret = async (question) => {
+    ensurePromptSupported('Cannot prompt for API key in non-interactive mode. Pass --api-key or set GRIDFOX_API_KEY.');
+    return new Promise((resolve, reject) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true
+        });
+        const originalWrite = rl._writeToOutput?.bind(rl);
+        rl.stdoutMuted = false;
+        rl._writeToOutput = (value) => {
+            if (!rl.stdoutMuted) {
+                if (originalWrite) {
+                    originalWrite(value);
+                }
+                else {
+                    process.stdout.write(value);
+                }
+                return;
+            }
+            if (value.endsWith('\n')) {
+                process.stdout.write(value);
+            }
+            else if (value.trim().length > 0) {
+                process.stdout.write('*');
+            }
+            else {
+                process.stdout.write(value);
+            }
+        };
+        const onSigint = () => {
+            rl.close();
+            reject(new Error('Prompt cancelled'));
+        };
+        rl.once('SIGINT', onSigint);
+        rl.question(question, (answer) => {
+            rl.off('SIGINT', onSigint);
+            rl.close();
+            process.stdout.write('\n');
+            resolve(answer.trim());
+        });
+        setImmediate(() => {
+            rl.stdoutMuted = true;
+        });
+    });
+};

package/dist/config/loadConfig.d.ts

@@ -0,0 +1,2 @@
+import { type Config } from './schema.js';
+export declare const loadConfig: (configPath?: string, overrides?: Partial<Config>) => Promise<Config>;

package/dist/config/loadConfig.js

@@ -0,0 +1,49 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ConfigSchema } from './schema.js';
+const defaults = {
+    input: undefined,
+    includeTables: undefined,
+    excludeTables: undefined,
+    apiKey: undefined,
+    apiBaseUrl: undefined,
+    apiTimeoutMs: undefined,
+    multiSelectMode: 'union',
+    emitClient: false,
+    emitRegistry: true,
+    emitSdkClient: undefined,
+    emitReverseAliasMap: false,
+    emitMetadata: true,
+    format: true
+};
+const readEnvConfig = () => {
+    const apiTimeoutMs = process.env.GRIDFOX_API_TIMEOUT_MS;
+    return {
+        apiKey: process.env.GRIDFOX_API_KEY,
+        apiBaseUrl: process.env.GRIDFOX_API_BASE_URL,
+        apiTimeoutMs: apiTimeoutMs !== undefined ? Number(apiTimeoutMs) : undefined
+    };
+};
+export const loadConfig = async (configPath, overrides = {}) => {
+    let configFromFile = {};
+    if (configPath) {
+        const extension = path.extname(configPath);
+        if (extension === '.json') {
+            const raw = await readFile(configPath, 'utf8');
+            configFromFile = JSON.parse(raw);
+        }
+        else {
+            const imported = await import(pathToFileURL(path.resolve(configPath)).href);
+            configFromFile = (imported.default ?? imported);
+        }
+    }
+    const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== undefined));
+    const merged = {
+        ...defaults,
+        ...readEnvConfig(),
+        ...configFromFile,
+        ...definedOverrides
+    };
+    return ConfigSchema.parse(merged);
+};

package/dist/config/schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const ConfigSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodString>;
+    output: z.ZodString;
+    includeTables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeTables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    apiBaseUrl: z.ZodOptional<z.ZodString>;
+    apiTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    multiSelectMode: z.ZodDefault<z.ZodEnum<{
+        union: "union";
+        stringArray: "stringArray";
+    }>>;
+    emitClient: z.ZodDefault<z.ZodBoolean>;
+    emitRegistry: z.ZodDefault<z.ZodBoolean>;
+    emitSdkClient: z.ZodOptional<z.ZodBoolean>;
+    emitReverseAliasMap: z.ZodDefault<z.ZodBoolean>;
+    emitMetadata: z.ZodDefault<z.ZodBoolean>;
+    format: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof ConfigSchema>;

package/dist/config/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const ConfigSchema = z.object({
+    input: z.string().optional(),
+    output: z.string(),
+    includeTables: z.array(z.string()).optional(),
+    excludeTables: z.array(z.string()).optional(),
+    apiKey: z.string().min(1).optional(),
+    apiBaseUrl: z.string().url().optional(),
+    apiTimeoutMs: z.number().int().positive().optional(),
+    multiSelectMode: z.enum(['union', 'stringArray']).default('union'),
+    emitClient: z.boolean().default(false),
+    emitRegistry: z.boolean().default(true),
+    emitSdkClient: z.boolean().optional(),
+    emitReverseAliasMap: z.boolean().default(false),
+    emitMetadata: z.boolean().default(true),
+    format: z.boolean().default(true)
+});

package/dist/emit/formatter.d.ts

@@ -0,0 +1 @@
+export declare const formatTypeScript: (source: string) => Promise<string>;

package/dist/emit/formatter.js

@@ -0,0 +1,2 @@
+import prettier from 'prettier';
+export const formatTypeScript = async (source) => prettier.format(source, { parser: 'typescript' });

package/dist/emit/writer.d.ts

@@ -0,0 +1,7 @@
+export type GeneratedFileStatus = 'new' | 'changed' | 'unchanged';
+export interface GeneratedFileDiff {
+    path: string;
+    status: GeneratedFileStatus;
+}
+export declare const diffGeneratedFiles: (baseDir: string, files: Record<string, string>) => Promise<GeneratedFileDiff[]>;
+export declare const writeGeneratedFiles: (baseDir: string, files: Record<string, string>) => Promise<void>;

package/dist/emit/writer.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { sortedKeys } from '../utils/sort.js';
+const readCurrentFile = async (outputPath) => {
+    try {
+        return await readFile(outputPath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+};
+export const diffGeneratedFiles = async (baseDir, files) => {
+    const diffs = [];
+    for (const relativePath of sortedKeys(files)) {
+        const outputPath = path.join(baseDir, relativePath);
+        const current = await readCurrentFile(outputPath);
+        const next = files[relativePath];
+        if (current === undefined) {
+            diffs.push({ path: relativePath, status: 'new' });
+            continue;
+        }
+        diffs.push({ path: relativePath, status: current === next ? 'unchanged' : 'changed' });
+    }
+    return diffs;
+};
+export const writeGeneratedFiles = async (baseDir, files) => {
+    await mkdir(baseDir, { recursive: true });
+    for (const relativePath of sortedKeys(files)) {
+        const content = files[relativePath];
+        const outputPath = path.join(baseDir, relativePath);
+        await mkdir(path.dirname(outputPath), { recursive: true });
+        const current = await readCurrentFile(outputPath);
+        if (current !== content) {
+            await writeFile(outputPath, content, 'utf8');
+        }
+    }
+};

package/dist/generate.d.ts

@@ -0,0 +1,9 @@
+import type { GridfoxCodegenConfig, RawTable } from './model/internalTypes.js';
+import { type GeneratedFileDiff } from './emit/writer.js';
+export declare const buildGeneratedFiles: (tables: RawTable[], config: GridfoxCodegenConfig) => Promise<Record<string, string>>;
+export interface GenerationPlan {
+    files: Record<string, string>;
+    diff: GeneratedFileDiff[];
+}
+export declare const planGeneration: (tables: RawTable[], config: GridfoxCodegenConfig) => Promise<GenerationPlan>;
+export declare const generateFromTables: (tables: RawTable[], config: GridfoxCodegenConfig) => Promise<Record<string, string>>;