@constructive-io/graphql-codegen 2.24.0 → 2.26.0

package/esm/cli/commands/generate-orm.js

@@ -6,7 +6,7 @@
  * 2. Infers table metadata from introspection (replaces _meta)
  * 3. Generates a Prisma-like ORM client with fluent API
  */
-import { resolveConfig } from '../../types/config';
+import { isMultiConfig, mergeConfig, resolveConfig } from '../../types/config';
 import { createSchemaSource, validateSourceOptions, } from '../introspect/source';
 import { runCodegenPipeline, validateTablesFound } from './shared';
 import { findConfigFile, loadConfigFile } from './init';
@@ -16,9 +16,9 @@ import { generateOrm } from '../codegen/orm';
  * Execute the generate-orm command
  */
 export async function generateOrmCommand(options = {}) {
-    const log = options.verbose ? console.log : () => { };
-    // 1. Load config
-    log('Loading configuration...');
+    if (options.verbose) {
+        console.log('Loading configuration...');
+    }
     const configResult = await loadConfig(options);
     if (!configResult.success) {
         return {
@@ -26,26 +26,73 @@ export async function generateOrmCommand(options = {}) {
             message: configResult.error,
         };
     }
-    const config = configResult.config;
-    // Use ORM output directory if specified, otherwise default
-    const outputDir = options.output || config.orm?.output || './generated/orm';
-    // Log source
-    if (config.schema) {
-        log(`  Schema: ${config.schema}`);
+    const targets = configResult.targets ?? [];
+    if (targets.length === 0) {
+        return {
+            success: false,
+            message: 'No targets resolved from configuration.',
+        };
+    }
+    const isMultiTarget = configResult.isMulti ?? targets.length > 1;
+    const results = [];
+    for (const target of targets) {
+        const result = await generateOrmForTarget(target, options, isMultiTarget);
+        results.push(result);
+    }
+    if (!isMultiTarget) {
+        const [result] = results;
+        return {
+            success: result.success,
+            message: result.message,
+            targets: results,
+            tables: result.tables,
+            customQueries: result.customQueries,
+            customMutations: result.customMutations,
+            filesWritten: result.filesWritten,
+            errors: result.errors,
+        };
     }
-    else {
-        log(`  Endpoint: ${config.endpoint}`);
+    const successCount = results.filter((result) => result.success).length;
+    const failedCount = results.length - successCount;
+    const summaryMessage = failedCount === 0
+        ? `Generated ORM clients for ${results.length} targets.`
+        : `Generated ORM clients for ${successCount} of ${results.length} targets.`;
+    return {
+        success: failedCount === 0,
+        message: summaryMessage,
+        targets: results,
+        errors: failedCount > 0
+            ? results.flatMap((result) => result.errors ?? [])
+            : undefined,
+    };
+}
+async function generateOrmForTarget(target, options, isMultiTarget) {
+    const config = target.config;
+    const outputDir = options.output || config.orm?.output || './generated/orm';
+    const prefix = isMultiTarget ? `[${target.name}] ` : '';
+    const log = options.verbose
+        ? (message) => console.log(`${prefix}${message}`)
+        : () => { };
+    const formatMessage = (message) => isMultiTarget ? `Target "${target.name}": ${message}` : message;
+    if (isMultiTarget) {
+        console.log(`\nTarget "${target.name}"`);
+        const sourceLabel = config.schema
+            ? `schema: ${config.schema}`
+            : `endpoint: ${config.endpoint}`;
+        console.log(`  Source: ${sourceLabel}`);
+        console.log(`  Output: ${outputDir}`);
     }
-    log(`  Output: ${outputDir}`);
-    // 2. Create schema source
+    // 1. Validate source
     const sourceValidation = validateSourceOptions({
         endpoint: config.endpoint || undefined,
         schema: config.schema || undefined,
     });
     if (!sourceValidation.valid) {
         return {
+            name: target.name,
+            output: outputDir,
             success: false,
-            message: sourceValidation.error,
+            message: formatMessage(sourceValidation.error),
         };
     }
     const source = createSchemaSource({
@@ -54,7 +101,7 @@ export async function generateOrmCommand(options = {}) {
         authorization: options.authorization || config.headers['Authorization'],
         headers: config.headers,
     });
-    // 3. Run the codegen pipeline
+    // 2. Run the codegen pipeline
     let pipelineResult;
     try {
         pipelineResult = await runCodegenPipeline({
@@ -66,21 +113,25 @@ export async function generateOrmCommand(options = {}) {
     }
     catch (err) {
         return {
+            name: target.name,
+            output: outputDir,
             success: false,
-            message: `Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`,
+            message: formatMessage(`Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`),
         };
     }
     const { tables, customOperations, stats } = pipelineResult;
-    // 4. Validate tables found
+    // 3. Validate tables found
     const tablesValidation = validateTablesFound(tables);
     if (!tablesValidation.valid) {
         return {
+            name: target.name,
+            output: outputDir,
             success: false,
-            message: tablesValidation.error,
+            message: formatMessage(tablesValidation.error),
         };
     }
-    // 5. Generate ORM code
-    console.log('Generating code...');
+    // 4. Generate ORM code
+    console.log(`${prefix}Generating code...`);
     const { files: generatedFiles, stats: genStats } = generateOrm({
         tables,
         customOperations: {
@@ -90,7 +141,7 @@ export async function generateOrmCommand(options = {}) {
         },
         config,
     });
-    console.log(`Generated ${genStats.totalFiles} files`);
+    console.log(`${prefix}Generated ${genStats.totalFiles} files`);
     log(`  ${genStats.tables} table models`);
     log(`  ${genStats.customQueries} custom query operations`);
     log(`  ${genStats.customMutations} custom mutation operations`);
@@ -98,15 +149,17 @@ export async function generateOrmCommand(options = {}) {
     const customMutations = customOperations.mutations.map((m) => m.name);
     if (options.dryRun) {
         return {
+            name: target.name,
+            output: outputDir,
             success: true,
-            message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`,
+            message: formatMessage(`Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`),
             tables: tables.map((t) => t.name),
             customQueries,
             customMutations,
             filesWritten: generatedFiles.map((f) => f.path),
         };
     }
-    // 6. Write files
+    // 5. Write files
     log('Writing files...');
     const writeResult = await writeGeneratedFiles(generatedFiles, outputDir, [
         'models',
@@ -115,23 +168,45 @@ export async function generateOrmCommand(options = {}) {
     ]);
     if (!writeResult.success) {
         return {
+            name: target.name,
+            output: outputDir,
             success: false,
-            message: `Failed to write files: ${writeResult.errors?.join(', ')}`,
+            message: formatMessage(`Failed to write files: ${writeResult.errors?.join(', ')}`),
             errors: writeResult.errors,
         };
     }
     const totalOps = customQueries.length + customMutations.length;
     const customOpsMsg = totalOps > 0 ? ` and ${totalOps} custom operations` : '';
     return {
+        name: target.name,
+        output: outputDir,
         success: true,
-        message: `Generated ORM client for ${tables.length} tables${customOpsMsg}. Files written to ${outputDir}`,
+        message: formatMessage(`Generated ORM client for ${tables.length} tables${customOpsMsg}. Files written to ${outputDir}`),
         tables: tables.map((t) => t.name),
         customQueries,
         customMutations,
         filesWritten: writeResult.filesWritten,
     };
 }
+function buildTargetOverrides(options) {
+    const overrides = {};
+    if (options.endpoint) {
+        overrides.endpoint = options.endpoint;
+        overrides.schema = undefined;
+    }
+    if (options.schema) {
+        overrides.schema = options.schema;
+        overrides.endpoint = undefined;
+    }
+    return overrides;
+}
 async function loadConfig(options) {
+    if (options.endpoint && options.schema) {
+        return {
+            success: false,
+            error: 'Cannot use both --endpoint and --schema. Choose one source.',
+        };
+    }
     // Find config file
     let configPath = options.config;
     if (!configPath) {
@@ -145,29 +220,70 @@ async function loadConfig(options) {
         }
         baseConfig = loadResult.config;
     }
-    // Override with CLI options
-    const mergedConfig = {
-        endpoint: options.endpoint || baseConfig.endpoint,
-        schema: options.schema || baseConfig.schema,
-        output: options.output || baseConfig.output,
-        headers: baseConfig.headers,
-        tables: baseConfig.tables,
-        queries: baseConfig.queries,
-        mutations: baseConfig.mutations,
-        excludeFields: baseConfig.excludeFields,
-        hooks: baseConfig.hooks,
-        postgraphile: baseConfig.postgraphile,
-        codegen: baseConfig.codegen,
-        orm: baseConfig.orm,
-    };
-    // Validate at least one source is provided
+    const overrides = buildTargetOverrides(options);
+    if (isMultiConfig(baseConfig)) {
+        if (Object.keys(baseConfig.targets).length === 0) {
+            return {
+                success: false,
+                error: 'Config file defines no targets.',
+            };
+        }
+        if (!options.target &&
+            (options.endpoint || options.schema || options.output)) {
+            return {
+                success: false,
+                error: 'Multiple targets configured. Use --target with --endpoint, --schema, or --output.',
+            };
+        }
+        if (options.target && !baseConfig.targets[options.target]) {
+            return {
+                success: false,
+                error: `Target "${options.target}" not found in config file.`,
+            };
+        }
+        const selectedTargets = options.target
+            ? { [options.target]: baseConfig.targets[options.target] }
+            : baseConfig.targets;
+        const defaults = baseConfig.defaults ?? {};
+        const resolvedTargets = [];
+        for (const [name, target] of Object.entries(selectedTargets)) {
+            let mergedTarget = mergeConfig(defaults, target);
+            if (options.target && name === options.target) {
+                mergedTarget = mergeConfig(mergedTarget, overrides);
+            }
+            if (!mergedTarget.endpoint && !mergedTarget.schema) {
+                return {
+                    success: false,
+                    error: `Target "${name}" is missing an endpoint or schema.`,
+                };
+            }
+            resolvedTargets.push({
+                name,
+                config: resolveConfig(mergedTarget),
+            });
+        }
+        return {
+            success: true,
+            targets: resolvedTargets,
+            isMulti: true,
+        };
+    }
+    if (options.target) {
+        return {
+            success: false,
+            error: 'Config file does not define targets. Remove --target to continue.',
+        };
+    }
+    const mergedConfig = mergeConfig(baseConfig, overrides);
     if (!mergedConfig.endpoint && !mergedConfig.schema) {
         return {
             success: false,
             error: 'No source specified. Use --endpoint or --schema, or create a config file with "graphql-codegen init".',
         };
     }
-    // Resolve with defaults
-    const config = resolveConfig(mergedConfig);
-    return { success: true, config };
+    return {
+        success: true,
+        targets: [{ name: 'default', config: resolveConfig(mergedConfig) }],
+        isMulti: false,
+    };
 }

package/esm/cli/commands/generate.d.ts

@@ -1,6 +1,8 @@
 export interface GenerateOptions {
     /** Path to config file */
     config?: string;
+    /** Named target in a multi-target config */
+    target?: string;
     /** GraphQL endpoint URL (overrides config) */
     endpoint?: string;
     /** Path to GraphQL schema file (.graphql) */
@@ -16,9 +18,21 @@ export interface GenerateOptions {
     /** Skip custom operations (only generate table CRUD) */
     skipCustomOperations?: boolean;
 }
+export interface GenerateTargetResult {
+    name: string;
+    output: string;
+    success: boolean;
+    message: string;
+    tables?: string[];
+    customQueries?: string[];
+    customMutations?: string[];
+    filesWritten?: string[];
+    errors?: string[];
+}
 export interface GenerateResult {
     success: boolean;
     message: string;
+    targets?: GenerateTargetResult[];
     tables?: string[];
     customQueries?: string[];
     customMutations?: string[];
@@ -42,3 +56,11 @@ export interface WriteOptions {
     showProgress?: boolean;
 }
 export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[], options?: WriteOptions): Promise<WriteResult>;
+/**
+ * Format generated files using oxfmt
+ * Runs oxfmt on the output directory after all files are written
+ */
+export declare function formatOutput(outputDir: string): {
+    success: boolean;
+    error?: string;
+};