@constructive-io/graphql-codegen 2.32.0 → 3.0.1

package/esm/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/esm/cli/shared.js

@@ -0,0 +1,101 @@
+/**
+ * Sanitize function that splits comma-separated strings into arrays
+ */
+export const splitCommas = (input) => {
+    if (!input)
+        return undefined;
+    return input.split(',').map((s) => s.trim()).filter(Boolean);
+};
+/**
+ * Questions for the codegen CLI
+ */
+export const 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: splitCommas,
+    },
+    {
+        name: 'apiNames',
+        message: 'API names (comma-separated)',
+        type: 'text',
+        required: false,
+        sanitize: 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
+ */
+export 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/{cli → esm/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/esm/{cli → core}/codegen/barrel.js

@@ -63,10 +63,7 @@ export function generateMutationsBarrel(tables) {
     return generateCode(statements);
 }
 export 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/{cli → esm/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/esm/{cli → core}/codegen/index.js

@@ -15,21 +15,24 @@ import { getTableNames } from './utils';
 // Main orchestrator
 // ============================================================================
 /**
- * Generate all SDK files for tables only (legacy function signature)
+ * Generate all SDK files for tables only
  */
 export 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).
  */
 export 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 ?? DEFAULT_QUERY_KEY_CONFIG;
     const useCentralizedKeys = queryKeyConfig.generateScopedKeys;
@@ -41,32 +44,49 @@ export function generate(options) {
     });
     // Collect table type names for import path resolution
     const tableTypeNames = new Set(tables.map((t) => 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 = 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 = 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: 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 = 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: generateTypesFile(tables, {
+                enumsFromSchemaTypes: generatedEnumNames,
+            }),
+        });
+    }
     // 3b. Generate centralized query keys (query-keys.ts)
     let hasQueryKeys = false;
     if (useCentralizedKeys) {

package/esm/{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/{cli → esm/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/esm/{cli → core}/codegen/orm/client-generator.js

@@ -371,10 +371,9 @@ export function generateCreateClientFile(tables, hasCustomQueries, hasCustomMuta
     ], 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/{cli → esm/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/esm/{cli → core}/codegen/orm/index.js

@@ -7,9 +7,10 @@ import { generateInputTypesFile, collectInputTypeNames, collectPayloadTypeNames
  * Generate all ORM client files
  */
 export 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/esm/{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/esm/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/esm/core/codegen/shared/index.js

@@ -0,0 +1,79 @@
+import * as t from '@babel/types';
+import { generateCode, addJSDocComment } from '../babel-ast';
+import { generateTypesFile } from '../types';
+import { generateSchemaTypesFile } from '../schema-types-generator';
+import { getTableNames } from '../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
+ */
+export function generateSharedTypes(options) {
+    const { tables, customOperations } = options;
+    const files = [];
+    // Collect table type names for import path resolution
+    const tableTypeNames = new Set(tables.map((t) => 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 = 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: 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) {
+        addJSDocComment(statements[0], [
+            'Shared types - auto-generated, do not edit',
+            '@generated by @constructive-io/graphql-codegen',
+        ]);
+    }
+    return generateCode(statements);
+}
+export { generateTypesFile } from '../types';
+export { generateSchemaTypesFile } from '../schema-types-generator';

package/esm/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/esm/core/config/index.js

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

package/esm/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>;

package/esm/core/config/loader.js

@@ -0,0 +1,71 @@
+/**
+ * Configuration file loading utilities
+ *
+ * Pure functions for finding and loading graphql-codegen configuration files.
+ * These are core utilities that can be used programmatically or by the CLI.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createJiti } from 'jiti';
+export const CONFIG_FILENAME = 'graphql-codegen.config.ts';
+/**
+ * Find the nearest config file by walking up directories
+ */
+export function findConfigFile(startDir = process.cwd()) {
+    let currentDir = startDir;
+    while (true) {
+        const configPath = path.join(currentDir, CONFIG_FILENAME);
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            // Reached root
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+/**
+ * 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 async function loadConfigFile(configPath) {
+    const resolvedPath = path.resolve(configPath);
+    if (!fs.existsSync(resolvedPath)) {
+        return {
+            success: false,
+            error: `Config file not found: ${resolvedPath}`,
+        };
+    }
+    try {
+        // Use jiti to load TypeScript/ESM config files seamlessly
+        // jiti handles .ts, .js, .mjs, .cjs and ESM/CJS interop
+        const jiti = createJiti(__filename, {
+            interopDefault: true,
+            debug: process.env.JITI_DEBUG === '1',
+        });
+        // jiti.import() with { default: true } returns mod?.default ?? mod
+        const config = await jiti.import(resolvedPath, { default: true });
+        if (!config || typeof config !== 'object') {
+            return {
+                success: false,
+                error: 'Config file must export a configuration object',
+            };
+        }
+        return {
+            success: true,
+            config,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return {
+            success: false,
+            error: `Failed to load config file: ${message}`,
+        };
+    }
+}

package/esm/core/config/resolver.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Configuration resolution utilities
+ *
+ * Functions for resolving and merging configuration from various sources
+ * (config file, CLI options, defaults) into a final resolved configuration.
+ */
+import type { GraphQLSDKConfigTarget } from '../../types/config';
+/**
+ * Options that can override config file settings.
+ * Extends GraphQLSDKConfigTarget with CLI-specific fields.
+ */
+export interface ConfigOverrideOptions extends GraphQLSDKConfigTarget {
+    /** Path to config file (CLI-only) */
+    config?: string;
+}
+/**
+ * Result of loading and resolving configuration
+ */
+export interface LoadConfigResult {
+    success: boolean;
+    config?: GraphQLSDKConfigTarget;
+    error?: string;
+}
+/**
+ * Load and resolve configuration from file and/or options
+ *
+ * This is the main entry point for configuration loading. It:
+ * 1. Finds and loads the config file (if any)
+ * 2. Applies CLI option overrides
+ * 3. Returns fully resolved configuration ready for use
+ */
+export declare function loadAndResolveConfig(options: ConfigOverrideOptions): Promise<LoadConfigResult>;
+/**
+ * Build watch configuration from options
+ *
+ * Used by watch mode to resolve configuration with watch-specific overrides.
+ */
+export declare function loadWatchConfig(options: {
+    config?: string;
+    endpoint?: string;
+    output?: string;
+    pollInterval?: number;
+    debounce?: number;
+    touch?: string;
+    clear?: boolean;
+}): Promise<GraphQLSDKConfigTarget | null>;