@constructive-io/graphql-codegen 2.21.0 → 2.22.0

package/cli/commands/generate.js

@@ -149,17 +149,17 @@ async function generateCommand(options = {}) {
         }
     }
     // 7. Generate code
-    log('Generating code...');
+    console.log('Generating code...');
     const { files: generatedFiles, stats } = (0, codegen_1.generate)({
         tables,
         customOperations: customOperationsData,
         config,
     });
-    log(`  Generated ${stats.queryHooks} table query hooks`);
-    log(`  Generated ${stats.mutationHooks} table mutation hooks`);
-    log(`  Generated ${stats.customQueryHooks} custom query hooks`);
-    log(`  Generated ${stats.customMutationHooks} custom mutation hooks`);
-    log(`  Total files: ${stats.totalFiles}`);
+    console.log(`Generated ${stats.totalFiles} files`);
+    log(`  ${stats.queryHooks} table query hooks`);
+    log(`  ${stats.mutationHooks} table mutation hooks`);
+    log(`  ${stats.customQueryHooks} custom query hooks`);
+    log(`  ${stats.customMutationHooks} custom mutation hooks`);
     if (options.dryRun) {
         return {
             success: true,
@@ -228,9 +228,12 @@ async function loadConfig(options) {
     const config = (0, config_1.resolveConfig)(mergedConfig);
     return { success: true, config };
 }
-async function writeGeneratedFiles(files, outputDir, subdirs) {
+async function writeGeneratedFiles(files, outputDir, subdirs, options = {}) {
+    const { showProgress = true } = options;
     const errors = [];
     const written = [];
+    const total = files.length;
+    const isTTY = process.stdout.isTTY;
     // Ensure output directory exists
     try {
         fs.mkdirSync(outputDir, { recursive: true });
@@ -256,8 +259,20 @@ async function writeGeneratedFiles(files, outputDir, subdirs) {
     if (errors.length > 0) {
         return { success: false, errors };
     }
-    for (const file of files) {
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
         const filePath = path.join(outputDir, file.path);
+        // Show progress
+        if (showProgress) {
+            const progress = Math.round(((i + 1) / total) * 100);
+            if (isTTY) {
+                process.stdout.write(`\rWriting files: ${i + 1}/${total} (${progress}%)`);
+            }
+            else if (i % 100 === 0 || i === total - 1) {
+                // Non-TTY: periodic updates for CI/CD
+                console.log(`Writing files: ${i + 1}/${total}`);
+            }
+        }
         // Ensure parent directory exists
         const parentDir = path.dirname(filePath);
         try {
@@ -277,6 +292,10 @@ async function writeGeneratedFiles(files, outputDir, subdirs) {
             errors.push(`Failed to write ${filePath}: ${message}`);
         }
     }
+    // Clear progress line
+    if (showProgress && isTTY) {
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+    }
     return {
         success: errors.length === 0,
         filesWritten: written,

package/cli/introspect/transform-schema.d.ts

@@ -30,13 +30,29 @@ export declare function transformSchemaToOperations(response: IntrospectionQuery
  * Uses glob-like patterns (supports * wildcard)
  */
 export declare function filterOperations(operations: CleanOperation[], include?: string[], exclude?: string[]): CleanOperation[];
+/**
+ * Result type for table operation names lookup
+ */
+export interface TableOperationNames {
+    queries: Set<string>;
+    mutations: Set<string>;
+}
 /**
  * Get the set of table-related operation names from tables
  * Used to identify which operations are already covered by table generators
  *
- * This includes:
- * - Basic CRUD: all, one, create, update, delete
- * - PostGraphile alternate mutations: updateXByY, deleteXByY (for unique constraints)
+ * IMPORTANT: This uses EXACT matches only from _meta.query fields.
+ * Any operation not explicitly listed in _meta will flow through as a
+ * custom operation, ensuring 100% coverage of the schema.
+ *
+ * Table operations (generated by table generators):
+ * - Queries: all (list), one (single by PK)
+ * - Mutations: create, update (by PK), delete (by PK)
+ *
+ * Custom operations (generated by custom operation generators):
+ * - Unique constraint lookups: *ByUsername, *ByEmail, etc.
+ * - Unique constraint mutations: update*By*, delete*By*
+ * - True custom operations: login, register, bootstrapUser, etc.
  */
 export declare function getTableOperationNames(tables: Array<{
     name: string;
@@ -47,28 +63,24 @@ export declare function getTableOperationNames(tables: Array<{
         update: string | null;
         delete: string | null;
     };
-    inflection?: {
-        tableType: string;
-    };
-}>): {
-    queries: Set<string>;
-    mutations: Set<string>;
-    tableTypePatterns: RegExp[];
-};
+}>): TableOperationNames;
 /**
  * Check if an operation is a table operation (already handled by table generators)
+ *
+ * Uses EXACT match only - no pattern matching. This ensures:
+ * 1. Only operations explicitly in _meta.query are treated as table operations
+ * 2. All other operations (including update*By*, delete*By*) become custom operations
+ * 3. 100% schema coverage is guaranteed
  */
-export declare function isTableOperation(operation: CleanOperation, tableOperationNames: {
-    queries: Set<string>;
-    mutations: Set<string>;
-    tableTypePatterns: RegExp[];
-}): boolean;
+export declare function isTableOperation(operation: CleanOperation, tableOperationNames: TableOperationNames): boolean;
 /**
  * Get only custom operations (not covered by table generators)
+ *
+ * This returns ALL operations that are not exact matches for table CRUD operations.
+ * Includes:
+ * - Unique constraint queries (*ByUsername, *ByEmail, etc.)
+ * - Unique constraint mutations (update*By*, delete*By*)
+ * - True custom operations (login, register, bootstrapUser, etc.)
  */
-export declare function getCustomOperations(operations: CleanOperation[], tableOperationNames: {
-    queries: Set<string>;
-    mutations: Set<string>;
-    tableTypePatterns: RegExp[];
-}): CleanOperation[];
+export declare function getCustomOperations(operations: CleanOperation[], tableOperationNames: TableOperationNames): CleanOperation[];
 export { unwrapType, getBaseTypeName, isNonNull };

package/cli/introspect/transform-schema.js

@@ -38,6 +38,10 @@ function buildTypeRegistry(types) {
         if (type.kind === 'ENUM' && type.enumValues) {
             resolvedType.enumValues = type.enumValues.map((ev) => ev.name);
         }
+        // Resolve possible types for UNION types (no circular refs for names)
+        if (type.kind === 'UNION' && type.possibleTypes) {
+            resolvedType.possibleTypes = type.possibleTypes.map((pt) => pt.name);
+        }
         registry.set(type.name, resolvedType);
     }
     // Second pass: Resolve fields (now that all types exist in registry)
@@ -212,57 +216,63 @@ function matchesPatterns(name, patterns) {
         return name === pattern;
     });
 }
-// ============================================================================
-// Utility Functions
-// ============================================================================
 /**
  * Get the set of table-related operation names from tables
  * Used to identify which operations are already covered by table generators
  *
- * This includes:
- * - Basic CRUD: all, one, create, update, delete
- * - PostGraphile alternate mutations: updateXByY, deleteXByY (for unique constraints)
+ * IMPORTANT: This uses EXACT matches only from _meta.query fields.
+ * Any operation not explicitly listed in _meta will flow through as a
+ * custom operation, ensuring 100% coverage of the schema.
+ *
+ * Table operations (generated by table generators):
+ * - Queries: all (list), one (single by PK)
+ * - Mutations: create, update (by PK), delete (by PK)
+ *
+ * Custom operations (generated by custom operation generators):
+ * - Unique constraint lookups: *ByUsername, *ByEmail, etc.
+ * - Unique constraint mutations: update*By*, delete*By*
+ * - True custom operations: login, register, bootstrapUser, etc.
  */
 function getTableOperationNames(tables) {
     const queries = new Set();
     const mutations = new Set();
-    const tableTypePatterns = [];
     for (const table of tables) {
         if (table.query) {
+            // Add exact query names from _meta
             queries.add(table.query.all);
             queries.add(table.query.one);
+            // Add exact mutation names from _meta
             mutations.add(table.query.create);
             if (table.query.update)
                 mutations.add(table.query.update);
             if (table.query.delete)
                 mutations.add(table.query.delete);
         }
-        // Create patterns to match alternate CRUD mutations (updateXByY, deleteXByY)
-        if (table.inflection?.tableType) {
-            const typeName = table.inflection.tableType;
-            // Match: update{TypeName}By*, delete{TypeName}By*
-            tableTypePatterns.push(new RegExp(`^update${typeName}By`, 'i'));
-            tableTypePatterns.push(new RegExp(`^delete${typeName}By`, 'i'));
-        }
     }
-    return { queries, mutations, tableTypePatterns };
+    return { queries, mutations };
 }
 /**
  * Check if an operation is a table operation (already handled by table generators)
+ *
+ * Uses EXACT match only - no pattern matching. This ensures:
+ * 1. Only operations explicitly in _meta.query are treated as table operations
+ * 2. All other operations (including update*By*, delete*By*) become custom operations
+ * 3. 100% schema coverage is guaranteed
  */
 function isTableOperation(operation, tableOperationNames) {
     if (operation.kind === 'query') {
         return tableOperationNames.queries.has(operation.name);
     }
-    // Check exact match first
-    if (tableOperationNames.mutations.has(operation.name)) {
-        return true;
-    }
-    // Check pattern match for alternate CRUD mutations (updateXByY, deleteXByY)
-    return tableOperationNames.tableTypePatterns.some((pattern) => pattern.test(operation.name));
+    return tableOperationNames.mutations.has(operation.name);
 }
 /**
  * Get only custom operations (not covered by table generators)
+ *
+ * This returns ALL operations that are not exact matches for table CRUD operations.
+ * Includes:
+ * - Unique constraint queries (*ByUsername, *ByEmail, etc.)
+ * - Unique constraint mutations (update*By*, delete*By*)
+ * - True custom operations (login, register, bootstrapUser, etc.)
  */
 function getCustomOperations(operations, tableOperationNames) {
     return operations.filter((op) => !isTableOperation(op, tableOperationNames));

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

@@ -15,8 +15,11 @@ export declare function generateQueriesBarrel(tables: CleanTable[]): string;
 export declare function generateMutationsBarrel(tables: CleanTable[]): string;
 /**
  * Generate the main index.ts barrel file
+ *
+ * @param tables - The tables to include in the SDK
+ * @param hasSchemaTypes - Whether schema-types.ts was generated
  */
-export declare function generateMainBarrel(tables: CleanTable[]): string;
+export declare function generateMainBarrel(tables: CleanTable[], hasSchemaTypes?: boolean): string;
 /**
  * Generate queries barrel including custom query operations
  */

package/esm/cli/codegen/barrel.js

@@ -5,10 +5,7 @@ import { getOperationHookName } from './type-resolver';
  * Generate the queries/index.ts barrel file
  */
 export function generateQueriesBarrel(tables) {
-    const lines = [
-        createFileHeader('Query hooks barrel export'),
-        '',
-    ];
+    const lines = [createFileHeader('Query hooks barrel export'), ''];
     // Export all query hooks
     for (const table of tables) {
         const listHookName = getListQueryHookName(table);
@@ -44,31 +41,40 @@ export function generateMutationsBarrel(tables) {
 }
 /**
  * Generate the main index.ts barrel file
+ *
+ * @param tables - The tables to include in the SDK
+ * @param hasSchemaTypes - Whether schema-types.ts was generated
  */
-export function generateMainBarrel(tables) {
+export function generateMainBarrel(tables, hasSchemaTypes = false) {
     const tableNames = tables.map((t) => t.name).join(', ');
+    const schemaTypesExport = hasSchemaTypes
+        ? `
+// Schema types (input, payload, enum types)
+export * from './schema-types';
+`
+        : '';
     return `/**
  * Auto-generated GraphQL SDK
  * @generated by @constructive-io/graphql-codegen
- * 
+ *
  * Tables: ${tableNames}
- * 
+ *
  * Usage:
- * 
+ *
  * 1. Configure the client:
  * \`\`\`ts
  * import { configure } from './generated';
- * 
+ *
  * configure({
  *   endpoint: 'https://api.example.com/graphql',
  *   headers: { Authorization: 'Bearer <token>' },
  * });
  * \`\`\`
- * 
+ *
  * 2. Use the hooks:
  * \`\`\`tsx
  * import { useCarsQuery, useCreateCarMutation } from './generated';
- * 
+ *
  * function MyComponent() {
  *   const { data, isLoading } = useCarsQuery({ first: 10 });
  *   const { mutate } = useCreateCarMutation();
@@ -82,7 +88,7 @@ export * from './client';
 
 // Entity and filter types
 export * from './types';
-
+${schemaTypesExport}
 // Query hooks
 export * from './queries';
 

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

@@ -23,6 +23,8 @@ export interface GenerateCustomMutationHookOptions {
     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
@@ -36,6 +38,8 @@ export interface GenerateAllCustomMutationHooksOptions {
     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

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

@@ -1,6 +1,6 @@
 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
@@ -21,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,
@@ -38,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'],
@@ -49,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);
@@ -87,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,
     }));
@@ -139,7 +164,7 @@ function generateHookBody(operation, documentConstName, variablesTypeName, resul
  * When reactQueryEnabled is false, returns empty array since mutations require React Query
  */
 export function generateAllCustomMutationHooks(options) {
-    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true } = options;
+    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames } = options;
     return operations
         .filter((op) => op.kind === 'mutation')
         .map((operation) => generateCustomMutationHook({
@@ -148,6 +173,7 @@ export function generateAllCustomMutationHooks(options) {
         maxDepth,
         skipQueryField,
         reactQueryEnabled,
+        tableTypeNames,
     }))
         .filter((result) => result !== null);
 }

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

@@ -23,6 +23,8 @@ export interface GenerateCustomQueryHookOptions {
     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
@@ -35,6 +37,8 @@ export interface GenerateAllCustomQueryHooksOptions {
     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, reactQueryEnabled = 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,
@@ -27,6 +29,19 @@ export function generateCustomQueryHook(options) {
         ? `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) {
@@ -41,21 +56,30 @@ export function generateCustomQueryHook(options) {
         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) {
@@ -126,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,
     }));
@@ -351,7 +375,7 @@ await ${fnName}(queryClient);
  * Generate all custom query hook files
  */
 export function generateAllCustomQueryHooks(options) {
-    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true } = options;
+    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames } = options;
     return operations
         .filter((op) => op.kind === 'query')
         .map((operation) => generateCustomQueryHook({
@@ -360,5 +384,6 @@ export function generateAllCustomQueryHooks(options) {
         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);