@constructive-io/graphql-codegen 2.32.0 → 3.0.1

package/cli/shared.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared CLI utilities for graphql-codegen
+ *
+ * These are exported so that packages/cli can use the same questions
+ * and types, ensuring consistency between the two CLIs.
+ */
+import type { Question } from 'inquirerer';
+import type { GenerateResult } from '../core/generate';
+/**
+ * Sanitize function that splits comma-separated strings into arrays
+ */
+export declare const splitCommas: (input: string | undefined) => string[] | undefined;
+/**
+ * Interface for codegen CLI answers
+ */
+export interface CodegenAnswers {
+    endpoint?: string;
+    schemaFile?: string;
+    output?: string;
+    schemas?: string[];
+    apiNames?: string[];
+    reactQuery?: boolean;
+    orm?: boolean;
+    authorization?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+}
+/**
+ * Questions for the codegen CLI
+ */
+export declare const codegenQuestions: Question[];
+/**
+ * Print the result of a generate operation
+ */
+export declare function printResult(result: GenerateResult): void;

package/cli/shared.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codegenQuestions = exports.splitCommas = void 0;
+exports.printResult = printResult;
+/**
+ * Sanitize function that splits comma-separated strings into arrays
+ */
+const splitCommas = (input) => {
+    if (!input)
+        return undefined;
+    return input.split(',').map((s) => s.trim()).filter(Boolean);
+};
+exports.splitCommas = splitCommas;
+/**
+ * Questions for the codegen CLI
+ */
+exports.codegenQuestions = [
+    {
+        name: 'endpoint',
+        message: 'GraphQL endpoint URL',
+        type: 'text',
+        required: false,
+    },
+    {
+        name: 'schemaFile',
+        message: 'Path to GraphQL schema file',
+        type: 'text',
+        required: false,
+    },
+    {
+        name: 'output',
+        message: 'Output directory',
+        type: 'text',
+        required: false,
+        default: 'codegen',
+        useDefault: true,
+    },
+    {
+        name: 'schemas',
+        message: 'PostgreSQL schemas (comma-separated)',
+        type: 'text',
+        required: false,
+        sanitize: exports.splitCommas,
+    },
+    {
+        name: 'apiNames',
+        message: 'API names (comma-separated)',
+        type: 'text',
+        required: false,
+        sanitize: exports.splitCommas,
+    },
+    {
+        name: 'reactQuery',
+        message: 'Generate React Query hooks?',
+        type: 'confirm',
+        required: false,
+        default: false,
+        useDefault: true,
+    },
+    {
+        name: 'orm',
+        message: 'Generate ORM client?',
+        type: 'confirm',
+        required: false,
+        default: false,
+        useDefault: true,
+    },
+    {
+        name: 'authorization',
+        message: 'Authorization header value',
+        type: 'text',
+        required: false,
+    },
+    {
+        name: 'dryRun',
+        message: 'Preview without writing files?',
+        type: 'confirm',
+        required: false,
+        default: false,
+        useDefault: true,
+    },
+    {
+        name: 'verbose',
+        message: 'Verbose output?',
+        type: 'confirm',
+        required: false,
+        default: false,
+        useDefault: true,
+    },
+];
+/**
+ * Print the result of a generate operation
+ */
+function printResult(result) {
+    if (result.success) {
+        console.log('[ok]', result.message);
+        if (result.tables?.length) {
+            console.log('Tables:', result.tables.join(', '));
+        }
+    }
+    else {
+        console.error('x', result.message);
+        result.errors?.forEach((e) => console.error('  -', e));
+        process.exit(1);
+    }
+}

package/{esm/cli → core}/codegen/barrel.d.ts

@@ -28,7 +28,7 @@ export interface MainBarrelOptions {
     /** Whether invalidation.ts was generated */
     hasInvalidation?: boolean;
 }
-export declare function generateMainBarrel(tables: CleanTable[], options?: MainBarrelOptions | boolean): string;
+export declare function generateMainBarrel(tables: CleanTable[], options?: MainBarrelOptions): string;
 /**
  * Generate queries barrel including custom query operations
  */

package/{cli → core}/codegen/barrel.js

