@constructive-io/graphql-codegen 4.0.1 → 4.1.0

package/esm/core/generate.js

@@ -4,22 +4,27 @@
  * This is the primary entry point for programmatic usage.
  * The CLI is a thin wrapper around this function.
  */
+import * as fs from 'node:fs';
 import path from 'node:path';
+import { buildClientSchema, printSchema } from 'graphql';
+import { PgpmPackage } from '@pgpmjs/core';
+import { createEphemeralDb } from 'pgsql-client';
+import { deployPgpm } from 'pgsql-seed';
 import { getConfigOptions } from '../types/config';
 import { generate as generateReactQueryFiles } from './codegen';
 import { generateRootBarrel } from './codegen/barrel';
+import { generateCli as generateCliFiles, generateMultiTargetCli } from './codegen/cli';
+import { generateReadme as generateCliReadme, generateAgentsDocs as generateCliAgentsDocs, getCliMcpTools, generateSkills as generateCliSkills, generateMultiTargetReadme, generateMultiTargetAgentsDocs, getMultiTargetCliMcpTools, generateMultiTargetSkills, } from './codegen/cli/docs-generator';
+import { resolveDocsConfig } from './codegen/docs-utils';
+import { generateHooksReadme, generateHooksAgentsDocs, getHooksMcpTools, generateHooksSkills, } from './codegen/hooks-docs-generator';
 import { generateOrm as generateOrmFiles } from './codegen/orm';
+import { generateOrmReadme, generateOrmAgentsDocs, getOrmMcpTools, generateOrmSkills, } from './codegen/orm/docs-generator';
 import { generateSharedTypes } from './codegen/shared';
+import { generateTargetReadme, generateCombinedMcpConfig, generateRootRootReadme, } from './codegen/target-docs-generator';
 import { createSchemaSource, validateSourceOptions } from './introspect';
 import { writeGeneratedFiles } from './output';
 import { runCodegenPipeline, validateTablesFound } from './pipeline';
-/**
- * Main generate function - takes a single config and generates code
- *
- * This is the primary entry point for programmatic usage.
- * For multiple configs, call this function in a loop.
- */
-export async function generate(options = {}) {
+export async function generate(options = {}, internalOptions) {
     // Apply defaults to get resolved config
     const config = getConfigOptions(options);
     const outputRoot = config.output;
@@ -27,11 +32,12 @@ export async function generate(options = {}) {
     // ORM is always required when React Query is enabled (hooks delegate to ORM)
     // This handles minimist setting orm=false when --orm flag is absent
     const runReactQuery = config.reactQuery ?? false;
-    const runOrm = runReactQuery || (options.orm !== undefined ? !!options.orm : false);
-    if (!runReactQuery && !runOrm) {
+    const runCli = internalOptions?.skipCli ? false : !!config.cli;
+    const runOrm = runReactQuery || !!config.cli || (options.orm !== undefined ? !!options.orm : false);
+    if (!options.schemaOnly && !runReactQuery && !runOrm && !runCli) {
         return {
             success: false,
-            message: 'No generators enabled. Use reactQuery: true or orm: true in your config.',
+            message: 'No generators enabled. Use reactQuery: true, orm: true, or cli: true in your config.',
             output: outputRoot,
         };
     }
@@ -55,6 +61,39 @@ export async function generate(options = {}) {
         authorization: options.authorization || config.headers?.Authorization,
         headers: config.headers,
     });
+    if (options.schemaOnly) {
+        try {
+            console.log(`Fetching schema from ${source.describe()}...`);
+            const { introspection } = await source.fetch();
+            const schema = buildClientSchema(introspection);
+            const sdl = printSchema(schema);
+            if (!sdl.trim()) {
+                return {
+                    success: false,
+                    message: 'Schema introspection returned empty SDL.',
+                    output: outputRoot,
+                };
+            }
+            const outDir = path.resolve(options.schemaOnlyOutput || outputRoot || '.');
+            await fs.promises.mkdir(outDir, { recursive: true });
+            const filename = options.schemaOnlyFilename || 'schema.graphql';
+            const filePath = path.join(outDir, filename);
+            await fs.promises.writeFile(filePath, sdl, 'utf-8');
+            return {
+                success: true,
+                message: `Schema exported to ${filePath}`,
+                output: outDir,
+                filesWritten: [filePath],
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: `Failed to export schema: ${err instanceof Error ? err.message : 'Unknown error'}`,
+                output: outputRoot,
+            };
+        }
+    }
     // Run pipeline
     let pipelineResult;
     try {
@@ -136,14 +175,115 @@ export async function generate(options = {}) {
             path: path.posix.join('orm', file.path),
         })));
     }
