@constructive-io/graphql-codegen 2.20.1 → 2.22.0

package/esm/cli/codegen/client.js

@@ -53,6 +53,39 @@ export function getConfig(): GraphQLClientConfig {
   return globalConfig;
 }
 
+/**
+ * Set a single header value
+ * Useful for updating Authorization after login
+ *
+ * @example
+ * \`\`\`ts
+ * setHeader('Authorization', 'Bearer <new-token>');
+ * \`\`\`
+ */
+export function setHeader(key: string, value: string): void {
+  const config = getConfig();
+  globalConfig = {
+    ...config,
+    headers: { ...config.headers, [key]: value },
+  };
+}
+
+/**
+ * Merge multiple headers into the current configuration
+ *
+ * @example
+ * \`\`\`ts
+ * setHeaders({ Authorization: 'Bearer <token>', 'X-Custom': 'value' });
+ * \`\`\`
+ */
+export function setHeaders(headers: Record<string, string>): void {
+  const config = getConfig();
+  globalConfig = {
+    ...config,
+    headers: { ...config.headers, ...headers },
+  };
+}
+
 // ============================================================================
 // Error handling
 // ============================================================================

package/esm/cli/codegen/custom-mutations.d.ts

@@ -21,18 +21,28 @@ export interface GenerateCustomMutationHookOptions {
     typeRegistry: TypeRegistry;
     maxDepth?: number;
     skipQueryField?: boolean;
+    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
+    reactQueryEnabled?: boolean;
+    /** Table entity type names (for import path resolution) */
+    tableTypeNames?: Set<string>;
 }
 /**
  * Generate a custom mutation hook file
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-export declare function generateCustomMutationHook(options: GenerateCustomMutationHookOptions): GeneratedCustomMutationFile;
+export declare function generateCustomMutationHook(options: GenerateCustomMutationHookOptions): GeneratedCustomMutationFile | null;
 export interface GenerateAllCustomMutationHooksOptions {
     operations: CleanOperation[];
     typeRegistry: TypeRegistry;
     maxDepth?: number;
     skipQueryField?: boolean;
+    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
+    reactQueryEnabled?: boolean;
+    /** Table entity type names (for import path resolution) */
+    tableTypeNames?: Set<string>;
 }
 /**
  * Generate all custom mutation hook files
+ * When reactQueryEnabled is false, returns empty array since mutations require React Query
  */
 export declare function generateAllCustomMutationHooks(options: GenerateAllCustomMutationHooksOptions): GeneratedCustomMutationFile[];

package/esm/cli/codegen/custom-mutations.js

@@ -1,11 +1,16 @@
 import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, createConst, } from './ts-ast';
 import { buildCustomMutationString } from './schema-gql-ast';
