@constructive-io/graphql-codegen 2.24.0 → 2.26.0

package/esm/cli/commands/generate.js

@@ -8,8 +8,8 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as prettier from 'prettier';
-import { resolveConfig } from '../../types/config';
+import { execSync } from 'node:child_process';
+import { isMultiConfig, mergeConfig, resolveConfig } from '../../types/config';
 import { createSchemaSource, validateSourceOptions, } from '../introspect/source';
 import { runCodegenPipeline, validateTablesFound } from './shared';
 import { findConfigFile, loadConfigFile } from './init';
@@ -18,9 +18,9 @@ import { generate } from '../codegen';
  * Execute the generate command
  */
 export async function generateCommand(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 {
@@ -28,24 +28,72 @@ export async function generateCommand(options = {}) {
             message: configResult.error,
         };
     }
-    const config = configResult.config;
-    // 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 generateForTarget(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 SDK for ${results.length} targets.`
+        : `Generated SDK 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 generateForTarget(target, options, isMultiTarget) {
+    const config = target.config;
+    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: ${config.output}`);
     }
-    log(`  Output: ${config.output}`);
-    // 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: config.output,
             success: false,
-            message: sourceValidation.error,
+            message: formatMessage(sourceValidation.error),
         };
     }
     const source = createSchemaSource({
@@ -54,7 +102,7 @@ export async function generateCommand(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 +114,25 @@ export async function generateCommand(options = {}) {
     }
     catch (err) {
         return {
+            name: target.name,
+            output: config.output,
             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: config.output,
             success: false,
-            message: tablesValidation.error,
+            message: formatMessage(tablesValidation.error),
         };
     }
-    // 5. Generate code
-    console.log('Generating code...');
+    // 4. Generate code
+    console.log(`${prefix}Generating code...`);
     const { files: generatedFiles, stats: genStats } = generate({
         tables,
         customOperations: {
@@ -90,7 +142,7 @@ export async function generateCommand(options = {}) {
         },
         config,
     });
-    console.log(`Generated ${genStats.totalFiles} files`);
+    console.log(`${prefix}Generated ${genStats.totalFiles} files`);
     log(`  ${genStats.queryHooks} table query hooks`);
     log(`  ${genStats.mutationHooks} table mutation hooks`);
     log(`  ${genStats.customQueryHooks} custom query hooks`);
@@ -99,15 +151,17 @@ export async function generateCommand(options = {}) {
     const customMutations = customOperations.mutations.map((m) => m.name);
     if (options.dryRun) {
         return {
+            name: target.name,
+            output: config.output,
             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, config.output, [
         'queries',
@@ -115,23 +169,48 @@ export async function generateCommand(options = {}) {
     ]);
     if (!writeResult.success) {
         return {
+            name: target.name,
+            output: config.output,
             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: config.output,
         success: true,
-        message: `Generated SDK for ${tables.length} tables${customOpsMsg}. Files written to ${config.output}`,
+        message: formatMessage(`Generated SDK for ${tables.length} tables${customOpsMsg}. Files written to ${config.output}`),
         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;
+    }
+    if (options.output) {
+        overrides.output = options.output;
+    }
+    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,31 +224,72 @@ 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,
-        reactQuery: baseConfig.reactQuery,
-    };
-    // 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,
+    };
 }
 export async function writeGeneratedFiles(files, outputDir, subdirs, options = {}) {
     const { showProgress = true } = options;
@@ -225,9 +345,7 @@ export async function writeGeneratedFiles(files, outputDir, subdirs, options = {
             // Ignore if already exists
         }
         try {
-            // Format with prettier
-            const formattedContent = await formatCode(file.content);
-            fs.writeFileSync(filePath, formattedContent, 'utf-8');
+            fs.writeFileSync(filePath, file.content, 'utf-8');
             written.push(filePath);
         }
         catch (err) {
@@ -239,23 +357,44 @@ export async function writeGeneratedFiles(files, outputDir, subdirs, options = {
     if (showProgress && isTTY) {
         process.stdout.write('\r' + ' '.repeat(40) + '\r');
     }
+    // Format all generated files with oxfmt
+    if (errors.length === 0) {
+        if (showProgress) {
+            console.log('Formatting generated files...');
+        }
+        const formatResult = formatOutput(outputDir);
+        if (!formatResult.success && showProgress) {
+            console.warn('Warning: Failed to format generated files:', formatResult.error);
+        }
+    }
     return {
         success: errors.length === 0,
         filesWritten: written,
         errors: errors.length > 0 ? errors : undefined,
     };
 }
-async function formatCode(code) {
+/**
+ * Format generated files using oxfmt
+ * Runs oxfmt on the output directory after all files are written
+ */
+export function formatOutput(outputDir) {
+    // Resolve to absolute path for reliable execution
+    const absoluteOutputDir = path.resolve(outputDir);
     try {
-        return await prettier.format(code, {
-            parser: 'typescript',
-            singleQuote: true,
-            trailingComma: 'es5',
-            tabWidth: 2,
+        // Find oxfmt binary from this package's node_modules/.bin
+        // oxfmt is a dependency of @constructive-io/graphql-codegen
+        const oxfmtPkgPath = require.resolve('oxfmt/package.json');
+        const oxfmtDir = path.dirname(oxfmtPkgPath);
+        const oxfmtBin = path.join(oxfmtDir, 'bin', 'oxfmt');
+        execSync(`"${oxfmtBin}" "${absoluteOutputDir}"`, {
+            stdio: 'pipe',
+            encoding: 'utf-8',
         });
+        return { success: true };
     }
-    catch {
-        // If prettier fails, return unformatted code
-        return code;
+    catch (err) {
+        // oxfmt may fail if files have syntax errors or if not installed
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return { success: false, error: message };
     }
 }

package/esm/cli/commands/init.js

@@ -14,6 +14,15 @@ export default defineConfig({
   // Output directory for generated files
   output: '{{OUTPUT}}',
 
+  // Optional: Multi-target config (use instead of endpoint/output)
+  // defaults: {
+  //   headers: { Authorization: 'Bearer YOUR_TOKEN' },
+  // },
+  // targets: {
+  //   public: { endpoint: 'https://api.example.com/graphql', output: './generated/public' },
+  //   admin: { schema: './admin.schema.graphql', output: './generated/admin' },
+  // },
+
   // Optional: Tables to include/exclude (supports glob patterns)
   // tables: {
   //   include: ['*'],
@@ -38,7 +47,7 @@ export default defineConfig({
  * Execute the init command
  */
 export async function initCommand(options = {}) {
-    const { directory = process.cwd(), force = false, endpoint = '', output = './generated' } = options;
+    const { directory = process.cwd(), force = false, endpoint = '', output = './generated', } = options;
     const configPath = path.join(directory, CONFIG_FILENAME);
     // Check if config already exists
     if (fs.existsSync(configPath) && !force) {
@@ -48,9 +57,7 @@ export async function initCommand(options = {}) {
         };
     }
     // Generate config content
-    const content = CONFIG_TEMPLATE
-        .replace('{{ENDPOINT}}', endpoint || 'http://localhost:5000/graphql')
-        .replace('{{OUTPUT}}', output);
+    const content = CONFIG_TEMPLATE.replace('{{ENDPOINT}}', endpoint || 'http://localhost:5000/graphql').replace('{{OUTPUT}}', output);
     try {
         // Ensure directory exists
         fs.mkdirSync(directory, { recursive: true });
@@ -96,10 +103,11 @@ export function findConfigFile(startDir = process.cwd()) {
  * tsx or ts-node installed.
  */
 export async function loadConfigFile(configPath) {
-    if (!fs.existsSync(configPath)) {
+    const resolvedPath = path.resolve(configPath);
+    if (!fs.existsSync(resolvedPath)) {
         return {
             success: false,
-            error: `Config file not found: ${configPath}`,
+            error: `Config file not found: ${resolvedPath}`,
         };
     }
     try {
@@ -110,19 +118,31 @@ export async function loadConfigFile(configPath) {
             debug: process.env.JITI_DEBUG === '1',
         });
         // jiti.import() with { default: true } returns mod?.default ?? mod
-        const config = await jiti.import(configPath, { default: true });
+        const config = await jiti.import(resolvedPath, { default: true });
         if (!config || typeof config !== 'object') {
             return {
                 success: false,
                 error: 'Config file must export a configuration object',
             };
         }
-        if (!('endpoint' in config)) {
+        const hasEndpoint = 'endpoint' in config;
+        const hasSchema = 'schema' in config;
+        const hasTargets = 'targets' in config;
+        if (!hasEndpoint && !hasSchema && !hasTargets) {
             return {
                 success: false,
-                error: 'Config file missing required "endpoint" property',
+                error: 'Config file must define "endpoint", "schema", or "targets".',
             };
         }
+        if (hasTargets) {
+            const targets = config.targets;
+            if (!targets || typeof targets !== 'object' || Array.isArray(targets)) {
+                return {
+                    success: false,
+                    error: 'Config file "targets" must be an object of named configs.',
+                };
+            }
+        }
         return {
             success: true,
             config,