@constructive-io/graphql-codegen 2.24.1 → 2.26.0

package/esm/cli/codegen/orm/custom-ops-generator.js

@@ -122,9 +122,14 @@ function buildOperationMethod(op, operationType) {
     const optionsParam = t.identifier('options');
     optionsParam.optional = true;
     if (selectTypeName) {
+        // Use DeepExact<S, SelectType> to enforce strict field validation
+        // This catches invalid fields even when mixed with valid ones
         optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeLiteral([
             (() => {
-                const prop = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('S'))));
+                const prop = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('DeepExact'), t.tsTypeParameterInstantiation([
+                    t.tsTypeReference(t.identifier('S')),
+                    t.tsTypeReference(t.identifier(selectTypeName)),
+                ]))));
                 prop.optional = true;
                 return prop;
             })(),
@@ -192,7 +197,7 @@ export function generateCustomQueryOpsFile(operations) {
     // Add imports
     statements.push(createImportDeclaration('../client', ['OrmClient']));
     statements.push(createImportDeclaration('../query-builder', ['QueryBuilder', 'buildCustomDocument']));
-    statements.push(createImportDeclaration('../select-types', ['InferSelectResult'], true));
+    statements.push(createImportDeclaration('../select-types', ['InferSelectResult', 'DeepExact'], true));
     if (allTypeImports.length > 0) {
         statements.push(createImportDeclaration('../input-types', allTypeImports, true));
     }
@@ -230,7 +235,7 @@ export function generateCustomMutationOpsFile(operations) {
     // Add imports
     statements.push(createImportDeclaration('../client', ['OrmClient']));
     statements.push(createImportDeclaration('../query-builder', ['QueryBuilder', 'buildCustomDocument']));
-    statements.push(createImportDeclaration('../select-types', ['InferSelectResult'], true));
+    statements.push(createImportDeclaration('../select-types', ['InferSelectResult', 'DeepExact'], true));
     if (allTypeImports.length > 0) {
         statements.push(createImportDeclaration('../input-types', allTypeImports, true));
     }

package/esm/cli/codegen/orm/model-generator.js

@@ -63,7 +63,7 @@ export function generateModelFile(table, _useSharedTypes) {
     ]));
     statements.push(createImportDeclaration('../select-types', [
         'ConnectionResult', 'FindManyArgs', 'FindFirstArgs', 'CreateArgs',
-        'UpdateArgs', 'DeleteArgs', 'InferSelectResult',
+        'UpdateArgs', 'DeleteArgs', 'InferSelectResult', 'DeepExact',
     ], true));
     statements.push(createImportDeclaration('../input-types', [
         typeName, relationTypeName, selectTypeName, whereTypeName, orderByTypeName,
@@ -77,10 +77,14 @@ export function generateModelFile(table, _useSharedTypes) {
     paramProp.accessibility = 'private';
     classBody.push(t.classMethod('constructor', t.identifier('constructor'), [paramProp], t.blockStatement([])));
     // findMany method
+    // Use DeepExact<S, SelectType> to enforce strict field validation
     const findManyParam = t.identifier('args');
     findManyParam.optional = true;
     findManyParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('FindManyArgs'), t.tsTypeParameterInstantiation([
-        t.tsTypeReference(t.identifier('S')),
+        t.tsTypeReference(t.identifier('DeepExact'), t.tsTypeParameterInstantiation([
+            t.tsTypeReference(t.identifier('S')),
+            t.tsTypeReference(t.identifier(selectTypeName)),
+        ])),
         t.tsTypeReference(t.identifier(whereTypeName)),
         t.tsTypeReference(t.identifier(orderByTypeName)),
     ])));
@@ -115,7 +119,10 @@ export function generateModelFile(table, _useSharedTypes) {
     const findFirstParam = t.identifier('args');
     findFirstParam.optional = true;
     findFirstParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('FindFirstArgs'), t.tsTypeParameterInstantiation([
-        t.tsTypeReference(t.identifier('S')),
+        t.tsTypeReference(t.identifier('DeepExact'), t.tsTypeParameterInstantiation([
+            t.tsTypeReference(t.identifier('S')),
+            t.tsTypeReference(t.identifier(selectTypeName)),
+        ])),
         t.tsTypeReference(t.identifier(whereTypeName)),
     ])));
     const findFirstReturnType = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('QueryBuilder'), t.tsTypeParameterInstantiation([
@@ -141,7 +148,10 @@ export function generateModelFile(table, _useSharedTypes) {
     // create method
     const createParam = t.identifier('args');
     createParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CreateArgs'), t.tsTypeParameterInstantiation([
-        t.tsTypeReference(t.identifier('S')),
+        t.tsTypeReference(t.identifier('DeepExact'), t.tsTypeParameterInstantiation([
+            t.tsTypeReference(t.identifier('S')),
+            t.tsTypeReference(t.identifier(selectTypeName)),
+        ])),
         t.tsIndexedAccessType(t.tsTypeReference(t.identifier(createInputTypeName)), t.tsLiteralType(t.stringLiteral(singularName))),
     ])));
     const createReturnType = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('QueryBuilder'), t.tsTypeParameterInstantiation([
@@ -167,7 +177,10 @@ export function generateModelFile(table, _useSharedTypes) {
     if (updateMutationName) {
         const updateParam = t.identifier('args');
         updateParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('UpdateArgs'), t.tsTypeParameterInstantiation([
-            t.tsTypeReference(t.identifier('S')),
+            t.tsTypeReference(t.identifier('DeepExact'), t.tsTypeParameterInstantiation([
+                t.tsTypeReference(t.identifier('S')),
+                t.tsTypeReference(t.identifier(selectTypeName)),
+            ])),
             t.tsTypeLiteral([t.tsPropertySignature(t.identifier('id'), t.tsTypeAnnotation(t.tsStringKeyword()))]),
             t.tsTypeReference(t.identifier(patchTypeName)),
         ])));

package/esm/cli/codegen/orm/select-types.d.ts

@@ -44,6 +44,39 @@ export interface NestedSelectConfig {
     filter?: Record<string, unknown>;
     orderBy?: string[];
 }
+/**
+ * Recursively validates select objects, rejecting unknown keys.
+ *
+ * This type ensures that users can only select fields that actually exist
+ * in the GraphQL schema. It returns `never` if any excess keys are found
+ * at any nesting level, causing a TypeScript compile error.
+ *
+ * Why this is needed:
+ * TypeScript's excess property checking has a quirk where it only catches
+ * invalid fields when they are the ONLY fields. When mixed with valid fields
+ * (e.g., `{ id: true, invalidField: true }`), the structural typing allows
+ * the excess property through. This type explicitly checks for and rejects
+ * such cases.
+ *
+ * @example
+ * // This will cause a type error because 'invalid' doesn't exist:
+ * type Result = DeepExact<{ id: true, invalid: true }, { id?: boolean }>;
+ * // Result = never (causes assignment error)
+ *
+ * @example
+ * // This works because all fields are valid:
+ * type Result = DeepExact<{ id: true }, { id?: boolean; name?: boolean }>;
+ * // Result = { id: true }
+ */
+export type DeepExact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? {
+    [K in keyof T]: K extends keyof Shape ? T[K] extends {
+        select: infer NS;
+    } ? Shape[K] extends {
+        select?: infer ShapeNS;
+    } ? {
+        select: DeepExact<NS, NonNullable<ShapeNS>>;
+    } : T[K] : T[K] : never;
+} : never : never;
 /**
  * Infers the result type from a select configuration
  *

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

@@ -9,6 +9,8 @@
 export interface GenerateOrmOptions {
     /** 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) */
@@ -24,9 +26,21 @@ export interface GenerateOrmOptions {
     /** Skip custom operations (only generate table CRUD) */
     skipCustomOperations?: boolean;
 }
+export interface GenerateOrmTargetResult {
+    name: string;
+    output: string;
+    success: boolean;
+    message: string;
+    tables?: string[];
+    customQueries?: string[];
+    customMutations?: string[];
+    filesWritten?: string[];
+    errors?: string[];
+}
 export interface GenerateOrmResult {
     success: boolean;
     message: string;
+    targets?: GenerateOrmTargetResult[];
     tables?: string[];
     customQueries?: string[];
     customMutations?: string[];

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;
+};