-import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, } from './type-resolver';
+import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, createTypeTracker, } from './type-resolver';
 /**
  * Generate a custom mutation hook file
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
 export function generateCustomMutationHook(options) {
-    const { operation } = options;
+    const { operation, reactQueryEnabled = true } = options;
+    // Mutations require React Query - skip generation when disabled
+    if (!reactQueryEnabled) {
+        return null;
+    }
     try {
         return generateCustomMutationHookInternal(options);
     }
@@ -16,13 +21,15 @@ export function generateCustomMutationHook(options) {
     }
 }
 function generateCustomMutationHookInternal(options) {
-    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true } = options;
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, tableTypeNames } = options;
     const project = createProject();
     const hookName = getOperationHookName(operation.name, 'mutation');
     const fileName = getOperationFileName(operation.name, 'mutation');
     const variablesTypeName = getOperationVariablesTypeName(operation.name, 'mutation');
     const resultTypeName = getOperationResultTypeName(operation.name, 'mutation');
     const documentConstName = getDocumentConstName(operation.name, 'mutation');
+    // Create type tracker to collect referenced types (with table type awareness)
+    const tracker = createTypeTracker({ tableTypeNames });
     // Generate GraphQL document
     const mutationDocument = buildCustomMutationString({
         operation,
@@ -33,8 +40,21 @@ function generateCustomMutationHookInternal(options) {
     const sourceFile = createSourceFile(project, fileName);
     // Add file header
     sourceFile.insertText(0, createFileHeader(`Custom mutation hook for ${operation.name}`) + '\n\n');
+    // Generate variables interface if there are arguments (with tracking)
+    let variablesProps = [];
+    if (operation.args.length > 0) {
+        variablesProps = generateVariablesProperties(operation.args, tracker);
+    }
+    // Generate result interface (with tracking)
+    const resultType = typeRefToTsType(operation.returnType, tracker);
+    const resultProps = [
+        { name: operation.name, type: resultType },
+    ];
+    // Get importable types from tracker (separated by source)
+    const schemaTypes = tracker.getImportableTypes(); // From schema-types.ts
+    const tableTypes = tracker.getTableTypes(); // From types.ts
     // Add imports
-    sourceFile.addImportDeclarations([
+    const imports = [
         createImport({
             moduleSpecifier: '@tanstack/react-query',
             namedImports: ['useMutation'],
@@ -44,21 +64,31 @@ function generateCustomMutationHookInternal(options) {
             moduleSpecifier: '../client',
             namedImports: ['execute'],
         }),
-    ]);
+    ];
+    // Add types.ts import for table entity types
+    if (tableTypes.length > 0) {
+        imports.push(createImport({
+            moduleSpecifier: '../types',
+            typeOnlyNamedImports: tableTypes,
+        }));
+    }
+    // Add schema-types import for Input/Payload/Enum types
+    if (schemaTypes.length > 0) {
+        imports.push(createImport({
+            moduleSpecifier: '../schema-types',
+            typeOnlyNamedImports: schemaTypes,
+        }));
+    }
+    sourceFile.addImportDeclarations(imports);
     // Add mutation document constant
     sourceFile.addVariableStatement(createConst(documentConstName, '`\n' + mutationDocument + '`', {
         docs: ['GraphQL mutation document'],
     }));
-    // Generate variables interface if there are arguments
+    // Add variables interface
     if (operation.args.length > 0) {
-        const variablesProps = generateVariablesProperties(operation.args);
         sourceFile.addInterface(createInterface(variablesTypeName, variablesProps));
     }
-    // Generate result interface
-    const resultType = typeRefToTsType(operation.returnType);
-    const resultProps = [
-        { name: operation.name, type: resultType },
-    ];
+    // Add result interface
     sourceFile.addInterface(createInterface(resultTypeName, resultProps));
     // Generate hook function
     const hookParams = generateHookParameters(operation, variablesTypeName, resultTypeName);
@@ -82,10 +112,10 @@ function generateCustomMutationHookInternal(options) {
 /**
  * Generate interface properties from CleanArguments
  */
-function generateVariablesProperties(args) {
+function generateVariablesProperties(args, tracker) {
     return args.map((arg) => ({
         name: arg.name,
-        type: typeRefToTsType(arg.type),
+        type: typeRefToTsType(arg.type, tracker),
         optional: !isTypeRequired(arg.type),
         docs: arg.description ? [arg.description] : undefined,
     }));
@@ -131,9 +161,10 @@ function generateHookBody(operation, documentConstName, variablesTypeName, resul
 }
 /**
  * Generate all custom mutation hook files
+ * When reactQueryEnabled is false, returns empty array since mutations require React Query
  */
 export function generateAllCustomMutationHooks(options) {
-    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true } = options;
+    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames } = options;
     return operations
         .filter((op) => op.kind === 'mutation')
         .map((operation) => generateCustomMutationHook({
@@ -141,5 +172,8 @@ export function generateAllCustomMutationHooks(options) {
         typeRegistry,
         maxDepth,
         skipQueryField,
-    }));
+        reactQueryEnabled,
+        tableTypeNames,
+    }))
+        .filter((result) => result !== null);
 }

package/esm/cli/codegen/custom-queries.d.ts

