@constructive-io/graphql-codegen 4.0.1 → 4.1.0

package/core/codegen/orm/docs-generator.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOrmReadme = generateOrmReadme;
+exports.generateOrmAgentsDocs = generateOrmAgentsDocs;
+exports.getOrmMcpTools = getOrmMcpTools;
+exports.generateOrmSkills = generateOrmSkills;
+const docs_utils_1 = require("../docs-utils");
+const utils_1 = require("../utils");
+function generateOrmReadme(tables, customOperations) {
+    const lines = [];
+    lines.push(...(0, docs_utils_1.getReadmeHeader)('ORM Client'));
+    lines.push('## Setup');
+    lines.push('');
+    lines.push('```typescript');
+    lines.push("import { createClient } from './orm';");
+    lines.push('');
+    lines.push('const db = createClient({');
+    lines.push("  endpoint: 'https://api.example.com/graphql',");
+    lines.push("  headers: { Authorization: 'Bearer <token>' },");
+    lines.push('});');
+    lines.push('```');
+    lines.push('');
+    lines.push('## Models');
+    lines.push('');
+    lines.push('| Model | Operations |');
+    lines.push('|-------|------------|');
+    for (const table of tables) {
+        const { singularName } = (0, utils_1.getTableNames)(table);
+        lines.push(`| \`${singularName}\` | findMany, findOne, create, update, delete |`);
+    }
+    lines.push('');
+    if (tables.length > 0) {
+        lines.push('## Table Operations');
+        lines.push('');
+        for (const table of tables) {
+            const { singularName } = (0, utils_1.getTableNames)(table);
+            const pk = (0, utils_1.getPrimaryKeyInfo)(table)[0];
+            const scalarFields = (0, utils_1.getScalarFields)(table);
+            const editableFields = (0, docs_utils_1.getEditableFields)(table);
+            lines.push(`### \`db.${singularName}\``);
+            lines.push('');
+            lines.push(`CRUD operations for ${table.name} records.`);
+            lines.push('');
+            lines.push('**Fields:**');
+            lines.push('');
+            lines.push('| Field | Type | Editable |');
+            lines.push('|-------|------|----------|');
+            for (const f of scalarFields) {
+                const editable = editableFields.some((ef) => ef.name === f.name);
+                lines.push(`| \`${f.name}\` | ${f.type.gqlType} | ${editable ? 'Yes' : 'No'} |`);
+            }
+            lines.push('');
+            lines.push('**Operations:**');
+            lines.push('');
+            lines.push('```typescript');
+            lines.push(`// List all ${singularName} records`);
+            lines.push(`const items = await db.${singularName}.findMany({ select: { ${scalarFields.map((f) => `${f.name}: true`).join(', ')} } }).execute();`);
+            lines.push('');
+            lines.push(`// Get one by ${pk.name}`);
+            lines.push(`const item = await db.${singularName}.findOne({ where: { ${pk.name}: '<value>' }, select: { ${scalarFields.map((f) => `${f.name}: true`).join(', ')} } }).execute();`);
+            lines.push('');
+            lines.push(`// Create`);
+            lines.push(`const created = await db.${singularName}.create({ data: { ${editableFields.map((f) => `${f.name}: '<value>'`).join(', ')} }, select: { ${pk.name}: true } }).execute();`);
+            lines.push('');
+            lines.push(`// Update`);
+            lines.push(`const updated = await db.${singularName}.update({ where: { ${pk.name}: '<value>' }, data: { ${editableFields[0]?.name || 'field'}: '<new-value>' }, select: { ${pk.name}: true } }).execute();`);
+            lines.push('');
+            lines.push(`// Delete`);
+            lines.push(`const deleted = await db.${singularName}.delete({ where: { ${pk.name}: '<value>' } }).execute();`);
+            lines.push('```');
+            lines.push('');
+        }
+    }
+    if (customOperations.length > 0) {
+        lines.push('## Custom Operations');
+        lines.push('');
+        for (const op of customOperations) {
+            const accessor = op.kind === 'query' ? 'query' : 'mutation';
+            lines.push(`### \`db.${accessor}.${op.name}\``);
+            lines.push('');
+            lines.push(op.description || op.name);
+            lines.push('');
+            lines.push(`- **Type:** ${op.kind}`);
+            if (op.args.length > 0) {
+                lines.push('- **Arguments:**');
+                lines.push('');
+                lines.push('  | Argument | Type |');
+                lines.push('  |----------|------|');
+                for (const arg of op.args) {
+                    lines.push(`  | \`${arg.name}\` | ${(0, docs_utils_1.formatArgType)(arg)} |`);
+                }
+                lines.push('');
+                lines.push('```typescript');
+                lines.push(`const result = await db.${accessor}.${op.name}({ ${op.args.map((a) => `${a.name}: '<value>'`).join(', ')} }).execute();`);
+                lines.push('```');
+            }
+            else {
+                lines.push('- **Arguments:** none');
+                lines.push('');
+                lines.push('```typescript');
+                lines.push(`const result = await db.${accessor}.${op.name}().execute();`);
+                lines.push('```');
+            }
+            lines.push('');
+        }
+    }
+    lines.push(...(0, docs_utils_1.getReadmeFooter)());
+    return {
+        fileName: 'README.md',
+        content: lines.join('\n'),
+    };
+}
+function generateOrmAgentsDocs(tables, customOperations) {
+    const lines = [];
+    lines.push('# ORM Client - Agent Reference');
+    lines.push('');
+    lines.push('> @generated by @constructive-io/graphql-codegen - DO NOT EDIT');
+    lines.push('> This document is structured for LLM/agent consumption.');
+    lines.push('');
+    lines.push('## OVERVIEW');
+    lines.push('');
+    lines.push('Prisma-like ORM client for interacting with a GraphQL API.');
+    lines.push('All methods return a query builder. Call `.execute()` to run the query.');
+    lines.push('');
+    lines.push('## SETUP');
+    lines.push('');
+    lines.push('```typescript');
+    lines.push("import { createClient } from './orm';");
+    lines.push('');
+    lines.push('const db = createClient({');
+    lines.push("  endpoint: 'https://api.example.com/graphql',");
+    lines.push("  headers: { Authorization: 'Bearer <token>' },");
+    lines.push('});');
+    lines.push('```');
+    lines.push('');
+    lines.push('## MODELS');
+    lines.push('');
+    for (const table of tables) {
+        const { singularName } = (0, utils_1.getTableNames)(table);
+        const pk = (0, utils_1.getPrimaryKeyInfo)(table)[0];
+        const scalarFields = (0, utils_1.getScalarFields)(table);
+        const editableFields = (0, docs_utils_1.getEditableFields)(table);
+        lines.push(`### MODEL: ${singularName}`);
+        lines.push('');
+        lines.push(`Access: \`db.${singularName}\``);
+        lines.push('');
+        lines.push('```');
+        lines.push('METHODS:');
+        lines.push(`  db.${singularName}.findMany({ select, where?, orderBy?, first?, offset? })`);
+        lines.push(`  db.${singularName}.findOne({ where: { ${pk.name} }, select })`);
+        lines.push(`  db.${singularName}.create({ data: { ${editableFields.map((f) => f.name).join(', ')} }, select })`);
+        lines.push(`  db.${singularName}.update({ where: { ${pk.name} }, data, select })`);
+        lines.push(`  db.${singularName}.delete({ where: { ${pk.name} } })`);
+        lines.push('');
+        lines.push('FIELDS:');
+        for (const f of scalarFields) {
+            const isPk = f.name === pk.name;
+            lines.push(`  ${f.name}: ${(0, utils_1.fieldTypeToTs)(f.type)}${isPk ? ' (primary key)' : ''}`);
+        }
+        lines.push('');
+        lines.push('EDITABLE FIELDS:');
+        for (const f of editableFields) {
+            lines.push(`  ${f.name}: ${(0, utils_1.fieldTypeToTs)(f.type)}`);
+        }
+        lines.push('');
+        lines.push('OUTPUT: Promise<JSON>');
+        lines.push(`  findMany: [{ ${scalarFields.map((f) => f.name).join(', ')} }]`);
+        lines.push(`  findOne:  { ${scalarFields.map((f) => f.name).join(', ')} }`);
+        lines.push(`  create:   { ${scalarFields.map((f) => f.name).join(', ')} }`);
+        lines.push(`  update:   { ${scalarFields.map((f) => f.name).join(', ')} }`);
+        lines.push(`  delete:   { ${pk.name} }`);
+        lines.push('```');
+        lines.push('');
+    }
+    if (customOperations.length > 0) {
+        lines.push('## CUSTOM OPERATIONS');
+        lines.push('');
+        for (const op of customOperations) {
+            const accessor = op.kind === 'query' ? 'query' : 'mutation';
+            lines.push(`### OPERATION: ${op.name}`);
+            lines.push('');
+            lines.push(op.description || op.name);
+            lines.push('');
+            lines.push('```');
+            lines.push(`TYPE: ${op.kind}`);
+            lines.push(`ACCESS: db.${accessor}.${op.name}`);
+            if (op.args.length > 0) {
+                lines.push(`USAGE: db.${accessor}.${op.name}({ ${op.args.map((a) => `${a.name}: <value>`).join(', ')} }).execute()`);
+                lines.push('');
+                lines.push('INPUT:');
+                for (const arg of op.args) {
+                    lines.push(`  ${arg.name}: ${(0, docs_utils_1.formatArgType)(arg)}`);
+                }
+            }
+            else {
+                lines.push(`USAGE: db.${accessor}.${op.name}().execute()`);
+                lines.push('');
+                lines.push('INPUT: none');
+            }
+            lines.push('');
+            lines.push('OUTPUT: Promise<JSON>');
+            lines.push('```');
+            lines.push('');
+        }
+    }
+    lines.push('## PATTERNS');
+    lines.push('');
+    lines.push('```typescript');
+    lines.push('// All methods require .execute() to run');
+    lines.push('const result = await db.modelName.findMany({ select: { id: true } }).execute();');
+    lines.push('');
+    lines.push('// Select specific fields');
+    lines.push('const partial = await db.modelName.findMany({ select: { id: true, name: true } }).execute();');
+    lines.push('');
+    lines.push('// Filter with where clause');
+    lines.push("const filtered = await db.modelName.findMany({ select: { id: true }, where: { name: 'test' } }).execute();");
+    lines.push('```');
+    lines.push('');
+    return {
+        fileName: 'AGENTS.md',
+        content: lines.join('\n'),
+    };
+}
+function getOrmMcpTools(tables, customOperations) {
+    const tools = [];
+    for (const table of tables) {
+        const { singularName } = (0, utils_1.getTableNames)(table);
+        const pk = (0, utils_1.getPrimaryKeyInfo)(table)[0];
+        const scalarFields = (0, utils_1.getScalarFields)(table);
+        const editableFields = (0, docs_utils_1.getEditableFields)(table);
+        tools.push({
+            name: `orm_${(0, utils_1.lcFirst)(singularName)}_findMany`,
+            description: `List all ${table.name} records via ORM`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    first: {
+                        type: 'integer',
+                        description: 'Limit number of results',
+                    },
+                    offset: {
+                        type: 'integer',
+                        description: 'Offset for pagination',
+                    },
+                },
+            },
+        });
+        tools.push({
+            name: `orm_${(0, utils_1.lcFirst)(singularName)}_findOne`,
+            description: `Get a single ${table.name} record by ${pk.name}`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    [pk.name]: {
+                        type: (0, docs_utils_1.gqlTypeToJsonSchemaType)(pk.gqlType),
+                        description: `${table.name} ${pk.name}`,
+                    },
+                },
+                required: [pk.name],
+            },
+        });
+        const createProps = {};
+        for (const f of editableFields) {
+            createProps[f.name] = {
+                type: (0, docs_utils_1.gqlTypeToJsonSchemaType)(f.type.gqlType),
+                description: `${table.name} ${f.name}`,
+            };
+        }
+        tools.push({
+            name: `orm_${(0, utils_1.lcFirst)(singularName)}_create`,
+            description: `Create a new ${table.name} record`,
+            inputSchema: {
+                type: 'object',
+                properties: createProps,
+                required: editableFields.map((f) => f.name),
+            },
+        });
+        const updateProps = {
+            [pk.name]: {
+                type: (0, docs_utils_1.gqlTypeToJsonSchemaType)(pk.gqlType),
+                description: `${table.name} ${pk.name}`,
+            },
+        };
+        for (const f of editableFields) {
+            updateProps[f.name] = {
+                type: (0, docs_utils_1.gqlTypeToJsonSchemaType)(f.type.gqlType),
+                description: `${table.name} ${f.name}`,
+            };
+        }
+        tools.push({
+            name: `orm_${(0, utils_1.lcFirst)(singularName)}_update`,
+            description: `Update an existing ${table.name} record`,
+            inputSchema: {
+                type: 'object',
+                properties: updateProps,
+                required: [pk.name],
+            },
+        });
+        tools.push({
+            name: `orm_${(0, utils_1.lcFirst)(singularName)}_delete`,
+            description: `Delete a ${table.name} record by ${pk.name}`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    [pk.name]: {
+                        type: (0, docs_utils_1.gqlTypeToJsonSchemaType)(pk.gqlType),
+                        description: `${table.name} ${pk.name}`,
+                    },
+                },
+                required: [pk.name],
+            },
+            _meta: {
+                fields: scalarFields.map((f) => ({
+                    name: f.name,
+                    type: f.type.gqlType,
+                    editable: editableFields.some((ef) => ef.name === f.name),
+                    primaryKey: f.name === pk.name,
+                })),
+            },
+        });
+    }
+    for (const op of customOperations) {
+        const accessor = op.kind === 'query' ? 'query' : 'mutation';
+        const props = {};
+        const required = [];
+        for (const arg of op.args) {
+            const isRequired = arg.type.kind === 'NON_NULL';
+            const baseType = isRequired && arg.type.ofType ? arg.type.ofType : arg.type;
+            props[arg.name] = {
+                type: (0, docs_utils_1.gqlTypeToJsonSchemaType)(baseType.name ?? 'String'),
+                description: arg.description || arg.name,
+            };
+            if (isRequired) {
+                required.push(arg.name);
+            }
+        }
+        tools.push({
+            name: `orm_${accessor}_${op.name}`,
+            description: op.description || `Execute ${op.name} ${op.kind}`,
+            inputSchema: {
+                type: 'object',
+                properties: props,
+                ...(required.length > 0 ? { required } : {}),
+            },
+        });
+    }
+    return tools;
+}
+function generateOrmSkills(tables, customOperations) {
+    const files = [];
+    for (const table of tables) {
+        const { singularName } = (0, utils_1.getTableNames)(table);
+        const pk = (0, utils_1.getPrimaryKeyInfo)(table)[0];
+        const editableFields = (0, docs_utils_1.getEditableFields)(table);
+        files.push({
+            fileName: `skills/${(0, utils_1.lcFirst)(singularName)}.md`,
+            content: (0, docs_utils_1.buildSkillFile)({
+                name: `orm-${(0, utils_1.lcFirst)(singularName)}`,
+                description: `ORM operations for ${table.name} records`,
+                language: 'typescript',
+                usage: [
+                    `db.${(0, utils_1.lcFirst)(singularName)}.findMany({ select: { id: true } }).execute()`,
+                    `db.${(0, utils_1.lcFirst)(singularName)}.findOne({ where: { ${pk.name}: '<value>' }, select: { id: true } }).execute()`,
+                    `db.${(0, utils_1.lcFirst)(singularName)}.create({ data: { ${editableFields.map((f) => `${f.name}: '<value>'`).join(', ')} }, select: { id: true } }).execute()`,
+                    `db.${(0, utils_1.lcFirst)(singularName)}.update({ where: { ${pk.name}: '<value>' }, data: { ${editableFields[0]?.name || 'field'}: '<new>' }, select: { id: true } }).execute()`,
+                    `db.${(0, utils_1.lcFirst)(singularName)}.delete({ where: { ${pk.name}: '<value>' } }).execute()`,
+                ],
+                examples: [
+                    {
+                        description: `List all ${singularName} records`,
+                        code: [
+                            `const items = await db.${(0, utils_1.lcFirst)(singularName)}.findMany({`,
+                            `  select: { ${pk.name}: true, ${editableFields[0]?.name || 'name'}: true }`,
+                            '}).execute();',
+                        ],
+                    },
+                    {
+                        description: `Create a ${singularName}`,
+                        code: [
+                            `const item = await db.${(0, utils_1.lcFirst)(singularName)}.create({`,
+                            `  data: { ${editableFields.map((f) => `${f.name}: 'value'`).join(', ')} },`,
+                            `  select: { ${pk.name}: true }`,
+                            '}).execute();',
+                        ],
+                    },
+                ],
+            }),
+        });
+    }
+    for (const op of customOperations) {
+        const accessor = op.kind === 'query' ? 'query' : 'mutation';
+        const callArgs = op.args.length > 0
+            ? `{ ${op.args.map((a) => `${a.name}: '<value>'`).join(', ')} }`
+            : '';
+        files.push({
+            fileName: `skills/${op.name}.md`,
+            content: (0, docs_utils_1.buildSkillFile)({
+                name: `orm-${op.name}`,
+                description: op.description || `Execute the ${op.name} ${op.kind}`,
+                language: 'typescript',
+                usage: [
+                    `db.${accessor}.${op.name}(${callArgs}).execute()`,
+                ],
+                examples: [
+                    {
+                        description: `Run ${op.name}`,
+                        code: [
+                            `const result = await db.${accessor}.${op.name}(${callArgs}).execute();`,
+                        ],
+                    },
+                ],
+            }),
+        });
+    }
+    return files;
+}

