@constructive-io/graphql-codegen 4.0.1 → 4.1.0

package/core/generate.js

@@ -1,31 +1,72 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generate = generate;
+exports.expandApiNamesToMultiTarget = expandApiNamesToMultiTarget;
+exports.expandSchemaDirToMultiTarget = expandSchemaDirToMultiTarget;
+exports.generateMulti = generateMulti;
 /**
  * Main generate function - orchestrates the entire codegen pipeline
  *
  * This is the primary entry point for programmatic usage.
  * The CLI is a thin wrapper around this function.
  */
+const fs = __importStar(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const graphql_1 = require("graphql");
+const core_1 = require("@pgpmjs/core");
+const pgsql_client_1 = require("pgsql-client");
+const pgsql_seed_1 = require("pgsql-seed");
 const config_1 = require("../types/config");
 const codegen_1 = require("./codegen");
 const barrel_1 = require("./codegen/barrel");
+const cli_1 = require("./codegen/cli");
+const docs_generator_1 = require("./codegen/cli/docs-generator");
+const docs_utils_1 = require("./codegen/docs-utils");
+const hooks_docs_generator_1 = require("./codegen/hooks-docs-generator");
 const orm_1 = require("./codegen/orm");
+const docs_generator_2 = require("./codegen/orm/docs-generator");
 const shared_1 = require("./codegen/shared");
+const target_docs_generator_1 = require("./codegen/target-docs-generator");
 const introspect_1 = require("./introspect");
 const output_1 = require("./output");
 const pipeline_1 = require("./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.
- */
-async function generate(options = {}) {
+async function generate(options = {}, internalOptions) {
     // Apply defaults to get resolved config
     const config = (0, config_1.getConfigOptions)(options);
     const outputRoot = config.output;
@@ -33,11 +74,12 @@ 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,
         };
     }
@@ -61,6 +103,39 @@ 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 = (0, graphql_1.buildClientSchema)(introspection);
+            const sdl = (0, graphql_1.printSchema)(schema);
+            if (!sdl.trim()) {
+                return {
+                    success: false,
+                    message: 'Schema introspection returned empty SDL.',
+                    output: outputRoot,
+                };
+            }
+            const outDir = node_path_1.default.resolve(options.schemaOnlyOutput || outputRoot || '.');
+            await fs.promises.mkdir(outDir, { recursive: true });
+            const filename = options.schemaOnlyFilename || 'schema.graphql';
+            const filePath = node_path_1.default.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 {
@@ -142,14 +217,115 @@ async function generate(options = {}) {
             path: node_path_1.default.posix.join('orm', file.path),
         })));
     }
