@chkit/plugin-codegen 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/index.js

@@ -1,852 +1,4 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { dirname, join, relative, resolve } from 'node:path';
-import { canonicalizeDefinitions, loadSchemaDefinitions, } from '@chkit/core';
-const DEFAULT_OPTIONS = {
-    outFile: './src/generated/chkit-types.ts',
-    emitZod: false,
-    tableNameStyle: 'pascal',
-    bigintMode: 'string',
-    includeViews: false,
-    runOnGenerate: true,
-    failOnUnsupportedType: true,
-    emitIngest: false,
-    ingestOutFile: './src/generated/chkit-ingest.ts',
-};
-const LARGE_INTEGER_TYPES = new Set([
-    'Int64',
-    'UInt64',
-    'Int128',
-    'UInt128',
-    'Int256',
-    'UInt256',
-]);
-const NUMBER_TYPES = new Set([
-    'Int8',
-    'Int16',
-    'Int32',
-    'UInt8',
-    'UInt16',
-    'UInt32',
-    'Float32',
-    'Float64',
-    'BFloat16',
-]);
-const STRING_TYPES = new Set([
-    'String',
-    'FixedString',
-    'Date',
-    'Date32',
-    'DateTime',
-    'DateTime64',
-    'UUID',
-    'IPv4',
-    'IPv6',
-    'Enum',
-    'Enum8',
-    'Enum16',
-    'Decimal',
-    'Decimal32',
-    'Decimal64',
-    'Decimal128',
-    'Decimal256',
-]);
-const BOOLEAN_TYPES = new Set(['Bool', 'Boolean']);
-class CodegenConfigError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CodegenConfigError';
-    }
-}
-class UnsupportedTypeError extends Error {
-    path;
-    sourceType;
-    constructor(path, sourceType) {
-        super(`Unsupported column type "${sourceType}" at ${path}. Set failOnUnsupportedType=false to emit unknown.`);
-        this.name = 'UnsupportedTypeError';
-        this.path = path;
-        this.sourceType = sourceType;
-    }
-}
-function parseBooleanOption(options, key) {
-    const value = options[key];
-    if (value === undefined)
-        return undefined;
-    if (typeof value === 'boolean')
-        return value;
-    throw new CodegenConfigError(`Invalid plugin option "${key}". Expected boolean.`);
-}
-function parseStringOption(options, key) {
-    const value = options[key];
-    if (value === undefined)
-        return undefined;
-    if (typeof value === 'string' && value.length > 0)
-        return value;
-    throw new CodegenConfigError(`Invalid plugin option "${key}". Expected non-empty string.`);
-}
-function normalizeRuntimeOptions(options) {
-    const rawTableNameStyle = options.tableNameStyle;
-    if (rawTableNameStyle !== undefined &&
-        rawTableNameStyle !== 'pascal' &&
-        rawTableNameStyle !== 'camel' &&
-        rawTableNameStyle !== 'raw') {
-        throw new CodegenConfigError('Invalid plugin option "tableNameStyle". Expected one of: pascal, camel, raw.');
-    }
-    const rawBigintMode = options.bigintMode;
-    if (rawBigintMode !== undefined && rawBigintMode !== 'string' && rawBigintMode !== 'bigint') {
-        throw new CodegenConfigError('Invalid plugin option "bigintMode". Expected one of: string, bigint.');
-    }
-    const normalized = {};
-    const outFile = parseStringOption(options, 'outFile');
-    const emitZod = parseBooleanOption(options, 'emitZod');
-    const includeViews = parseBooleanOption(options, 'includeViews');
-    const runOnGenerate = parseBooleanOption(options, 'runOnGenerate');
-    const failOnUnsupportedType = parseBooleanOption(options, 'failOnUnsupportedType');
-    const emitIngest = parseBooleanOption(options, 'emitIngest');
-    const ingestOutFile = parseStringOption(options, 'ingestOutFile');
-    if (outFile !== undefined)
-        normalized.outFile = outFile;
-    if (emitZod !== undefined)
-        normalized.emitZod = emitZod;
-    if (rawTableNameStyle !== undefined)
-        normalized.tableNameStyle = rawTableNameStyle;
-    if (rawBigintMode !== undefined)
-        normalized.bigintMode = rawBigintMode;
-    if (includeViews !== undefined)
-        normalized.includeViews = includeViews;
-    if (runOnGenerate !== undefined)
-        normalized.runOnGenerate = runOnGenerate;
-    if (failOnUnsupportedType !== undefined)
-        normalized.failOnUnsupportedType = failOnUnsupportedType;
-    if (emitIngest !== undefined)
-        normalized.emitIngest = emitIngest;
-    if (ingestOutFile !== undefined)
-        normalized.ingestOutFile = ingestOutFile;
-    return normalized;
-}
-export function normalizeCodegenOptions(options = {}) {
-    return {
-        ...DEFAULT_OPTIONS,
-        ...options,
-    };
-}
-function toWords(input) {
-    return input
-        .split(/[^a-zA-Z0-9]+/)
-        .map((part) => part.trim())
-        .filter((part) => part.length > 0);
-}
-function pascalCase(input) {
-    const words = toWords(input);
-    if (words.length === 0)
-        return 'Item';
-    return words.map((part) => part[0]?.toUpperCase() + part.slice(1)).join('');
-}
-function camelCase(input) {
-    const words = toWords(input);
-    if (words.length === 0)
-        return 'item';
-    const [head, ...tail] = words;
-    return `${head?.toLowerCase() ?? 'item'}${tail
-        .map((part) => part[0]?.toUpperCase() + part.slice(1))
-        .join('')}`;
-}
-function rawCase(input) {
-    const sanitized = input.replace(/[^a-zA-Z0-9_]/g, '_').replace(/_+/g, '_').replace(/^_+|_+$/g, '');
-    return sanitized.length > 0 ? sanitized : 'item';
-}
-function isValidIdentifier(input) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(input);
-}
-function renderPropertyName(name) {
-    if (isValidIdentifier(name))
-        return name;
-    return JSON.stringify(name);
-}
-function baseRowTypeName(definition, style) {
-    const combined = `${definition.database}_${definition.name}`;
-    if (style === 'raw') {
-        const candidate = `${rawCase(combined)}_row`;
-        return isValidIdentifier(candidate) ? candidate : `_${candidate}`;
-    }
-    if (style === 'camel') {
-        return `${camelCase(combined)}Row`;
-    }
-    return `${pascalCase(combined)}Row`;
-}
-function resolveTableNames(definitions, style) {
-    const baseNames = definitions.map((definition) => ({
-        definition,
-        base: baseRowTypeName(definition, style),
-    }));
-    const counts = new Map();
-    return baseNames.map((item) => {
-        const seen = counts.get(item.base) ?? 0;
-        const nextSeen = seen + 1;
-        counts.set(item.base, nextSeen);
-        return {
-            definition: item.definition,
-            interfaceName: nextSeen === 1 ? item.base : `${item.base}_${nextSeen}`,
-        };
-    });
-}
-function splitTopLevelArgs(input) {
-    const args = [];
-    let depth = 0;
-    let start = 0;
-    for (let i = 0; i < input.length; i++) {
-        const ch = input[i];
-        if (ch === '(')
-            depth++;
-        else if (ch === ')')
-            depth--;
-        else if (ch === ',' && depth === 0) {
-            args.push(input.slice(start, i).trim());
-            start = i + 1;
-        }
-    }
-    const last = input.slice(start).trim();
-    if (last.length > 0)
-        args.push(last);
-    return args;
-}
-function parseClickHouseType(typeStr) {
-    const trimmed = typeStr.trim();
-    const parenIndex = trimmed.indexOf('(');
-    if (parenIndex < 0)
-        return { base: trimmed, args: [] };
-    const base = trimmed.slice(0, parenIndex);
-    const closingParen = trimmed.lastIndexOf(')');
-    if (closingParen <= parenIndex)
-        return { base: trimmed, args: [] };
-    const inner = trimmed.slice(parenIndex + 1, closingParen);
-    if (inner.trim().length === 0)
-        return { base, args: [] };
-    return { base, args: splitTopLevelArgs(inner) };
-}
-function mapScalarType(base, bigintMode) {
-    if (STRING_TYPES.has(base))
-        return 'string';
-    if (BOOLEAN_TYPES.has(base))
-        return 'boolean';
-    if (NUMBER_TYPES.has(base))
-        return 'number';
-    if (LARGE_INTEGER_TYPES.has(base))
-        return bigintMode;
-    return null;
-}
-function scalarToZod(mapped) {
-    if (mapped === 'string')
-        return 'z.string()';
-    if (mapped === 'number')
-        return 'z.number()';
-    if (mapped === 'boolean')
-        return 'z.boolean()';
-    if (mapped === 'bigint')
-        return 'z.bigint()';
-    return 'z.unknown()';
-}
-function resolveInnerType(typeStr, bigintMode) {
-    const parsed = parseClickHouseType(typeStr);
-    const scalar = mapScalarType(parsed.base, bigintMode);
-    if (scalar)
-        return { tsType: scalar, zodType: scalarToZod(scalar) };
-    switch (parsed.base) {
-        case 'Nullable': {
-            const arg = parsed.args[0];
-            if (!arg)
-                return null;
-            const inner = resolveInnerType(arg, bigintMode);
-            if (!inner)
-                return null;
-            return { tsType: `${inner.tsType} | null`, zodType: `${inner.zodType}.nullable()` };
-        }
-        case 'LowCardinality': {
-            const arg = parsed.args[0];
-            if (!arg)
-                return null;
-            return resolveInnerType(arg, bigintMode);
-        }
-        case 'Array': {
-            const arg = parsed.args[0];
-            if (!arg)
-                return null;
-            const inner = resolveInnerType(arg, bigintMode);
-            if (!inner)
-                return null;
-            const needsWrap = inner.tsType.includes('|');
-            const tsType = needsWrap ? `(${inner.tsType})[]` : `${inner.tsType}[]`;
-            return { tsType, zodType: `z.array(${inner.zodType})` };
-        }
-        case 'Map': {
-            const keyArg = parsed.args[0];
-            const valueArg = parsed.args[1];
-            if (!keyArg || !valueArg)
-                return null;
-            const key = resolveInnerType(keyArg, bigintMode);
-            const value = resolveInnerType(valueArg, bigintMode);
-            if (!key || !value)
-                return null;
-            return {
-                tsType: `Record<${key.tsType}, ${value.tsType}>`,
-                zodType: `z.record(${key.zodType}, ${value.zodType})`,
-            };
-        }
-        case 'Tuple': {
-            if (parsed.args.length === 0)
-                return null;
-            const elements = parsed.args.map((a) => resolveInnerType(a, bigintMode));
-            if (elements.some((e) => e === null))
-                return null;
-            const valid = elements;
-            return {
-                tsType: `[${valid.map((e) => e.tsType).join(', ')}]`,
-                zodType: `z.tuple([${valid.map((e) => e.zodType).join(', ')}])`,
-            };
-        }
-        case 'SimpleAggregateFunction': {
-            const lastArg = parsed.args[parsed.args.length - 1];
-            if (parsed.args.length < 2 || !lastArg)
-                return null;
-            return resolveInnerType(lastArg, bigintMode);
-        }
-        case 'JSON': {
-            return { tsType: 'Record<string, unknown>', zodType: 'z.record(z.string(), z.unknown())' };
-        }
-        default:
-            return null;
-    }
-}
-function resolveColumnType(typeStr, bigintMode) {
-    const parsed = parseClickHouseType(typeStr);
-    const firstArg = parsed.args[0];
-    if (parsed.base === 'LowCardinality' && firstArg) {
-        return resolveColumnType(firstArg, bigintMode);
-    }
-    if (parsed.base === 'Nullable' && firstArg) {
-        const inner = resolveColumnType(firstArg, bigintMode);
-        if (!inner)
-            return null;
-        return { tsType: inner.tsType, zodType: inner.zodType, nullable: true };
-    }
-    const resolved = resolveInnerType(typeStr, bigintMode);
-    if (!resolved)
-        return null;
-    return { tsType: resolved.tsType, zodType: resolved.zodType, nullable: false };
-}
-export function mapColumnType(input, options) {
-    const resolved = resolveColumnType(input.column.type, options.bigintMode);
-    const columnNullable = input.column.nullable === true;
-    if (!resolved) {
-        if (options.failOnUnsupportedType) {
-            throw new UnsupportedTypeError(input.path, input.column.type);
-        }
-        const unknownType = columnNullable ? 'unknown | null' : 'unknown';
-        return {
-            tsType: unknownType,
-            zodType: 'z.unknown()',
-            nullable: columnNullable,
-            finding: {
-                code: 'codegen_unsupported_type',
-                message: `Unsupported type "${input.column.type}" at ${input.path}; emitted unknown.`,
-                severity: 'warn',
-                path: input.path,
-            },
-        };
-    }
-    const nullable = columnNullable || resolved.nullable;
-    const tsType = nullable ? `${resolved.tsType} | null` : resolved.tsType;
-    return { tsType, zodType: resolved.zodType, nullable };
-}
-function renderHeader(toolVersion) {
-    const lines = ['// Generated by chkit codegen plugin'];
-    lines.push(`// chkit-codegen-version: ${toolVersion}`);
-    return lines;
-}
-function renderTableInterface(table, interfaceName, options) {
-    const lines = [`export interface ${interfaceName} {`];
-    const findings = [];
-    const zodFields = [];
-    for (const column of table.columns) {
-        const path = `${table.database}.${table.name}.${column.name}`;
-        const mapped = mapColumnType({ column, path }, options);
-        if (mapped.finding)
-            findings.push(mapped.finding);
-        lines.push(`  ${renderPropertyName(column.name)}: ${mapped.tsType}`);
-        const zodExpr = mapped.nullable ? `${mapped.zodType}.nullable()` : mapped.zodType;
-        zodFields.push(`  ${renderPropertyName(column.name)}: ${zodExpr},`);
-    }
-    lines.push('}');
-    if (options.emitZod) {
-        lines.push('');
-        lines.push(`export const ${interfaceName}Schema = z.object({`);
-        lines.push(...zodFields);
-        lines.push('})');
-        lines.push('');
-        lines.push(`export type ${interfaceName}Input = z.input<typeof ${interfaceName}Schema>`);
-        lines.push(`export type ${interfaceName}Output = z.output<typeof ${interfaceName}Schema>`);
-    }
-    return { lines, findings };
-}
-function renderViewInterface(definition, interfaceName) {
-    const kind = definition.kind === 'view' ? 'view' : 'materialized_view';
-    return {
-        lines: [
-            `export interface ${interfaceName} {`,
-            '  [key: string]: unknown',
-            '}',
-            '',
-            `// ${kind} ${definition.database}.${definition.name} is emitted as unknown-key row shape in v1.`,
-        ],
-        findings: [],
-    };
-}
-export function generateTypeArtifacts(input) {
-    const normalized = normalizeCodegenOptions(input.options);
-    const definitions = canonicalizeDefinitions(input.definitions);
-    const sortedDefinitions = definitions
-        .filter((definition) => {
-        if (definition.kind === 'table')
-            return true;
-        if (!normalized.includeViews)
-            return false;
-        return definition.kind === 'view' || definition.kind === 'materialized_view';
-    })
-        .sort((a, b) => {
-        if (a.database !== b.database)
-            return a.database.localeCompare(b.database);
-        return a.name.localeCompare(b.name);
-    });
-    const resolved = resolveTableNames(sortedDefinitions, normalized.tableNameStyle);
-    const findings = [];
-    const bodyLines = [];
-    for (const entry of resolved) {
-        const rendered = entry.definition.kind === 'table'
-            ? renderTableInterface(entry.definition, entry.interfaceName, normalized)
-            : renderViewInterface(entry.definition, entry.interfaceName);
-        findings.push(...rendered.findings);
-        bodyLines.push(...rendered.lines);
-        bodyLines.push('');
-    }
-    const header = renderHeader(input.toolVersion ?? '0.1.0');
-    const lines = [
-        ...header,
-        ...(normalized.emitZod ? ['', "import { z } from 'zod'"] : []),
-        '',
-        ...bodyLines,
-    ];
-    const content = `${lines.join('\n').trimEnd()}\n`;
-    return {
-        content,
-        outFile: normalized.outFile,
-        declarationCount: resolved.length,
-        findings,
-    };
-}
-function computeRelativeImportPath(fromFile, toFile) {
-    const fromDir = dirname(fromFile);
-    let rel = relative(fromDir, toFile);
-    if (!rel.startsWith('.'))
-        rel = `./${rel}`;
-    // Replace .ts extension with .js for ESM imports
-    return rel.replace(/\.ts$/, '.js');
-}
-function stripRowSuffix(name) {
-    if (name.endsWith('Row'))
-        return name.slice(0, -3);
-    if (name.endsWith('_row'))
-        return name.slice(0, -4);
-    return name;
-}
-function renderIngestFunction(table, interfaceName, emitZod) {
-    const funcName = `ingest${stripRowSuffix(interfaceName)}`;
-    const tableFqn = `${table.database}.${table.name}`;
-    const lines = [];
-    if (emitZod) {
-        lines.push(`export async function ${funcName}(`);
-        lines.push(`  ingestor: Ingestor,`);
-        lines.push(`  rows: ${interfaceName}[],`);
-        lines.push(`  options?: { validate?: boolean }`);
-        lines.push(`): Promise<void> {`);
-        lines.push(`  const data = options?.validate ? rows.map(row => ${interfaceName}Schema.parse(row)) : rows`);
-        lines.push(`  await ingestor.insert({ table: '${tableFqn}', values: data })`);
-        lines.push(`}`);
-    }
-    else {
-        lines.push(`export async function ${funcName}(`);
-        lines.push(`  ingestor: Ingestor,`);
-        lines.push(`  rows: ${interfaceName}[]`);
-        lines.push(`): Promise<void> {`);
-        lines.push(`  await ingestor.insert({ table: '${tableFqn}', values: rows })`);
-        lines.push(`}`);
-    }
-    return lines;
-}
-export function generateIngestArtifacts(input) {
-    const normalized = normalizeCodegenOptions(input.options);
-    const definitions = canonicalizeDefinitions(input.definitions);
-    const tables = definitions
-        .filter((definition) => definition.kind === 'table')
-        .sort((a, b) => {
-        if (a.database !== b.database)
-            return a.database.localeCompare(b.database);
-        return a.name.localeCompare(b.name);
-    });
-    const resolved = resolveTableNames(tables, normalized.tableNameStyle);
-    const importPath = computeRelativeImportPath(normalized.ingestOutFile, normalized.outFile);
-    const typeImports = [];
-    const valueImports = [];
-    for (const entry of resolved) {
-        typeImports.push(entry.interfaceName);
-        if (normalized.emitZod) {
-            valueImports.push(`${entry.interfaceName}Schema`);
-        }
-    }
-    const header = renderHeader(input.toolVersion ?? '0.1.0');
-    const lines = [...header, ''];
-    if (typeImports.length > 0) {
-        lines.push(`import type { ${typeImports.join(', ')} } from '${importPath}'`);
-    }
-    if (valueImports.length > 0) {
-        lines.push(`import { ${valueImports.join(', ')} } from '${importPath}'`);
-    }
-    lines.push('');
-    lines.push('export interface Ingestor {');
-    lines.push('  insert(params: { table: string; values: Record<string, unknown>[] }): Promise<void>');
-    lines.push('}');
-    for (const entry of resolved) {
-        if (entry.definition.kind !== 'table')
-            continue;
-        lines.push('');
-        lines.push(...renderIngestFunction(entry.definition, entry.interfaceName, normalized.emitZod));
-    }
-    const content = `${lines.join('\n').trimEnd()}\n`;
-    return {
-        content,
-        outFile: normalized.ingestOutFile,
-        functionCount: resolved.length,
-    };
-}
-function parseArgs(args) {
-    const parsed = {
-        check: false,
-    };
-    for (let i = 0; i < args.length; i += 1) {
-        const token = args[i];
-        if (!token)
-            continue;
-        if (token === '--check') {
-            parsed.check = true;
-            continue;
-        }
-        if (token === '--include-views') {
-            parsed.includeViews = true;
-            continue;
-        }
-        if (token === '--emit-zod') {
-            parsed.emitZod = true;
-            continue;
-        }
-        if (token === '--no-emit-zod') {
-            parsed.emitZod = false;
-            continue;
-        }
-        if (token === '--emit-ingest') {
-            parsed.emitIngest = true;
-            continue;
-        }
-        if (token === '--no-emit-ingest') {
-            parsed.emitIngest = false;
-            continue;
-        }
-        if (token === '--out-file') {
-            const value = args[i + 1];
-            if (!value || value.startsWith('--')) {
-                throw new CodegenConfigError('Missing value for --out-file');
-            }
-            parsed.outFile = value;
-            i += 1;
-            continue;
-        }
-        if (token === '--ingest-out-file') {
-            const value = args[i + 1];
-            if (!value || value.startsWith('--')) {
-                throw new CodegenConfigError('Missing value for --ingest-out-file');
-            }
-            parsed.ingestOutFile = value;
-            i += 1;
-            continue;
-        }
-        if (token === '--bigint-mode') {
-            const value = args[i + 1];
-            if (value !== 'string' && value !== 'bigint') {
-                throw new CodegenConfigError('Invalid value for --bigint-mode. Expected string or bigint.');
-            }
-            parsed.bigintMode = value;
-            i += 1;
-        }
-    }
-    return parsed;
-}
-function mergeOptions(baseOptions, runtimeOptions, argOptions) {
-    const fromRuntime = normalizeRuntimeOptions(runtimeOptions);
-    const withRuntime = normalizeCodegenOptions({ ...baseOptions, ...fromRuntime });
-    return normalizeCodegenOptions({
-        ...withRuntime,
-        outFile: argOptions.outFile ?? withRuntime.outFile,
-        emitZod: argOptions.emitZod ?? withRuntime.emitZod,
-        bigintMode: argOptions.bigintMode ?? withRuntime.bigintMode,
-        includeViews: argOptions.includeViews ?? withRuntime.includeViews,
-        emitIngest: argOptions.emitIngest ?? withRuntime.emitIngest,
-        ingestOutFile: argOptions.ingestOutFile ?? withRuntime.ingestOutFile,
-    });
-}
-export function isRunOnGenerateEnabled(baseOptions, runtimeOptions) {
-    const fromRuntime = normalizeRuntimeOptions(runtimeOptions);
-    const effective = normalizeCodegenOptions({ ...baseOptions, ...fromRuntime });
-    return effective.runOnGenerate;
-}
-async function writeAtomic(targetPath, content) {
-    await mkdir(dirname(targetPath), { recursive: true });
-    const tempPath = join(dirname(targetPath), `.${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`);
-    await writeFile(tempPath, content, 'utf8');
-    await rename(tempPath, targetPath);
-}
-async function readMaybe(path) {
-    try {
-        return await readFile(path, 'utf8');
-    }
-    catch {
-        return null;
-    }
-}
-function checkGeneratedOutput(input) {
-    if (input.current === null) {
-        return {
-            plugin: 'codegen',
-            evaluated: true,
-            ok: false,
-            findings: [
-                {
-                    code: input.missingCode,
-                    message: `${input.label} output file is missing: ${input.outFile}`,
-                    severity: 'error',
-                    metadata: { outFile: input.outFile },
-                },
-            ],
-            metadata: {
-                outFile: input.outFile,
-            },
-        };
-    }
-    if (input.current !== input.expected) {
-        return {
-            plugin: 'codegen',
-            evaluated: true,
-            ok: false,
-            findings: [
-                {
-                    code: input.staleCode,
-                    message: `${input.label} output is stale: ${input.outFile}`,
-                    severity: 'error',
-                    metadata: { outFile: input.outFile },
-                },
-            ],
-            metadata: {
-                outFile: input.outFile,
-            },
-        };
-    }
-    return {
-        plugin: 'codegen',
-        evaluated: true,
-        ok: true,
-        findings: [],
-        metadata: {
-            outFile: input.outFile,
-        },
-    };
-}
-function mergeCheckResults(results) {
-    const allFindings = results.flatMap((r) => r.findings);
-    const allOk = results.every((r) => r.ok);
-    return {
-        plugin: 'codegen',
-        evaluated: true,
-        ok: allOk,
-        findings: allFindings,
-        metadata: results.reduce((acc, r) => ({ ...acc, ...r.metadata }), {}),
-    };
-}
-export function createCodegenPlugin(options = {}) {
-    const base = normalizeCodegenOptions(options);
-    return {
-        manifest: {
-            name: 'codegen',
-            apiVersion: 1,
-        },
-        commands: [
-            {
-                name: 'codegen',
-                description: 'Generate TypeScript artifacts from chkit schema definitions',
-                async run({ args, jsonMode, print, options: runtimeOptions, config, configPath, }) {
-                    try {
-                        const parsedArgs = parseArgs(args);
-                        const effectiveOptions = mergeOptions(base, runtimeOptions, parsedArgs);
-                        const configDir = resolve(configPath, '..');
-                        const outFile = resolve(configDir, effectiveOptions.outFile);
-                        const definitions = await loadSchemaDefinitions(config.schema, { cwd: configDir });
-                        const generated = generateTypeArtifacts({
-                            definitions,
-                            options: effectiveOptions,
-                        });
-                        let ingestGenerated = null;
-                        let ingestOutFile = null;
-                        if (effectiveOptions.emitIngest) {
-                            ingestGenerated = generateIngestArtifacts({
-                                definitions,
-                                options: effectiveOptions,
-                            });
-                            ingestOutFile = resolve(configDir, effectiveOptions.ingestOutFile);
-                        }
-                        if (parsedArgs.check) {
-                            const current = await readMaybe(outFile);
-                            const typeCheckResult = checkGeneratedOutput({
-                                label: 'Codegen',
-                                outFile,
-                                expected: generated.content,
-                                current,
-                                missingCode: 'codegen_missing_output',
-                                staleCode: 'codegen_stale_output',
-                            });
-                            const results = [typeCheckResult];
-                            if (ingestGenerated && ingestOutFile) {
-                                const ingestCurrent = await readMaybe(ingestOutFile);
-                                results.push(checkGeneratedOutput({
-                                    label: 'Codegen ingest',
-                                    outFile: ingestOutFile,
-                                    expected: ingestGenerated.content,
-                                    current: ingestCurrent,
-                                    missingCode: 'codegen_missing_ingest_output',
-                                    staleCode: 'codegen_stale_ingest_output',
-                                }));
-                            }
-                            const checkResult = mergeCheckResults(results);
-                            const payload = {
-                                ok: checkResult.ok,
-                                findingCodes: checkResult.findings.map((finding) => finding.code),
-                                outFile,
-                                mode: 'check',
-                            };
-                            if (jsonMode) {
-                                print(payload);
-                            }
-                            else {
-                                if (checkResult.ok) {
-                                    print(`Codegen up-to-date: ${outFile}`);
-                                }
-                                else {
-                                    const firstCode = checkResult.findings[0]?.code ?? 'codegen_stale_output';
-                                    print(`Codegen check failed (${firstCode}): ${outFile}`);
-                                }
-                            }
-                            return checkResult.ok ? 0 : 1;
-                        }
-                        await writeAtomic(outFile, generated.content);
-                        if (ingestGenerated && ingestOutFile) {
-                            await writeAtomic(ingestOutFile, ingestGenerated.content);
-                        }
-                        const payload = {
-                            ok: true,
-                            outFile,
-                            declarationCount: generated.declarationCount,
-                            findingCodes: generated.findings.map((finding) => finding.code),
-                            mode: 'write',
-                        };
-                        if (jsonMode) {
-                            print(payload);
-                        }
-                        else {
-                            print(`Codegen wrote ${outFile} (${generated.declarationCount} declarations)`);
-                        }
-                        return 0;
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        if (jsonMode) {
-                            print({
-                                ok: false,
-                                error: message,
-                            });
-                        }
-                        else {
-                            print(`Codegen failed: ${message}`);
-                        }
-                        if (error instanceof CodegenConfigError) {
-                            return 2;
-                        }
-                        return 1;
-                    }
-                },
-            },
-        ],
-        hooks: {
-            onConfigLoaded({ options: runtimeOptions }) {
-                normalizeRuntimeOptions(runtimeOptions);
-            },
-            async onCheck({ config, configPath, options: runtimeOptions }) {
-                const effectiveOptions = mergeOptions(base, runtimeOptions, { check: false });
-                const configDir = resolve(configPath, '..');
-                const outFile = resolve(configDir, effectiveOptions.outFile);
-                const definitions = await loadSchemaDefinitions(config.schema, { cwd: configDir });
-                const generated = generateTypeArtifacts({
-                    definitions,
-                    options: effectiveOptions,
-                });
-                const current = await readMaybe(outFile);
-                const typeResult = checkGeneratedOutput({
-                    label: 'Codegen',
-                    outFile,
-                    expected: generated.content,
-                    current,
-                    missingCode: 'codegen_missing_output',
-                    staleCode: 'codegen_stale_output',
-                });
-                if (!effectiveOptions.emitIngest) {
-                    return typeResult;
-                }
-                const ingestOutFile = resolve(configDir, effectiveOptions.ingestOutFile);
-                const ingestGenerated = generateIngestArtifacts({
-                    definitions,
-                    options: effectiveOptions,
-                });
-                const ingestCurrent = await readMaybe(ingestOutFile);
-                const ingestResult = checkGeneratedOutput({
-                    label: 'Codegen ingest',
-                    outFile: ingestOutFile,
-                    expected: ingestGenerated.content,
-                    current: ingestCurrent,
-                    missingCode: 'codegen_missing_ingest_output',
-                    staleCode: 'codegen_stale_ingest_output',
-                });
-                return mergeCheckResults([typeResult, ingestResult]);
-            },
-            onCheckReport({ result, print }) {
-                const findingCodes = result.findings.map((finding) => finding.code);
-                if (result.ok) {
-                    print(`codegen check: ok`);
-                    return;
-                }
-                print(`codegen check: failed${findingCodes.length > 0 ? ` (${findingCodes.join(', ')})` : ''}`);
-            },
-        },
-    };
-}
-export function codegen(options = {}) {
-    return {
-        plugin: createCodegenPlugin(),
-        name: 'codegen',
-        enabled: true,
-        options,
-    };
-}
+export { createCodegenPlugin, codegen } from './plugin.js';
+export { normalizeCodegenOptions, isRunOnGenerateEnabled } from './options.js';
+export { mapColumnType, generateTypeArtifacts, generateIngestArtifacts } from './generators.js';
 //# sourceMappingURL=index.js.map