@@ -21,6 +21,10 @@ export interface GenerateCustomQueryHookOptions {
     typeRegistry: TypeRegistry;
     maxDepth?: number;
     skipQueryField?: boolean;
+    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
+    reactQueryEnabled?: boolean;
+    /** Table entity type names (for import path resolution) */
+    tableTypeNames?: Set<string>;
 }
 /**
  * Generate a custom query hook file
@@ -31,6 +35,10 @@ export interface GenerateAllCustomQueryHooksOptions {
     typeRegistry: TypeRegistry;
     maxDepth?: number;
     skipQueryField?: boolean;
+    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
+    reactQueryEnabled?: boolean;
+    /** Table entity type names (for import path resolution) */
+    tableTypeNames?: Set<string>;
 }
 /**
  * Generate all custom query hook files

package/esm/cli/codegen/custom-queries.js

@@ -1,12 +1,12 @@
 import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, createConst, } from './ts-ast';
 import { buildCustomQueryString } from './schema-gql-ast';
-import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, getQueryKeyName, } from './type-resolver';
+import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, getQueryKeyName, createTypeTracker, } from './type-resolver';
 import { ucFirst } from './utils';
 /**
  * Generate a custom query hook file
  */
 export function generateCustomQueryHook(options) {
-    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true } = options;
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames } = options;
     const project = createProject();
     const hookName = getOperationHookName(operation.name, 'query');
     const fileName = getOperationFileName(operation.name, 'query');
@@ -14,6 +14,8 @@ export function generateCustomQueryHook(options) {
     const resultTypeName = getOperationResultTypeName(operation.name, 'query');
     const documentConstName = getDocumentConstName(operation.name, 'query');
     const queryKeyName = getQueryKeyName(operation.name);
+    // Create type tracker to collect referenced types (with table type awareness)
+    const tracker = createTypeTracker({ tableTypeNames });
     // Generate GraphQL document
     const queryDocument = buildCustomQueryString({
         operation,
@@ -23,34 +25,61 @@ export function generateCustomQueryHook(options) {
     });
     const sourceFile = createSourceFile(project, fileName);
     // Add file header
-    sourceFile.insertText(0, createFileHeader(`Custom query hook for ${operation.name}`) + '\n\n');
-    // Add imports
-    sourceFile.addImportDeclarations([
-        createImport({
+    const headerText = reactQueryEnabled
+        ? `Custom query hook for ${operation.name}`
+        : `Custom query functions for ${operation.name}`;
+    sourceFile.insertText(0, createFileHeader(headerText) + '\n\n');
+    // Generate variables interface if there are arguments (with tracking)
+    let variablesProps = [];
+    if (operation.args.length > 0) {
+        variablesProps = generateVariablesProperties(operation.args, tracker);
+    }
+    // Generate result interface (with tracking)
+    const resultType = typeRefToTsType(operation.returnType, tracker);
+    const resultProps = [
+        { name: operation.name, type: resultType },
+    ];
+    // Get importable types from tracker (separated by source)
+    const schemaTypes = tracker.getImportableTypes(); // From schema-types.ts
+    const tableTypes = tracker.getTableTypes(); // From types.ts
+    // Add imports - conditionally include React Query imports
+    const imports = [];
+    if (reactQueryEnabled) {
+        imports.push(createImport({
             moduleSpecifier: '@tanstack/react-query',
             namedImports: ['useQuery'],
             typeOnlyNamedImports: ['UseQueryOptions', 'QueryClient'],
-        }),
-        createImport({
-            moduleSpecifier: '../client',
-            namedImports: ['execute'],
-            typeOnlyNamedImports: ['ExecuteOptions'],
-        }),
-    ]);
+        }));
+    }
+    imports.push(createImport({
+        moduleSpecifier: '../client',
+        namedImports: ['execute'],
+        typeOnlyNamedImports: ['ExecuteOptions'],
+    }));
+    // Add types.ts import for table entity types
+    if (tableTypes.length > 0) {
+        imports.push(createImport({
+            moduleSpecifier: '../types',
+            typeOnlyNamedImports: tableTypes,
+        }));
+    }
+    // Add schema-types import for Input/Payload/Enum types
+    if (schemaTypes.length > 0) {
+        imports.push(createImport({
+            moduleSpecifier: '../schema-types',
+            typeOnlyNamedImports: schemaTypes,
+        }));
+    }
+    sourceFile.addImportDeclarations(imports);
     // Add query document constant
     sourceFile.addVariableStatement(createConst(documentConstName, '`\n' + queryDocument + '`', {
         docs: ['GraphQL query document'],
     }));
-    // Generate variables interface if there are arguments
+    // Add variables interface
     if (operation.args.length > 0) {
-        const variablesProps = generateVariablesProperties(operation.args);
         sourceFile.addInterface(createInterface(variablesTypeName, variablesProps));
     }
-    // Generate result interface
-    const resultType = typeRefToTsType(operation.returnType);
-    const resultProps = [
-        { name: operation.name, type: resultType },
-    ];
+    // Add result interface
     sourceFile.addInterface(createInterface(resultTypeName, resultProps));
     // Query key factory
     if (operation.args.length > 0) {
@@ -62,17 +91,19 @@ export function generateCustomQueryHook(options) {
             docs: ['Query key factory for caching'],
         }));
     }