@@ -103,10 +103,7 @@ function generateMutationsBarrel(tables) {
     return (0, babel_ast_1.generateCode)(statements);
 }
 function generateMainBarrel(tables, options = {}) {
-    // Support legacy signature where second arg was just hasSchemaTypes boolean
-    const opts = typeof options === 'boolean'
-        ? { hasSchemaTypes: options, hasMutations: true }
-        : options;
+    const opts = options;
     const { hasSchemaTypes = false, hasMutations = true, hasQueryKeys = false, hasMutationKeys = false, hasInvalidation = false, } = opts;
     const tableNames = tables.map((tbl) => tbl.name).join(', ');
     const statements = [];

package/{esm/cli → core}/codegen/index.d.ts

@@ -24,7 +24,7 @@
  *     ...
  */
 import type { CleanTable, CleanOperation, TypeRegistry } from '../../types/schema';
-import type { ResolvedConfig } from '../../types/config';
+import type { GraphQLSDKConfigTarget } from '../../types/config';
 export interface GeneratedFile {
     /** Relative path from output directory */
     path: string;
@@ -51,15 +51,25 @@ export interface GenerateOptions {
         mutations: CleanOperation[];
         typeRegistry: TypeRegistry;
     };
-    /** Resolved configuration */
-    config: ResolvedConfig;
+    /** Configuration */
+    config: GraphQLSDKConfigTarget;
+    /**
+     * Path to shared types directory (relative import path).
+     * When provided, types.ts and schema-types.ts are NOT generated
+     * and imports reference the shared types location instead.
+     * Example: '..' means types are in parent directory
+     */
+    sharedTypesPath?: string;
 }
 /**
- * Generate all SDK files for tables only (legacy function signature)
+ * Generate all SDK files for tables only
  */
-export declare function generateAllFiles(tables: CleanTable[], config: ResolvedConfig): GenerateResult;
+export declare function generateAllFiles(tables: CleanTable[], config: GraphQLSDKConfigTarget): GenerateResult;
 /**
  * Generate all SDK files with full support for custom operations
+ *
+ * When sharedTypesPath is provided, types.ts and schema-types.ts are NOT generated
+ * (they're expected to exist in the shared types directory).
  */
 export declare function generate(options: GenerateOptions): GenerateResult;
 export { generateClientFile } from './client';

package/{cli → core}/codegen/index.js

@@ -20,21 +20,24 @@ const utils_1 = require("./utils");
 // Main orchestrator
 // ============================================================================
 /**
- * Generate all SDK files for tables only (legacy function signature)
+ * Generate all SDK files for tables only
  */
 function generateAllFiles(tables, config) {
     return generate({ tables, config });
 }
 /**
  * Generate all SDK files with full support for custom operations
+ *
+ * When sharedTypesPath is provided, types.ts and schema-types.ts are NOT generated
+ * (they're expected to exist in the shared types directory).
  */
 function generate(options) {
-    const { tables, customOperations, config } = options;
+    const { tables, customOperations, config, sharedTypesPath } = options;
     const files = [];
     // Extract codegen options
     const maxDepth = config.codegen.maxFieldDepth;
     const skipQueryField = config.codegen.skipQueryField;
-    const reactQueryEnabled = config.reactQuery.enabled;
+    const reactQueryEnabled = config.reactQuery;
     // Query key configuration (use defaults if not provided)
     const queryKeyConfig = config.queryKeys ?? config_1.DEFAULT_QUERY_KEY_CONFIG;
     const useCentralizedKeys = queryKeyConfig.generateScopedKeys;
@@ -46,32 +49,49 @@ function generate(options) {
     });
     // Collect table type names for import path resolution
     const tableTypeNames = new Set(tables.map((t) => (0, utils_1.getTableNames)(t).typeName));
-    // 2. Generate schema-types.ts for custom operations (if any)
-    // NOTE: This must come BEFORE types.ts so that types.ts can import enum types
+    // When using shared types, skip generating types.ts and schema-types.ts
+    // They're already generated in the shared directory
     let hasSchemaTypes = false;
     let generatedEnumNames = [];
-    if (customOperations && customOperations.typeRegistry) {
-        const schemaTypesResult = (0, schema_types_generator_1.generateSchemaTypesFile)({
-            typeRegistry: customOperations.typeRegistry,
-            tableTypeNames,
-        });
-        // Only include if there's meaningful content
-        if (schemaTypesResult.content.split('\n').length > 10) {
-            files.push({
-                path: 'schema-types.ts',
-                content: schemaTypesResult.content,
+    if (sharedTypesPath) {
+        // Using shared types - check if schema-types would be generated
+        if (customOperations && customOperations.typeRegistry) {
+            const schemaTypesResult = (0, schema_types_generator_1.generateSchemaTypesFile)({
+                typeRegistry: customOperations.typeRegistry,
+                tableTypeNames,
             });
-            hasSchemaTypes = true;
-            generatedEnumNames = schemaTypesResult.generatedEnums || [];
+            if (schemaTypesResult.content.split('\n').length > 10) {
+                hasSchemaTypes = true;
+                generatedEnumNames = schemaTypesResult.generatedEnums || [];
+            }
         }
     }
-    // 3. Generate types.ts (can now import enums from schema-types)
-    files.push({
-        path: 'types.ts',
-        content: (0, types_1.generateTypesFile)(tables, {
-            enumsFromSchemaTypes: generatedEnumNames,
-        }),
-    });
+    else {
+        // 2. Generate schema-types.ts for custom operations (if any)
+        // NOTE: This must come BEFORE types.ts so that types.ts can import enum types
+        if (customOperations && customOperations.typeRegistry) {
+            const schemaTypesResult = (0, schema_types_generator_1.generateSchemaTypesFile)({
+                typeRegistry: customOperations.typeRegistry,
+                tableTypeNames,
+            });
+            // Only include if there's meaningful content
+            if (schemaTypesResult.content.split('\n').length > 10) {
+                files.push({
+                    path: 'schema-types.ts',
+                    content: schemaTypesResult.content,
+                });
+                hasSchemaTypes = true;
+                generatedEnumNames = schemaTypesResult.generatedEnums || [];
+            }
+        }
+        // 3. Generate types.ts (can now import enums from schema-types)
+        files.push({
+            path: 'types.ts',
+            content: (0, types_1.generateTypesFile)(tables, {
+                enumsFromSchemaTypes: generatedEnumNames,
+            }),
+        });
+    }
     // 3b. Generate centralized query keys (query-keys.ts)
     let hasQueryKeys = false;
     if (useCentralizedKeys) {

package/{cli → core}/codegen/invalidation.d.ts

@@ -5,10 +5,10 @@
  * for parent-child entity relationships.
  */
 import type { CleanTable } from '../../types/schema';
-import type { ResolvedQueryKeyConfig } from '../../types/config';
+import type { QueryKeyConfig } from '../../types/config';
 export interface InvalidationGeneratorOptions {
     tables: CleanTable[];
-    config: ResolvedQueryKeyConfig;
+    config: QueryKeyConfig;
 }
 export interface GeneratedInvalidationFile {
     fileName: string;

package/{esm/cli → core}/codegen/mutation-keys.d.ts

@@ -8,11 +8,11 @@
  * - Tracking mutation state with useIsMutating
  */
 import type { CleanTable, CleanOperation } from '../../types/schema';
-import type { ResolvedQueryKeyConfig } from '../../types/config';
+import type { QueryKeyConfig } from '../../types/config';
 export interface MutationKeyGeneratorOptions {
     tables: CleanTable[];
     customMutations: CleanOperation[];
-    config: ResolvedQueryKeyConfig;
+    config: QueryKeyConfig;
 }
 export interface GeneratedMutationKeysFile {
     fileName: string;

package/{cli → core}/codegen/orm/client-generator.js

@@ -410,10 +410,9 @@ function generateCreateClientFile(tables, hasCustomQueries, hasCustomMutations)
     ], t.stringLiteral('./query-builder')));
     // export * from './select-types';
     statements.push(t.exportAllDeclaration(t.stringLiteral('./select-types')));
-    // Re-export all models for backwards compatibility
-    // export * from './models';
+    // Re-export all models
     statements.push(t.exportAllDeclaration(t.stringLiteral('./models')));
-    // Re-export custom operations for backwards compatibility
+    // Re-export custom operations
     if (hasCustomQueries) {
         statements.push(t.exportNamedDeclaration(null, [
             t.exportSpecifier(t.identifier('createQueryOperations'), t.identifier('createQueryOperations')),

package/{esm/cli → core}/codegen/orm/index.d.ts

@@ -5,7 +5,7 @@
  * and produces the complete ORM client output.
  */
 import type { CleanTable, CleanOperation, TypeRegistry } from '../../../types/schema';
-import type { ResolvedConfig } from '../../../types/config';
+import type { GraphQLSDKConfigTarget } from '../../../types/config';
 export interface GeneratedFile {
     path: string;
     content: string;
@@ -17,7 +17,14 @@ export interface GenerateOrmOptions {
         mutations: CleanOperation[];
         typeRegistry?: TypeRegistry;
     };
-    config: ResolvedConfig;
+    config: GraphQLSDKConfigTarget;
+    /**
+     * Path to shared types directory (relative import path).
+     * When provided, entity types are imported from shared types
+     * instead of being generated in input-types.ts.
+     * Example: '..' means types are in parent directory
+     */
+    sharedTypesPath?: string;
 }
 export interface GenerateOrmResult {
     files: GeneratedFile[];

package/{cli → core}/codegen/orm/index.js

@@ -11,9 +11,10 @@ const input_types_generator_1 = require("./input-types-generator");
  * Generate all ORM client files
  */
 function generateOrm(options) {
-    const { tables, customOperations, config } = options;
+    const { tables, customOperations, sharedTypesPath } = options;
     const files = [];
-    const useSharedTypes = config.orm.useSharedTypes;
+    // Use shared types when a sharedTypesPath is provided (unified output mode)
+    const useSharedTypes = !!sharedTypesPath;
     const hasCustomQueries = (customOperations?.queries.length ?? 0) > 0;
     const hasCustomMutations = (customOperations?.mutations.length ?? 0) > 0;
     const typeRegistry = customOperations?.typeRegistry;

package/{cli → core}/codegen/query-keys.d.ts

@@ -1,9 +1,9 @@
 import type { CleanTable, CleanOperation } from '../../types/schema';
-import type { ResolvedQueryKeyConfig } from '../../types/config';
+import type { QueryKeyConfig } from '../../types/config';
 export interface QueryKeyGeneratorOptions {
     tables: CleanTable[];
     customQueries: CleanOperation[];
-    config: ResolvedQueryKeyConfig;
+    config: QueryKeyConfig;
 }
 export interface GeneratedQueryKeysFile {
     fileName: string;

package/core/codegen/shared/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared types generator
+ *
+ * Generates shared TypeScript types that can be imported by both
+ * React Query SDK and ORM client outputs.
+ *
+ * Output structure:
+ * shared/
+ *   index.ts          - Barrel export
+ *   types.ts          - Entity interfaces
+ *   schema-types.ts   - Enums, input types, payload types
+ *   filters.ts        - Filter types (StringFilter, IntFilter, etc.)
+ */
+import type { CleanTable, CleanOperation, TypeRegistry } from '../../../types/schema';
+import type { GraphQLSDKConfigTarget } from '../../../types/config';
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export interface GenerateSharedOptions {
+    tables: CleanTable[];
+    customOperations?: {
+        queries: CleanOperation[];
+        mutations: CleanOperation[];
+        typeRegistry: TypeRegistry;
+    };
+    config: GraphQLSDKConfigTarget;
+}
+export interface GenerateSharedResult {
+    files: GeneratedFile[];
+    generatedEnumNames: string[];
+    hasSchemaTypes: boolean;
+}
+/**
+ * Generate shared types that can be imported by both React Query SDK and ORM client
+ */
+export declare function generateSharedTypes(options: GenerateSharedOptions): GenerateSharedResult;
+export { generateTypesFile } from '../types';
+export { generateSchemaTypesFile } from '../schema-types-generator';

package/core/codegen/shared/index.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaTypesFile = exports.generateTypesFile = void 0;
+exports.generateSharedTypes = generateSharedTypes;
+const t = __importStar(require("@babel/types"));
+const babel_ast_1 = require("../babel-ast");
+const types_1 = require("../types");
+const schema_types_generator_1 = require("../schema-types-generator");
+const utils_1 = require("../utils");
+/**
+ * Helper to create export * from './module' statement
+ */
+function exportAllFrom(modulePath) {
+    return t.exportAllDeclaration(t.stringLiteral(modulePath));
+}
+/**
+ * Generate shared types that can be imported by both React Query SDK and ORM client
+ */
+function generateSharedTypes(options) {
+    const { tables, customOperations } = options;
+    const files = [];
+    // Collect table type names for import path resolution
+    const tableTypeNames = new Set(tables.map((t) => (0, utils_1.getTableNames)(t).typeName));
+    // 1. Generate schema-types.ts for custom operations (if any)
+    // NOTE: This must come BEFORE types.ts so that types.ts can import enum types
+    let hasSchemaTypes = false;
+    let generatedEnumNames = [];
+    if (customOperations && customOperations.typeRegistry) {
+        const schemaTypesResult = (0, schema_types_generator_1.generateSchemaTypesFile)({
+            typeRegistry: customOperations.typeRegistry,
+            tableTypeNames,
+        });
+        // Only include if there's meaningful content
+        if (schemaTypesResult.content.split('\n').length > 10) {
+            files.push({
+                path: 'schema-types.ts',
+                content: schemaTypesResult.content,
+            });
+            hasSchemaTypes = true;
+            generatedEnumNames = schemaTypesResult.generatedEnums || [];
+        }
+    }
+    // 2. Generate types.ts (entity interfaces and filter types)
+    files.push({
+        path: 'types.ts',
+        content: (0, types_1.generateTypesFile)(tables, {
+            enumsFromSchemaTypes: generatedEnumNames,
+        }),
+    });
+    // 3. Generate barrel export (index.ts)
+    const barrelContent = generateSharedBarrel(hasSchemaTypes);
+    files.push({
+        path: 'index.ts',
+        content: barrelContent,
+    });
+    return {
+        files,
+        generatedEnumNames,
+        hasSchemaTypes,
+    };
+}
+/**
+ * Generate the barrel export for shared types using Babel AST
+ */
+function generateSharedBarrel(hasSchemaTypes) {
+    const statements = [];
+    // Export types
+    statements.push(exportAllFrom('./types'));
+    // Export schema types if present
+    if (hasSchemaTypes) {
+        statements.push(exportAllFrom('./schema-types'));
+    }
+    // Add file header as leading comment on first statement
+    if (statements.length > 0) {
+        (0, babel_ast_1.addJSDocComment)(statements[0], [
+            'Shared types - auto-generated, do not edit',
+            '@generated by @constructive-io/graphql-codegen',
+        ]);
+    }
+    return (0, babel_ast_1.generateCode)(statements);
+}
+var types_2 = require("../types");
+Object.defineProperty(exports, "generateTypesFile", { enumerable: true, get: function () { return types_2.generateTypesFile; } });
+var schema_types_generator_2 = require("../schema-types-generator");
+Object.defineProperty(exports, "generateSchemaTypesFile", { enumerable: true, get: function () { return schema_types_generator_2.generateSchemaTypesFile; } });

package/core/config/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration module exports
+ */
+export { CONFIG_FILENAME, findConfigFile, loadConfigFile, type LoadConfigFileResult, } from './loader';
+export { loadAndResolveConfig, loadWatchConfig, type ConfigOverrideOptions, type LoadConfigResult, } from './resolver';

package/core/config/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Configuration module exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadWatchConfig = exports.loadAndResolveConfig = exports.loadConfigFile = exports.findConfigFile = exports.CONFIG_FILENAME = void 0;
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "CONFIG_FILENAME", { enumerable: true, get: function () { return loader_1.CONFIG_FILENAME; } });
+Object.defineProperty(exports, "findConfigFile", { enumerable: true, get: function () { return loader_1.findConfigFile; } });
+Object.defineProperty(exports, "loadConfigFile", { enumerable: true, get: function () { return loader_1.loadConfigFile; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "loadAndResolveConfig", { enumerable: true, get: function () { return resolver_1.loadAndResolveConfig; } });
+Object.defineProperty(exports, "loadWatchConfig", { enumerable: true, get: function () { return resolver_1.loadWatchConfig; } });

package/core/config/loader.d.ts

@@ -0,0 +1,18 @@
+export declare const CONFIG_FILENAME = "graphql-codegen.config.ts";
+/**
+ * Find the nearest config file by walking up directories
+ */
+export declare function findConfigFile(startDir?: string): string | null;
+export interface LoadConfigFileResult {
+    success: boolean;
+    config?: any;
+    error?: string;
+}
+/**
+ * Load and validate a config file
+ *
+ * Uses jiti to support TypeScript config files (.ts) in addition to
+ * JavaScript (.js, .mjs, .cjs) without requiring the user to have
+ * tsx or ts-node installed.
+ */
+export declare function loadConfigFile(configPath: string): Promise<LoadConfigFileResult>;