+    // Generate CLI commands
+    if (runCli) {
+        console.log('Generating CLI commands...');
+        const { files } = (0, cli_1.generateCli)({
+            tables,
+            customOperations: {
+                queries: customOperations.queries,
+                mutations: customOperations.mutations,
+            },
+            config,
+        });
+        filesToWrite.push(...files.map((file) => ({
+            path: node_path_1.default.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 = (0, barrel_1.generateRootBarrel)({
         hasTypes: bothEnabled,
         hasHooks: runReactQuery,
         hasOrm: runOrm,
+        hasCli: runCli,
     });
     filesToWrite.push({ path: 'index.ts', content: barrelContent });
+    // Generate docs for each enabled generator
+    const docsConfig = (0, docs_utils_1.resolveDocsConfig)(config.docs);
+    const allCustomOps = [
+        ...(customOperations.queries ?? []),
+        ...(customOperations.mutations ?? []),
+    ];
+    const allMcpTools = [];
+    if (runOrm) {
+        if (docsConfig.readme) {
+            const readme = (0, docs_generator_2.generateOrmReadme)(tables, allCustomOps);
+            filesToWrite.push({ path: node_path_1.default.posix.join('orm', readme.fileName), content: readme.content });
+        }
+        if (docsConfig.agents) {
+            const agents = (0, docs_generator_2.generateOrmAgentsDocs)(tables, allCustomOps);
+            filesToWrite.push({ path: node_path_1.default.posix.join('orm', agents.fileName), content: agents.content });
+        }
+        if (docsConfig.mcp) {
+            allMcpTools.push(...(0, docs_generator_2.getOrmMcpTools)(tables, allCustomOps));
+        }
+        if (docsConfig.skills) {
+            for (const skill of (0, docs_generator_2.generateOrmSkills)(tables, allCustomOps)) {
+                filesToWrite.push({ path: node_path_1.default.posix.join('orm', skill.fileName), content: skill.content });
+            }
+        }
+    }
+    if (runReactQuery) {
+        if (docsConfig.readme) {
+            const readme = (0, hooks_docs_generator_1.generateHooksReadme)(tables, allCustomOps);
+            filesToWrite.push({ path: node_path_1.default.posix.join('hooks', readme.fileName), content: readme.content });
+        }
+        if (docsConfig.agents) {
+            const agents = (0, hooks_docs_generator_1.generateHooksAgentsDocs)(tables, allCustomOps);
+            filesToWrite.push({ path: node_path_1.default.posix.join('hooks', agents.fileName), content: agents.content });
+        }
+        if (docsConfig.mcp) {
+            allMcpTools.push(...(0, hooks_docs_generator_1.getHooksMcpTools)(tables, allCustomOps));
+        }
+        if (docsConfig.skills) {
+            for (const skill of (0, hooks_docs_generator_1.generateHooksSkills)(tables, allCustomOps)) {
+                filesToWrite.push({ path: node_path_1.default.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 = (0, docs_generator_1.generateReadme)(tables, allCustomOps, toolName);
+            filesToWrite.push({ path: node_path_1.default.posix.join('cli', readme.fileName), content: readme.content });
+        }
+        if (docsConfig.agents) {
+            const agents = (0, docs_generator_1.generateAgentsDocs)(tables, allCustomOps, toolName);
+            filesToWrite.push({ path: node_path_1.default.posix.join('cli', agents.fileName), content: agents.content });
+        }
+        if (docsConfig.mcp) {
+            allMcpTools.push(...(0, docs_generator_1.getCliMcpTools)(tables, allCustomOps, toolName));
+        }
+        if (docsConfig.skills) {
+            for (const skill of (0, docs_generator_1.generateSkills)(tables, allCustomOps, toolName)) {
+                filesToWrite.push({ path: node_path_1.default.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 = (0, target_docs_generator_1.generateCombinedMcpConfig)(allMcpTools, mcpName);
+        filesToWrite.push({ path: mcpFile.fileName, content: mcpFile.content });
+    }
+    // Generate per-target README at output root
+    if (docsConfig.readme) {
+        const targetReadme = (0, target_docs_generator_1.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 (0, output_1.writeGeneratedFiles)(filesToWrite, outputRoot, [], {
             pruneStaleFiles: true,
@@ -164,7 +340,11 @@ 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 {
@@ -175,5 +355,266 @@ async function generate(options = {}) {
         output: outputRoot,
         tables: tables.map((t) => t.name),
         filesWritten: allFilesWritten,
+        pipelineData: {
+            tables,
+            customOperations: {
+                queries: customOperations.queries,
+                mutations: customOperations.mutations,
+            },
+        },
+    };
+}
+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;
+}
+function expandSchemaDirToMultiTarget(config) {
+    const schemaDir = config.schemaDir;
+    if (!schemaDir)
+        return null;
+    const resolvedDir = node_path_1.default.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 = node_path_1.default.basename(file, '.graphql');
+        targets[name] = {
+            ...config,
+            schemaDir: undefined,
+            schemaFile: node_path_1.default.join(resolvedDir, file),
+            output: config.output
+                ? `${config.output}/${name}`
+                : `./generated/graphql/${name}`,
+        };
+    }
+    return targets;
+}
+function getPgpmSourceKey(pgpm) {
+    if (pgpm.modulePath)
+        return `module:${node_path_1.default.resolve(pgpm.modulePath)}`;
+    if (pgpm.workspacePath && pgpm.moduleName)
+        return `workspace:${node_path_1.default.resolve(pgpm.workspacePath)}:${pgpm.moduleName}`;
+    return null;
+}
+function getModulePathFromPgpm(pgpm) {
+    if (pgpm.modulePath)
+        return pgpm.modulePath;
+    if (pgpm.workspacePath && pgpm.moduleName) {
+        const workspace = new core_1.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 = (0, pgsql_client_1.createEphemeralDb)({
+            prefix: 'codegen_pgpm_shared_',
+            verbose: false,
+        });
+        const modulePath = getModulePathFromPgpm(pgpmConfig);
+        await (0, pgsql_seed_1.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,
     };
 }
+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 = (0, config_1.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 } = (0, cli_1.generateMultiTargetCli)({
+                toolName,
+                builtinNames: cliConfig.builtinNames,
+                targets: cliTargets,
+            });
+            const cliFilesToWrite = files.map((file) => ({
+                path: node_path_1.default.posix.join('cli', file.fileName),
+                content: file.content,
+            }));
+            const firstTargetDocsConfig = names.length > 0 && configs[names[0]]?.docs;
+            const docsConfig = (0, docs_utils_1.resolveDocsConfig)(firstTargetDocsConfig);
+            const { resolveBuiltinNames } = await Promise.resolve().then(() => __importStar(require('./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 = (0, docs_generator_1.generateMultiTargetReadme)(docsInput);
+                cliFilesToWrite.push({ path: node_path_1.default.posix.join('cli', readme.fileName), content: readme.content });
+            }
+            if (docsConfig.agents) {
+                const agents = (0, docs_generator_1.generateMultiTargetAgentsDocs)(docsInput);
+                cliFilesToWrite.push({ path: node_path_1.default.posix.join('cli', agents.fileName), content: agents.content });
+            }
+            if (docsConfig.mcp) {
+                allMcpTools.push(...(0, docs_generator_1.getMultiTargetCliMcpTools)(docsInput));
+            }
+            if (docsConfig.skills) {
+                for (const skill of (0, docs_generator_1.generateMultiTargetSkills)(docsInput)) {
+                    cliFilesToWrite.push({ path: node_path_1.default.posix.join('cli', skill.fileName), content: skill.content });
+                }
+            }
+            if (docsConfig.mcp && allMcpTools.length > 0) {
+                const mcpFile = (0, target_docs_generator_1.generateCombinedMcpConfig)(allMcpTools, toolName);
+                cliFilesToWrite.push({ path: node_path_1.default.posix.join('cli', mcpFile.fileName), content: mcpFile.content });
+            }
+            const { writeGeneratedFiles: writeFiles } = await Promise.resolve().then(() => __importStar(require('./output')));
+            await writeFiles(cliFilesToWrite, '.', [], { pruneStaleFiles: false });
+        }
+        // Generate root-root README if multi-target
+        if (names.length > 1 && targetInfos.length > 0 && !dryRun) {
+            const rootReadme = (0, target_docs_generator_1.generateRootRootReadme)(targetInfos);
+            const { writeGeneratedFiles: writeFiles } = await Promise.resolve().then(() => __importStar(require('./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/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/core/index.js

@@ -29,12 +29,10 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./ast"), exports);
 __exportStar(require("./custom-ast"), exports);
 // Query builder
-/** @deprecated Legacy v4 query builder — use v5 ORM codegen instead */
 var query_builder_1 = require("./query-builder");
 Object.defineProperty(exports, "MetaObject", { enumerable: true, get: function () { return query_builder_1.MetaObject; } });
 Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return query_builder_1.QueryBuilder; } });
 // Meta object utilities
-/** @deprecated Legacy v4 meta-object utilities — v5 uses standard introspection */
 var meta_object_1 = require("./meta-object");
 Object.defineProperty(exports, "convertFromMetaSchema", { enumerable: true, get: function () { return meta_object_1.convertFromMetaSchema; } });
 Object.defineProperty(exports, "validateMetaObject", { enumerable: true, get: function () { return meta_object_1.validateMetaObject; } });

package/core/introspect/source/database.js

@@ -8,7 +8,7 @@ exports.DatabaseSchemaSource = void 0;
  * introspection and converts it to introspection format.
  */
 const graphql_1 = require("graphql");
-const database_1 = require("../../database");
+const graphile_schema_1 = require("graphile-schema");
 const api_schemas_1 = require("./api-schemas");
 const types_1 = require("./types");
 /**
@@ -48,7 +48,7 @@ class DatabaseSchemaSource {
         // Build SDL from database
         let sdl;
         try {
-            sdl = await (0, database_1.buildSchemaSDLFromDatabase)({
+            sdl = await (0, graphile_schema_1.buildSchemaSDL)({
                 database,
                 schemas,
             });

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

@@ -17,7 +17,7 @@ const graphql_1 = require("graphql");
 const pg_cache_1 = require("pg-cache");
 const pgsql_client_1 = require("pgsql-client");
 const pgsql_seed_1 = require("pgsql-seed");
-const database_1 = require("../../database");
+const graphile_schema_1 = require("graphile-schema");
 const api_schemas_1 = require("./api-schemas");
 const types_1 = require("./types");
 /**
@@ -103,7 +103,7 @@ class PgpmModuleSchemaSource {
             // Build SDL from the deployed database
             let sdl;
             try {
-                sdl = await (0, database_1.buildSchemaSDLFromDatabase)({
+                sdl = await (0, graphile_schema_1.buildSchemaSDL)({
                     database: dbConfig.database,
                     schemas,
                 });

package/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/core/output/index.js

@@ -3,7 +3,6 @@
  * Output module exports
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeGeneratedFiles = exports.formatOutput = void 0;
+exports.writeGeneratedFiles = void 0;
 var writer_1 = require("./writer");
-Object.defineProperty(exports, "formatOutput", { enumerable: true, get: function () { return writer_1.formatOutput; } });
 Object.defineProperty(exports, "writeGeneratedFiles", { enumerable: true, get: function () { return writer_1.writeGeneratedFiles; } });

package/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/core/output/writer.js

@@ -34,7 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeGeneratedFiles = writeGeneratedFiles;
-exports.formatOutput = formatOutput;
 /**
  * File writing utilities
  *
@@ -205,33 +204,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.
- */
-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/cli/handler.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared codegen CLI handler
+ *
+ * Contains the core logic used by both `graphql-codegen` and `cnc codegen`.
+ * Both CLIs delegate to runCodegenHandler() after handling their own
+ * help/version flags.
+ */
+import type { Question } from 'inquirerer';
+interface Prompter {
+    prompt(argv: Record<string, unknown>, questions: Question[]): Promise<Record<string, unknown>>;
+}
+export declare function runCodegenHandler(argv: Record<string, unknown>, prompter: Prompter): Promise<void>;
+export {};