+    // Generate CLI commands
+    if (runCli) {
+        console.log('Generating CLI commands...');
+        const { files } = generateCliFiles({
+            tables,
+            customOperations: {
+                queries: customOperations.queries,
+                mutations: customOperations.mutations,
+            },
+            config,
+        });
+        filesToWrite.push(...files.map((file) => ({
+            path: path.posix.join('cli', file.fileName),
+            content: file.content,
+        })));
+    }
     // Generate barrel file at output root
-    // This re-exports from the appropriate subdirectories based on which generators are enabled
     const barrelContent = generateRootBarrel({
         hasTypes: bothEnabled,
         hasHooks: runReactQuery,
         hasOrm: runOrm,
+        hasCli: runCli,
     });
     filesToWrite.push({ path: 'index.ts', content: barrelContent });
+    // Generate docs for each enabled generator
+    const docsConfig = resolveDocsConfig(config.docs);
+    const allCustomOps = [
+        ...(customOperations.queries ?? []),
+        ...(customOperations.mutations ?? []),
+    ];
+    const allMcpTools = [];
+    if (runOrm) {
+        if (docsConfig.readme) {
+            const readme = generateOrmReadme(tables, allCustomOps);
+            filesToWrite.push({ path: path.posix.join('orm', readme.fileName), content: readme.content });
+        }
+        if (docsConfig.agents) {
+            const agents = generateOrmAgentsDocs(tables, allCustomOps);
+            filesToWrite.push({ path: path.posix.join('orm', agents.fileName), content: agents.content });
+        }
+        if (docsConfig.mcp) {
+            allMcpTools.push(...getOrmMcpTools(tables, allCustomOps));
+        }
+        if (docsConfig.skills) {
+            for (const skill of generateOrmSkills(tables, allCustomOps)) {
+                filesToWrite.push({ path: path.posix.join('orm', skill.fileName), content: skill.content });
+            }
+        }
+    }
+    if (runReactQuery) {
+        if (docsConfig.readme) {
+            const readme = generateHooksReadme(tables, allCustomOps);
+            filesToWrite.push({ path: path.posix.join('hooks', readme.fileName), content: readme.content });
+        }
+        if (docsConfig.agents) {
+            const agents = generateHooksAgentsDocs(tables, allCustomOps);
+            filesToWrite.push({ path: path.posix.join('hooks', agents.fileName), content: agents.content });
+        }
+        if (docsConfig.mcp) {
+            allMcpTools.push(...getHooksMcpTools(tables, allCustomOps));
+        }
+        if (docsConfig.skills) {
+            for (const skill of generateHooksSkills(tables, allCustomOps)) {
+                filesToWrite.push({ path: path.posix.join('hooks', skill.fileName), content: skill.content });
+            }
+        }
+    }
+    if (runCli) {
+        const toolName = typeof config.cli === 'object' && config.cli?.toolName
+            ? config.cli.toolName
+            : 'app';
+        if (docsConfig.readme) {
+            const readme = generateCliReadme(tables, allCustomOps, toolName);
+            filesToWrite.push({ path: path.posix.join('cli', readme.fileName), content: readme.content });
+        }
+        if (docsConfig.agents) {
+            const agents = generateCliAgentsDocs(tables, allCustomOps, toolName);
+            filesToWrite.push({ path: path.posix.join('cli', agents.fileName), content: agents.content });
+        }
+        if (docsConfig.mcp) {
+            allMcpTools.push(...getCliMcpTools(tables, allCustomOps, toolName));
+        }
+        if (docsConfig.skills) {
+            for (const skill of generateCliSkills(tables, allCustomOps, toolName)) {
+                filesToWrite.push({ path: path.posix.join('cli', skill.fileName), content: skill.content });
+            }
+        }
+    }
+    // Generate combined mcp.json at output root
+    if (docsConfig.mcp && allMcpTools.length > 0) {
+        const mcpName = typeof config.cli === 'object' && config.cli?.toolName
+            ? config.cli.toolName
+            : 'graphql-sdk';
+        const mcpFile = generateCombinedMcpConfig(allMcpTools, mcpName);
+        filesToWrite.push({ path: mcpFile.fileName, content: mcpFile.content });
+    }
+    // Generate per-target README at output root
+    if (docsConfig.readme) {
+        const targetReadme = generateTargetReadme({
+            hasOrm: runOrm,
+            hasHooks: runReactQuery,
+            hasCli: runCli,
+            tableCount: tables.length,
+            customQueryCount: customOperations.queries.length,
+            customMutationCount: customOperations.mutations.length,
+            config,
+        });
+        filesToWrite.push({ path: targetReadme.fileName, content: targetReadme.content });
+    }
     if (!options.dryRun) {
         const writeResult = await writeGeneratedFiles(filesToWrite, outputRoot, [], {
             pruneStaleFiles: true,
@@ -158,7 +298,11 @@ export async function generate(options = {}) {
         }
         allFilesWritten.push(...(writeResult.filesWritten ?? []));
     }
-    const generators = [runReactQuery && 'React Query', runOrm && 'ORM']
+    const generators = [
+        runReactQuery && 'React Query',
+        runOrm && 'ORM',
+        runCli && 'CLI',
+    ]
         .filter(Boolean)
         .join(' and ');
     return {
@@ -169,5 +313,266 @@ export async function generate(options = {}) {
         output: outputRoot,
         tables: tables.map((t) => t.name),
         filesWritten: allFilesWritten,
+        pipelineData: {
+            tables,
+            customOperations: {
+                queries: customOperations.queries,
+                mutations: customOperations.mutations,
+            },
+        },
+    };
+}
+export function expandApiNamesToMultiTarget(config) {
+    const apiNames = config.db?.apiNames;
+    if (!apiNames || apiNames.length <= 1)
+        return null;
+    const targets = {};
+    for (const apiName of apiNames) {
+        targets[apiName] = {
+            ...config,
+            db: {
+                ...config.db,
+                apiNames: [apiName],
+            },
+            output: config.output
+                ? `${config.output}/${apiName}`
+                : `./generated/graphql/${apiName}`,
+        };
+    }
+    return targets;
+}
+export function expandSchemaDirToMultiTarget(config) {
+    const schemaDir = config.schemaDir;
+    if (!schemaDir)
+        return null;
+    const resolvedDir = path.resolve(schemaDir);
+    if (!fs.existsSync(resolvedDir) || !fs.statSync(resolvedDir).isDirectory()) {
+        return null;
+    }
+    const graphqlFiles = fs.readdirSync(resolvedDir)
+        .filter((f) => f.endsWith('.graphql'))
+        .sort();
+    if (graphqlFiles.length === 0)
+        return null;
+    const targets = {};
+    for (const file of graphqlFiles) {
+        const name = path.basename(file, '.graphql');
+        targets[name] = {
+            ...config,
+            schemaDir: undefined,
+            schemaFile: path.join(resolvedDir, file),
+            output: config.output
+                ? `${config.output}/${name}`
+                : `./generated/graphql/${name}`,
+        };
+    }
+    return targets;
+}
+function getPgpmSourceKey(pgpm) {
+    if (pgpm.modulePath)
+        return `module:${path.resolve(pgpm.modulePath)}`;
+    if (pgpm.workspacePath && pgpm.moduleName)
+        return `workspace:${path.resolve(pgpm.workspacePath)}:${pgpm.moduleName}`;
+    return null;
+}
+function getModulePathFromPgpm(pgpm) {
+    if (pgpm.modulePath)
+        return pgpm.modulePath;
+    if (pgpm.workspacePath && pgpm.moduleName) {
+        const workspace = new PgpmPackage(pgpm.workspacePath);
+        const moduleProject = workspace.getModuleProject(pgpm.moduleName);
+        const modulePath = moduleProject.getModulePath();
+        if (!modulePath) {
+            throw new Error(`Module "${pgpm.moduleName}" not found in workspace`);
+        }
+        return modulePath;
+    }
+    throw new Error('Invalid PGPM config: requires modulePath or workspacePath+moduleName');
+}
+async function prepareSharedPgpmSources(configs, cliOverrides) {
+    const sharedSources = new Map();
+    const pgpmTargetCount = new Map();
+    for (const name of Object.keys(configs)) {
+        const merged = { ...configs[name], ...(cliOverrides ?? {}) };
+        const pgpm = merged.db?.pgpm;
+        if (!pgpm)
+            continue;
+        const key = getPgpmSourceKey(pgpm);
+        if (!key)
+            continue;
+        pgpmTargetCount.set(key, (pgpmTargetCount.get(key) ?? 0) + 1);
+    }
+    for (const [key, count] of pgpmTargetCount) {
+        if (count < 2)
+            continue;
+        let pgpmConfig;
+        for (const name of Object.keys(configs)) {
+            const merged = { ...configs[name], ...(cliOverrides ?? {}) };
+            const pgpm = merged.db?.pgpm;
+            if (pgpm && getPgpmSourceKey(pgpm) === key) {
+                pgpmConfig = pgpm;
+                break;
+            }
+        }
+        if (!pgpmConfig)
+            continue;
+        const ephemeralDb = createEphemeralDb({
+            prefix: 'codegen_pgpm_shared_',
+            verbose: false,
+        });
+        const modulePath = getModulePathFromPgpm(pgpmConfig);
+        await deployPgpm(ephemeralDb.config, modulePath, false);
+        sharedSources.set(key, {
+            key,
+            ephemeralDb,
+            deployed: true,
+        });
+        console.log(`[multi-target] Shared PGPM source deployed once for ${count} targets: ${key}`);
+    }
+    return sharedSources;
+}
+function applySharedPgpmDb(config, sharedSources) {
+    const pgpm = config.db?.pgpm;
+    if (!pgpm)
+        return config;
+    const key = getPgpmSourceKey(pgpm);
+    if (!key)
+        return config;
+    const shared = sharedSources.get(key);
+    if (!shared)
+        return config;
+    const sharedDbConfig = {
+        ...config.db,
+        pgpm: undefined,
+        config: shared.ephemeralDb.config,
+        keepDb: true,
+    };
+    return {
+        ...config,
+        db: sharedDbConfig,
     };
 }
+export async function generateMulti(options) {
+    const { configs, cliOverrides, verbose, dryRun, schemaOnly, unifiedCli } = options;
+    const names = Object.keys(configs);
+    const results = [];
+    let hasError = false;
+    const targetInfos = [];
+    const useUnifiedCli = !schemaOnly && !!unifiedCli && names.length > 1;
+    const cliTargets = [];
+    const sharedSources = await prepareSharedPgpmSources(configs, cliOverrides);
+    try {
+        for (const name of names) {
+            const baseConfig = {
+                ...configs[name],
+                ...(cliOverrides ?? {}),
+            };
+            const targetConfig = applySharedPgpmDb(baseConfig, sharedSources);
+            const result = await generate({
+                ...targetConfig,
+                verbose,
+                dryRun,
+                schemaOnly,
+                schemaOnlyFilename: schemaOnly ? `${name}.graphql` : undefined,
+            }, useUnifiedCli ? { skipCli: true } : undefined);
+            results.push({ name, result });
+            if (!result.success) {
+                hasError = true;
+            }
+            else {
+                const resolvedConfig = getConfigOptions(targetConfig);
+                const gens = [];
+                if (resolvedConfig.reactQuery)
+                    gens.push('React Query');
+                if (resolvedConfig.orm || resolvedConfig.reactQuery || !!resolvedConfig.cli)
+                    gens.push('ORM');
+                if (resolvedConfig.cli)
+                    gens.push('CLI');
+                targetInfos.push({
+                    name,
+                    output: resolvedConfig.output,
+                    endpoint: resolvedConfig.endpoint || undefined,
+                    generators: gens,
+                });
+                if (useUnifiedCli && result.pipelineData) {
+                    const isAuthTarget = name === 'auth';
+                    cliTargets.push({
+                        name,
+                        endpoint: resolvedConfig.endpoint || '',
+                        ormImportPath: `../${resolvedConfig.output.replace(/^\.\//, '')}/orm`,
+                        tables: result.pipelineData.tables,
+                        customOperations: result.pipelineData.customOperations,
+                        isAuthTarget,
+                    });
+                }
+            }
+        }
+        if (useUnifiedCli && cliTargets.length > 0 && !dryRun) {
+            const cliConfig = typeof unifiedCli === 'object' ? unifiedCli : {};
+            const toolName = cliConfig.toolName ?? 'app';
+            const { files } = generateMultiTargetCli({
+                toolName,
+                builtinNames: cliConfig.builtinNames,
+                targets: cliTargets,
+            });
+            const cliFilesToWrite = files.map((file) => ({
+                path: path.posix.join('cli', file.fileName),
+                content: file.content,
+            }));
+            const firstTargetDocsConfig = names.length > 0 && configs[names[0]]?.docs;
+            const docsConfig = resolveDocsConfig(firstTargetDocsConfig);
+            const { resolveBuiltinNames } = await import('./codegen/cli');
+            const builtinNames = resolveBuiltinNames(cliTargets.map((t) => t.name), cliConfig.builtinNames);
+            const docsInput = {
+                toolName,
+                builtinNames,
+                targets: cliTargets.map((t) => ({
+                    name: t.name,
+                    endpoint: t.endpoint,
+                    tables: t.tables,
+                    customOperations: [
+                        ...(t.customOperations?.queries ?? []),
+                        ...(t.customOperations?.mutations ?? []),
+                    ],
+                    isAuthTarget: t.isAuthTarget,
+                })),
+            };
+            const allMcpTools = [];
+            if (docsConfig.readme) {
+                const readme = generateMultiTargetReadme(docsInput);
+                cliFilesToWrite.push({ path: path.posix.join('cli', readme.fileName), content: readme.content });
+            }
+            if (docsConfig.agents) {
+                const agents = generateMultiTargetAgentsDocs(docsInput);
+                cliFilesToWrite.push({ path: path.posix.join('cli', agents.fileName), content: agents.content });
+            }
+            if (docsConfig.mcp) {
+                allMcpTools.push(...getMultiTargetCliMcpTools(docsInput));
+            }
+            if (docsConfig.skills) {
+                for (const skill of generateMultiTargetSkills(docsInput)) {
+                    cliFilesToWrite.push({ path: path.posix.join('cli', skill.fileName), content: skill.content });
+                }
+            }
+            if (docsConfig.mcp && allMcpTools.length > 0) {
+                const mcpFile = generateCombinedMcpConfig(allMcpTools, toolName);
+                cliFilesToWrite.push({ path: path.posix.join('cli', mcpFile.fileName), content: mcpFile.content });
+            }
+            const { writeGeneratedFiles: writeFiles } = await import('./output');
+            await writeFiles(cliFilesToWrite, '.', [], { pruneStaleFiles: false });
+        }
+        // Generate root-root README if multi-target
+        if (names.length > 1 && targetInfos.length > 0 && !dryRun) {
+            const rootReadme = generateRootRootReadme(targetInfos);
+            const { writeGeneratedFiles: writeFiles } = await import('./output');
+            await writeFiles([{ path: rootReadme.fileName, content: rootReadme.content }], '.', [], { pruneStaleFiles: false });
+        }
+    }
+    finally {
+        for (const shared of sharedSources.values()) {
+            const keepDb = Object.values(configs).some((c) => c.db?.keepDb);
+            shared.ephemeralDb.teardown({ keepDb });
+        }
+    }
+    return { results, hasError };
+}

package/esm/core/index.d.ts

@@ -9,9 +9,7 @@ export { generate } from './generate';
 export * from './types';
 export * from './ast';
 export * from './custom-ast';
-/** @deprecated Legacy v4 query builder — use v5 ORM codegen instead */
 export { MetaObject, QueryBuilder } from './query-builder';
-/** @deprecated Legacy v4 meta-object utilities — v5 uses standard introspection */
 export { convertFromMetaSchema, validateMetaObject } from './meta-object';
 export * from './config';
 export * from './codegen';

package/esm/core/index.js

@@ -11,10 +11,8 @@ export * from './types';
 export * from './ast';
 export * from './custom-ast';
 // Query builder
-/** @deprecated Legacy v4 query builder — use v5 ORM codegen instead */
 export { MetaObject, QueryBuilder } from './query-builder';
 // Meta object utilities
-/** @deprecated Legacy v4 meta-object utilities — v5 uses standard introspection */
 export { convertFromMetaSchema, validateMetaObject } from './meta-object';
 // Configuration loading and resolution
 export * from './config';

package/esm/core/introspect/source/database.js

@@ -5,7 +5,7 @@
  * introspection and converts it to introspection format.
  */
 import { buildSchema, introspectionFromSchema } from 'graphql';
-import { buildSchemaSDLFromDatabase } from '../../database';
+import { buildSchemaSDL } from 'graphile-schema';
 import { createDatabasePool, resolveApiSchemas, validateServicesSchemas, } from './api-schemas';
 import { SchemaSourceError } from './types';
 /**
@@ -45,7 +45,7 @@ export class DatabaseSchemaSource {
         // Build SDL from database
         let sdl;
         try {
-            sdl = await buildSchemaSDLFromDatabase({
+            sdl = await buildSchemaSDL({
                 database,
                 schemas,
             });

package/esm/core/introspect/source/pgpm-module.js

@@ -12,7 +12,7 @@ import { buildSchema, introspectionFromSchema } from 'graphql';
 import { getPgPool } from 'pg-cache';
 import { createEphemeralDb } from 'pgsql-client';
 import { deployPgpm } from 'pgsql-seed';
-import { buildSchemaSDLFromDatabase } from '../../database';
+import { buildSchemaSDL } from 'graphile-schema';
 import { resolveApiSchemas, validateServicesSchemas } from './api-schemas';
 import { SchemaSourceError } from './types';
 /**
@@ -98,7 +98,7 @@ export class PgpmModuleSchemaSource {
             // Build SDL from the deployed database
             let sdl;
             try {
-                sdl = await buildSchemaSDLFromDatabase({
+                sdl = await buildSchemaSDL({
                     database: dbConfig.database,
                     schemas,
                 });

package/esm/core/output/index.d.ts

@@ -1,4 +1,4 @@
 /**
  * Output module exports
  */
-export { formatOutput, type GeneratedFile, writeGeneratedFiles, type WriteOptions, type WriteResult, } from './writer';
+export { type GeneratedFile, writeGeneratedFiles, type WriteOptions, type WriteResult, } from './writer';

package/esm/core/output/index.js

@@ -1,4 +1,4 @@
 /**
  * Output module exports
  */
-export { formatOutput, writeGeneratedFiles, } from './writer';
+export { writeGeneratedFiles, } from './writer';

package/esm/core/output/writer.d.ts

@@ -29,13 +29,3 @@ export interface WriteOptions {
  * @param options - Write options
  */
 export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[], options?: WriteOptions): Promise<WriteResult>;
-/**
- * Format generated files using oxfmt programmatically
- *
- * @deprecated Use writeGeneratedFiles with formatFiles option instead.
- * This function is kept for backwards compatibility.
- */
-export declare function formatOutput(outputDir: string): Promise<{
-    success: boolean;
-    error?: string;
-}>;

package/esm/core/output/writer.js

@@ -168,33 +168,3 @@ function findTsFiles(dir) {
     }
     return files;
 }
-/**
- * Format generated files using oxfmt programmatically
- *
- * @deprecated Use writeGeneratedFiles with formatFiles option instead.
- * This function is kept for backwards compatibility.
- */
-export async function formatOutput(outputDir) {
-    const formatFn = await getOxfmtFormat();
-    if (!formatFn) {
-        return {
-            success: false,
-            error: 'oxfmt not available. Install it with: npm install oxfmt',
-        };
-    }
-    const absoluteOutputDir = path.resolve(outputDir);
-    try {
-        // Find all .ts files in the output directory
-        const tsFiles = findTsFiles(absoluteOutputDir);
-        for (const filePath of tsFiles) {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const formatted = await formatFileContent(path.basename(filePath), content, formatFn);
-            fs.writeFileSync(filePath, formatted, 'utf-8');
-        }
-        return { success: true };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { success: false, error: message };
-    }
-}

package/esm/generators/index.d.ts

@@ -1,8 +1,5 @@
 /**
  * Query and mutation generator exports
- *
- * @deprecated Legacy v4 generators — use v5 ORM codegen pipeline instead.
- * These are retained for backward compatibility with existing v4 consumers.
  */
 export { convertToSelectionOptions, getAvailableRelations, isRelationalField, validateFieldSelection, } from './field-selector';
 export { buildCount, buildFindOne, buildSelect, cleanTableToMetaObject, createASTQueryBuilder, generateIntrospectionSchema, toCamelCasePlural, toOrderByTypeName, } from './select';

package/esm/generators/index.js

@@ -1,8 +1,5 @@
 /**
  * Query and mutation generator exports
- *
- * @deprecated Legacy v4 generators — use v5 ORM codegen pipeline instead.
- * These are retained for backward compatibility with existing v4 consumers.
  */
 // Field selector utilities
 export { convertToSelectionOptions, getAvailableRelations, isRelationalField, validateFieldSelection, } from './field-selector';

package/esm/index.d.ts

@@ -10,10 +10,11 @@ export * from './core';
 export * from './generators';
 export * from './client';
 export { defineConfig } from './types/config';
-export type { GenerateOptions, GenerateResult } from './core/generate';
-export { generate } from './core/generate';
+export type { GenerateOptions, GenerateResult, GenerateMultiOptions, GenerateMultiResult } from './core/generate';
+export { generate, generateMulti, expandApiNamesToMultiTarget, expandSchemaDirToMultiTarget } from './core/generate';
 export { findConfigFile, loadConfigFile } from './core/config';
+export { runCodegenHandler } from './cli/handler';
 export type { CodegenAnswers } from './cli/shared';
 export { buildDbConfig, buildGenerateOptions, camelizeArgv, codegenQuestions, filterDefined, flattenDbFields, hasResolvedCodegenSource, hyphenateKeys, normalizeCodegenListOptions, printResult, seedArgvFromConfig, splitCommas, } from './cli/shared';
 export type { BuildSchemaFromDatabaseOptions, BuildSchemaFromDatabaseResult, } from './core/database';
-export { buildSchemaFromDatabase, buildSchemaSDLFromDatabase, } from './core/database';
+export { buildSchemaFromDatabase } from './core/database';

package/esm/index.js

@@ -15,8 +15,10 @@ export * from './generators';
 export * from './client';
 // Config definition helper
 export { defineConfig } from './types/config';
-export { generate } from './core/generate';
+export { generate, generateMulti, expandApiNamesToMultiTarget, expandSchemaDirToMultiTarget } from './core/generate';
 // Config utilities
 export { findConfigFile, loadConfigFile } from './core/config';
+// CLI shared utilities (for packages/cli to import)
+export { runCodegenHandler } from './cli/handler';
 export { buildDbConfig, buildGenerateOptions, camelizeArgv, codegenQuestions, filterDefined, flattenDbFields, hasResolvedCodegenSource, hyphenateKeys, normalizeCodegenListOptions, printResult, seedArgvFromConfig, splitCommas, } from './cli/shared';
-export { buildSchemaFromDatabase, buildSchemaSDLFromDatabase, } from './core/database';
+export { buildSchemaFromDatabase } from './core/database';