package/core/codegen/target-docs-generator.d.ts

@@ -0,0 +1,20 @@
+import type { GraphQLSDKConfigTarget } from '../../types/config';
+import type { GeneratedDocFile, McpTool } from './docs-utils';
+export interface TargetReadmeOptions {
+    hasOrm: boolean;
+    hasHooks: boolean;
+    hasCli: boolean;
+    tableCount: number;
+    customQueryCount: number;
+    customMutationCount: number;
+    config: GraphQLSDKConfigTarget;
+}
+export declare function generateTargetReadme(options: TargetReadmeOptions): GeneratedDocFile;
+export declare function generateCombinedMcpConfig(tools: McpTool[], name: string): GeneratedDocFile;
+export interface RootRootReadmeTarget {
+    name: string;
+    output: string;
+    endpoint?: string;
+    generators: string[];
+}
+export declare function generateRootRootReadme(targets: RootRootReadmeTarget[]): GeneratedDocFile;

package/core/codegen/target-docs-generator.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTargetReadme = generateTargetReadme;
+exports.generateCombinedMcpConfig = generateCombinedMcpConfig;
+exports.generateRootRootReadme = generateRootRootReadme;
+const docs_utils_1 = require("./docs-utils");
+function generateTargetReadme(options) {
+    const { hasOrm, hasHooks, hasCli, tableCount, customQueryCount, customMutationCount, config, } = options;
+    const lines = [];
+    lines.push(...(0, docs_utils_1.getReadmeHeader)('Generated GraphQL SDK'));
+    lines.push('## Overview');
+    lines.push('');
+    lines.push(`- **Tables:** ${tableCount}`);
+    lines.push(`- **Custom queries:** ${customQueryCount}`);
+    lines.push(`- **Custom mutations:** ${customMutationCount}`);
+    lines.push('');
+    const generators = [];
+    if (hasOrm)
+        generators.push('ORM');
+    if (hasHooks)
+        generators.push('React Query');
+    if (hasCli)
+        generators.push('CLI');
+    lines.push(`**Generators:** ${generators.join(', ')}`);
+    lines.push('');
+    if (config.endpoint) {
+        lines.push(`**Endpoint:** \`${config.endpoint}\``);
+        lines.push('');
+    }
+    lines.push('## Modules');
+    lines.push('');
+    if (hasOrm) {
+        lines.push('### ORM Client (`./orm`)');
+        lines.push('');
+        lines.push('Prisma-like ORM client for programmatic GraphQL access.');
+        lines.push('');
+        lines.push('```typescript');
+        lines.push("import { createClient } from './orm';");
+        lines.push('');
+        lines.push('const db = createClient({');
+        lines.push("  endpoint: 'https://api.example.com/graphql',");
+        lines.push('});');
+        lines.push('```');
+        lines.push('');
+        lines.push('See [orm/README.md](./orm/README.md) for full API reference.');
+        lines.push('');
+    }
+    if (hasHooks) {
+        lines.push('### React Query Hooks (`./hooks`)');
+        lines.push('');
+        lines.push('Type-safe React Query hooks for data fetching and mutations.');
+        lines.push('');
+        lines.push('```typescript');
+        lines.push("import { configure } from './hooks';");
+        lines.push("import { useCarsQuery } from './hooks';");
+        lines.push('');
+        lines.push("configure({ endpoint: 'https://api.example.com/graphql' });");
+        lines.push('```');
+        lines.push('');
+        lines.push('See [hooks/README.md](./hooks/README.md) for full hook reference.');
+        lines.push('');
+    }
+    if (hasCli) {
+        const toolName = typeof config.cli === 'object' && config.cli?.toolName
+            ? config.cli.toolName
+            : 'app';
+        lines.push(`### CLI Commands (\`./cli\`)`);
+        lines.push('');
+        lines.push(`inquirerer-based CLI commands for \`${toolName}\`.`);
+        lines.push('');
+        lines.push('See [cli/README.md](./cli/README.md) for command reference.');
+        lines.push('');
+    }
+    lines.push(...(0, docs_utils_1.getReadmeFooter)());
+    return {
+        fileName: 'README.md',
+        content: lines.join('\n'),
+    };
+}
+function generateCombinedMcpConfig(tools, name) {
+    const mcpConfig = {
+        name,
+        version: '1.0.0',
+        description: `MCP tool definitions for ${name} SDK (auto-generated from GraphQL schema)`,
+        tools,
+    };
+    return {
+        fileName: 'mcp.json',
+        content: JSON.stringify(mcpConfig, null, 2) + '\n',
+    };
+}
+function generateRootRootReadme(targets) {
+    const lines = [];
+    lines.push(...(0, docs_utils_1.getReadmeHeader)('GraphQL SDK'));
+    lines.push('## APIs');
+    lines.push('');
+    lines.push('| API | Endpoint | Generators | Docs |');
+    lines.push('|-----|----------|------------|------|');
+    for (const target of targets) {
+        const endpoint = target.endpoint || '-';
+        const gens = target.generators.join(', ');
+        lines.push(`| ${target.name} | ${endpoint} | ${gens} | [${target.output}/README.md](${target.output}/README.md) |`);
+    }
+    lines.push('');
+    lines.push(...(0, docs_utils_1.getReadmeFooter)());
+    return {
+        fileName: 'README.md',
+        content: lines.join('\n'),
+    };
+}