-    // Generate hook function
-    const hookParams = generateHookParameters(operation, variablesTypeName, resultTypeName);
-    const hookBody = generateHookBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName);
-    const hookDoc = generateHookDoc(operation, hookName);
-    sourceFile.addFunction({
-        name: hookName,
-        isExported: true,
-        parameters: hookParams,
-        statements: hookBody,
-        docs: [{ description: hookDoc }],
-    });
+    // Generate hook function (only if React Query is enabled)
+    if (reactQueryEnabled) {
+        const hookParams = generateHookParameters(operation, variablesTypeName, resultTypeName);
+        const hookBody = generateHookBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName);
+        const hookDoc = generateHookDoc(operation, hookName);
+        sourceFile.addFunction({
+            name: hookName,
+            isExported: true,
+            parameters: hookParams,
+            statements: hookBody,
+            docs: [{ description: hookDoc }],
+        });
+    }
     // Add standalone functions section
     sourceFile.addStatements('\n// ============================================================================');
     sourceFile.addStatements('// Standalone Functions (non-React)');
@@ -91,20 +122,22 @@ export function generateCustomQueryHook(options) {
         statements: fetchBody,
         docs: [{ description: fetchDoc }],
     });
-    // Generate prefetch function
-    const prefetchFnName = `prefetch${ucFirst(operation.name)}Query`;
-    const prefetchParams = generatePrefetchParameters(operation, variablesTypeName);
-    const prefetchBody = generatePrefetchBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName);
-    const prefetchDoc = generatePrefetchDoc(operation, prefetchFnName);
-    sourceFile.addFunction({
-        name: prefetchFnName,
-        isExported: true,
-        isAsync: true,
-        parameters: prefetchParams,
-        returnType: 'Promise<void>',
-        statements: prefetchBody,
-        docs: [{ description: prefetchDoc }],
-    });
+    // Generate prefetch function (only if React Query is enabled)
+    if (reactQueryEnabled) {
+        const prefetchFnName = `prefetch${ucFirst(operation.name)}Query`;
+        const prefetchParams = generatePrefetchParameters(operation, variablesTypeName);
+        const prefetchBody = generatePrefetchBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName);
+        const prefetchDoc = generatePrefetchDoc(operation, prefetchFnName);
+        sourceFile.addFunction({
+            name: prefetchFnName,
+            isExported: true,
+            isAsync: true,
+            parameters: prefetchParams,
+            returnType: 'Promise<void>',
+            statements: prefetchBody,
+            docs: [{ description: prefetchDoc }],
+        });
+    }
     return {
         fileName,
         content: getFormattedOutput(sourceFile),
@@ -117,10 +150,10 @@ export function generateCustomQueryHook(options) {
 /**
  * Generate interface properties from CleanArguments
  */
-function generateVariablesProperties(args) {
+function generateVariablesProperties(args, tracker) {
     return args.map((arg) => ({
         name: arg.name,
-        type: typeRefToTsType(arg.type),
+        type: typeRefToTsType(arg.type, tracker),
         optional: !isTypeRequired(arg.type),
         docs: arg.description ? [arg.description] : undefined,
     }));
@@ -342,7 +375,7 @@ await ${fnName}(queryClient);
  * Generate all custom query hook files
  */
 export function generateAllCustomQueryHooks(options) {
-    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true } = options;
+    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames } = options;
     return operations
         .filter((op) => op.kind === 'query')
         .map((operation) => generateCustomQueryHook({
@@ -350,5 +383,7 @@ export function generateAllCustomQueryHooks(options) {
         typeRegistry,
         maxDepth,
         skipQueryField,
+        reactQueryEnabled,
+        tableTypeNames,
     }));
 }

package/esm/cli/codegen/gql-ast.js

@@ -6,7 +6,7 @@
  */
 import * as t from 'gql-ast';
 import { print } from 'graphql';
-import { getTableNames, getAllRowsQueryName, getSingleRowQueryName, getCreateMutationName, getUpdateMutationName, getDeleteMutationName, getFilterTypeName, getOrderByTypeName, getScalarFields, ucFirst, } from './utils';
+import { getTableNames, getAllRowsQueryName, getSingleRowQueryName, getCreateMutationName, getUpdateMutationName, getDeleteMutationName, getFilterTypeName, getOrderByTypeName, getScalarFields, getPrimaryKeyInfo, ucFirst, } from './utils';
 // ============================================================================
 // Field selection builders
 // ============================================================================
@@ -106,16 +106,20 @@ export function buildSingleQueryAST(config) {
     const { table } = config;
     const queryName = getSingleRowQueryName(table);
     const scalarFields = getScalarFields(table);
-    // Variable definitions - assume UUID primary key
+    // Get primary key info dynamically from table constraints
+    const pkFields = getPrimaryKeyInfo(table);
+    // For simplicity, use first PK field (most common case)
+    const pkField = pkFields[0];
+    // Variable definitions - use dynamic PK field name and type
     const variableDefinitions = [
         t.variableDefinition({
-            variable: t.variable({ name: 'id' }),
-            type: t.nonNullType({ type: t.namedType({ type: 'UUID' }) }),
+            variable: t.variable({ name: pkField.name }),
+            type: t.nonNullType({ type: t.namedType({ type: pkField.gqlType }) }),
         }),
     ];
-    // Query arguments
+    // Query arguments - use dynamic PK field name
     const args = [
-        t.argument({ name: 'id', value: t.variable({ name: 'id' }) }),
+        t.argument({ name: pkField.name, value: t.variable({ name: pkField.name }) }),
     ];
     // Field selections
     const fieldSelections = createFieldSelections(scalarFields);

package/esm/cli/codegen/index.js

@@ -1,10 +1,12 @@
 import { generateClientFile } from './client';
 import { generateTypesFile } from './types';
+import { generateSchemaTypesFile } from './schema-types-generator';
 import { generateAllQueryHooks } from './queries';
 import { generateAllMutationHooks } from './mutations';
 import { generateAllCustomQueryHooks } from './custom-queries';
 import { generateAllCustomMutationHooks } from './custom-mutations';
 import { generateQueriesBarrel, generateMutationsBarrel, generateMainBarrel, generateCustomQueriesBarrel, generateCustomMutationsBarrel, } from './barrel';
+import { getTableNames } from './utils';
 // ============================================================================
 // Main orchestrator
 // ============================================================================
@@ -23,25 +25,47 @@ export function generate(options) {
     // Extract codegen options
     const maxDepth = config.codegen.maxFieldDepth;
     const skipQueryField = config.codegen.skipQueryField;
+    const reactQueryEnabled = config.reactQuery.enabled;
     // 1. Generate client.ts
     files.push({
         path: 'client.ts',
         content: generateClientFile(),
     });
-    // 2. Generate types.ts
+    // 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
+    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 || [];
+        }
+    }
+    // 3. Generate types.ts (can now import enums from schema-types)
     files.push({
         path: 'types.ts',
-        content: generateTypesFile(tables),
+        content: generateTypesFile(tables, { enumsFromSchemaTypes: generatedEnumNames }),
     });
-    // 3. Generate table-based query hooks (queries/*.ts)
-    const queryHooks = generateAllQueryHooks(tables);
+    // 4. Generate table-based query hooks (queries/*.ts)
+    const queryHooks = generateAllQueryHooks(tables, { reactQueryEnabled });
     for (const hook of queryHooks) {
         files.push({
             path: `queries/${hook.fileName}`,
             content: hook.content,
         });
     }
-    // 4. Generate custom query hooks if available
+    // 5. Generate custom query hooks if available
     let customQueryHooks = [];
     if (customOperations && customOperations.queries.length > 0) {
         customQueryHooks = generateAllCustomQueryHooks({
@@ -49,6 +73,8 @@ export function generate(options) {
             typeRegistry: customOperations.typeRegistry,
             maxDepth,
             skipQueryField,
+            reactQueryEnabled,
+            tableTypeNames,
         });
         for (const hook of customQueryHooks) {
             files.push({
@@ -65,7 +91,10 @@ export function generate(options) {
             : generateQueriesBarrel(tables),
     });
     // 6. Generate table-based mutation hooks (mutations/*.ts)
-    const mutationHooks = generateAllMutationHooks(tables);
+    const mutationHooks = generateAllMutationHooks(tables, {
+        reactQueryEnabled,
+        enumsFromSchemaTypes: generatedEnumNames,
+    });
     for (const hook of mutationHooks) {
         files.push({
             path: `mutations/${hook.fileName}`,
@@ -80,6 +109,8 @@ export function generate(options) {
             typeRegistry: customOperations.typeRegistry,
             maxDepth,
             skipQueryField,
+            reactQueryEnabled,
+            tableTypeNames,
         });
         for (const hook of customMutationHooks) {
             files.push({
@@ -95,10 +126,10 @@ export function generate(options) {
             ? generateCustomMutationsBarrel(tables, customMutationHooks.map((h) => h.operationName))
             : generateMutationsBarrel(tables),
     });
-    // 9. Generate main index.ts barrel
+    // 9. Generate main index.ts barrel (with schema-types if present)
     files.push({
         path: 'index.ts',
-        content: generateMainBarrel(tables),
+        content: generateMainBarrel(tables, hasSchemaTypes),
     });
     return {
         files,

package/esm/cli/codegen/mutations.d.ts

@@ -12,19 +12,29 @@ export interface GeneratedMutationFile {
     fileName: string;
     content: string;
 }
+export interface MutationGeneratorOptions {
+    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
+    reactQueryEnabled?: boolean;
+    /** Enum type names that are available from schema-types.ts */
+    enumsFromSchemaTypes?: string[];
+}
 /**
  * Generate create mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-export declare function generateCreateMutationHook(table: CleanTable): GeneratedMutationFile;
+export declare function generateCreateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
 /**
  * Generate update mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-export declare function generateUpdateMutationHook(table: CleanTable): GeneratedMutationFile | null;
+export declare function generateUpdateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
 /**
  * Generate delete mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-export declare function generateDeleteMutationHook(table: CleanTable): GeneratedMutationFile | null;
+export declare function generateDeleteMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
 /**
  * Generate all mutation hook files for all tables
+ * When reactQueryEnabled is false, returns empty array since mutations require React Query
  */
-export declare function generateAllMutationHooks(tables: CleanTable[]): GeneratedMutationFile[];
+export declare function generateAllMutationHooks(tables: CleanTable[], options?: MutationGeneratorOptions): GeneratedMutationFile[];