@constructive-io/graphql-codegen 2.24.1 → 2.26.0

package/cli/commands/generate.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommand = generateCommand;
 exports.writeGeneratedFiles = writeGeneratedFiles;
+exports.formatOutput = formatOutput;
 /**
  * Generate command - generates SDK from GraphQL schema
  *
@@ -45,7 +46,7 @@ exports.writeGeneratedFiles = writeGeneratedFiles;
  */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const prettier = __importStar(require("prettier"));
+const node_child_process_1 = require("node:child_process");
 const config_1 = require("../../types/config");
 const source_1 = require("../introspect/source");
 const shared_1 = require("./shared");
@@ -55,9 +56,9 @@ const codegen_1 = require("../codegen");
  * Execute the generate command
  */
 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 {
@@ -65,24 +66,72 @@ 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 = (0, source_1.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 = (0, source_1.createSchemaSource)({
@@ -91,7 +140,7 @@ 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 (0, shared_1.runCodegenPipeline)({
@@ -103,21 +152,25 @@ 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 = (0, shared_1.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 } = (0, codegen_1.generate)({
         tables,
         customOperations: {
@@ -127,7 +180,7 @@ 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`);
@@ -136,15 +189,17 @@ 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',
@@ -152,23 +207,48 @@ 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) {
@@ -182,31 +262,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 ((0, config_1.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 = (0, config_1.mergeConfig)(defaults, target);
+            if (options.target && name === options.target) {
+                mergedTarget = (0, config_1.mergeConfig)(mergedTarget, overrides);
+            }
+            if (!mergedTarget.endpoint && !mergedTarget.schema) {
+                return {
+                    success: false,
+                    error: `Target "${name}" is missing an endpoint or schema.`,
+                };
+            }
+            resolvedTargets.push({
+                name,
+                config: (0, config_1.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 = (0, config_1.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 = (0, config_1.resolveConfig)(mergedConfig);
-    return { success: true, config };
+    return {
+        success: true,
+        targets: [{ name: 'default', config: (0, config_1.resolveConfig)(mergedConfig) }],
+        isMulti: false,
+    };
 }
 async function writeGeneratedFiles(files, outputDir, subdirs, options = {}) {
     const { showProgress = true } = options;
@@ -262,9 +383,7 @@ 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) {
@@ -276,23 +395,44 @@ 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
+ */
+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');
+        (0, node_child_process_1.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/cli/commands/init.js

@@ -52,6 +52,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: ['*'],
@@ -76,7 +85,7 @@ export default defineConfig({
  * Execute the init command
  */
 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) {
@@ -86,9 +95,7 @@ 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 });
@@ -134,10 +141,11 @@ function findConfigFile(startDir = process.cwd()) {
  * tsx or ts-node installed.
  */
 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 {
@@ -148,19 +156,31 @@ 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,