package/core/database/index.d.ts

@@ -29,15 +29,3 @@ export interface BuildSchemaFromDatabaseResult {
  * @returns The path to the generated schema file and the SDL content
  */
 export declare function buildSchemaFromDatabase(options: BuildSchemaFromDatabaseOptions): Promise<BuildSchemaFromDatabaseResult>;
-/**
- * Build a GraphQL schema SDL string from a PostgreSQL database without writing to file.
- *
- * This is a convenience wrapper around buildSchemaSDL from graphql-server.
- *
- * @param options - Configuration options
- * @returns The SDL content as a string
- */
-export declare function buildSchemaSDLFromDatabase(options: {
-    database: string;
-    schemas: string[];
-}): Promise<string>;

package/core/database/index.js

@@ -39,10 +39,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSchemaFromDatabase = buildSchemaFromDatabase;
-exports.buildSchemaSDLFromDatabase = buildSchemaSDLFromDatabase;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const graphql_server_1 = require("@constructive-io/graphql-server");
+const graphile_schema_1 = require("graphile-schema");
 /**
  * Build a GraphQL schema from a PostgreSQL database and write it to a file.
  *
@@ -57,7 +56,7 @@ async function buildSchemaFromDatabase(options) {
     // Ensure output directory exists
     await fs.promises.mkdir(outDir, { recursive: true });
     // Build schema SDL from database (PostGraphile v5 preset-driven settings)
-    const sdl = await (0, graphql_server_1.buildSchemaSDL)({
+    const sdl = await (0, graphile_schema_1.buildSchemaSDL)({
         database,
         schemas,
     });
@@ -66,19 +65,3 @@ async function buildSchemaFromDatabase(options) {
     await fs.promises.writeFile(schemaPath, sdl, 'utf-8');
     return { schemaPath, sdl };
 }
-/**
- * Build a GraphQL schema SDL string from a PostgreSQL database without writing to file.
- *
- * This is a convenience wrapper around buildSchemaSDL from graphql-server.
- *
- * @param options - Configuration options
- * @returns The SDL content as a string
- */
-async function buildSchemaSDLFromDatabase(options) {
-    const { database, schemas } = options;
-    // PostGraphile v5 resolves role/settings via preset configuration.
-    return (0, graphql_server_1.buildSchemaSDL)({
-        database,
-        schemas,
-    });
-}

package/core/generate.d.ts

@@ -1,9 +1,13 @@
-import type { GraphQLSDKConfigTarget } from '../types/config';
+import type { CliConfig, GraphQLSDKConfigTarget } from '../types/config';
+import type { CleanOperation, CleanTable } from '../types/schema';
 export interface GenerateOptions extends GraphQLSDKConfigTarget {
     authorization?: string;
     verbose?: boolean;
     dryRun?: boolean;
     skipCustomOperations?: boolean;
+    schemaOnly?: boolean;
+    schemaOnlyOutput?: string;
+    schemaOnlyFilename?: string;
 }
 export interface GenerateResult {
     success: boolean;
@@ -12,6 +16,13 @@ export interface GenerateResult {
     tables?: string[];
     filesWritten?: string[];
     errors?: string[];
+    pipelineData?: {
+        tables: CleanTable[];
+        customOperations: {
+            queries: CleanOperation[];
+            mutations: CleanOperation[];
+        };
+    };
 }
 /**
  * Main generate function - takes a single config and generates code
@@ -19,4 +30,25 @@ export interface GenerateResult {
  * This is the primary entry point for programmatic usage.
  * For multiple configs, call this function in a loop.
  */
-export declare function generate(options?: GenerateOptions): Promise<GenerateResult>;
+export interface GenerateInternalOptions {
+    skipCli?: boolean;
+}
+export declare function generate(options?: GenerateOptions, internalOptions?: GenerateInternalOptions): Promise<GenerateResult>;
+export declare function expandApiNamesToMultiTarget(config: GraphQLSDKConfigTarget): Record<string, GraphQLSDKConfigTarget> | null;
+export declare function expandSchemaDirToMultiTarget(config: GraphQLSDKConfigTarget): Record<string, GraphQLSDKConfigTarget> | null;
+export interface GenerateMultiOptions {
+    configs: Record<string, GraphQLSDKConfigTarget>;
+    cliOverrides?: Partial<GraphQLSDKConfigTarget>;
+    verbose?: boolean;
+    dryRun?: boolean;
+    schemaOnly?: boolean;
+    unifiedCli?: CliConfig | boolean;
+}
+export interface GenerateMultiResult {
+    results: Array<{
+        name: string;
+        result: GenerateResult;
+    }>;
+    hasError: boolean;
+}
+export declare function generateMulti(options: GenerateMultiOptions): Promise<GenerateMultiResult>;