@constructive-io/graphql-codegen 3.2.0 → 3.3.0

package/esm/core/codegen/babel-ast.d.ts

@@ -7,7 +7,7 @@
  */
 import generate from '@babel/generator';
 import * as t from '@babel/types';
-export { t, generate };
+export { generate, t };
 /**
  * Generate code from an array of statements
  */

package/esm/core/codegen/babel-ast.js

@@ -8,7 +8,7 @@
 import generate from '@babel/generator';
 import * as t from '@babel/types';
 // Re-export for convenience
-export { t, generate };
+export { generate, t };
 /**
  * Generate code from an array of statements
  */
@@ -47,7 +47,7 @@ export const commentLine = (value) => {
 export function addJSDocComment(node, lines) {
     const commentText = lines.length === 1
         ? `* ${lines[0]} `
-        : `*\n${lines.map(line => ` * ${line}`).join('\n')}\n `;
+        : `*\n${lines.map((line) => ` * ${line}`).join('\n')}\n `;
     if (!node.leadingComments) {
         node.leadingComments = [];
     }

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

@@ -1,8 +1,3 @@
-/**
- * Barrel file generators - creates index.ts files for exports
- *
- * Using Babel AST for generating barrel (index.ts) files with re-exports.
- */
 import type { CleanTable } from '../../types/schema';
 /**
  * Generate the queries/index.ts barrel file
@@ -19,7 +14,6 @@ export declare function generateMutationsBarrel(tables: CleanTable[]): string;
  * @param hasSchemaTypes - Whether schema-types.ts was generated
  */
 export interface MainBarrelOptions {
-    hasSchemaTypes?: boolean;
     hasMutations?: boolean;
     /** Whether query-keys.ts was generated */
     hasQueryKeys?: boolean;

package/esm/core/codegen/barrel.js

@@ -1,7 +1,12 @@
+/**
+ * Barrel file generators - creates index.ts files for exports
+ *
+ * Using Babel AST for generating barrel (index.ts) files with re-exports.
+ */
 import * as t from '@babel/types';
-import { generateCode, addJSDocComment } from './babel-ast';
-import { getListQueryHookName, getSingleQueryHookName, getCreateMutationHookName, getUpdateMutationHookName, getDeleteMutationHookName, hasValidPrimaryKey, } from './utils';
+import { addJSDocComment, generateCode } from './babel-ast';
 import { getOperationHookName } from './type-resolver';
+import { getCreateMutationHookName, getDeleteMutationHookName, getListQueryHookName, getSingleQueryHookName, getUpdateMutationHookName, hasValidPrimaryKey, } from './utils';
 /**
  * Helper to create export * from './module' statement
  */
@@ -41,14 +46,14 @@ export function generateMutationsBarrel(tables) {
     // Export all mutation hooks
     for (const table of tables) {
         const createHookName = getCreateMutationHookName(table);
-        const updateHookName = getUpdateMutationHookName(table);
-        const deleteHookName = getDeleteMutationHookName(table);
         statements.push(exportAllFrom(`./${createHookName}`));
-        // Only add update/delete if they exist
-        if (table.query?.update !== null) {
+        // Only add update/delete if they exist AND table has valid PK
+        if (table.query?.update !== null && hasValidPrimaryKey(table)) {
+            const updateHookName = getUpdateMutationHookName(table);
             statements.push(exportAllFrom(`./${updateHookName}`));
         }
-        if (table.query?.delete !== null) {
+        if (table.query?.delete !== null && hasValidPrimaryKey(table)) {
+            const deleteHookName = getDeleteMutationHookName(table);
             statements.push(exportAllFrom(`./${deleteHookName}`));
         }
     }
@@ -64,17 +69,11 @@ export function generateMutationsBarrel(tables) {
 }
 export function generateMainBarrel(tables, options = {}) {
     const opts = options;
-    const { hasSchemaTypes = false, hasMutations = true, hasQueryKeys = false, hasMutationKeys = false, hasInvalidation = false, } = opts;
+    const { hasMutations = true, hasQueryKeys = false, hasMutationKeys = false, hasInvalidation = false, } = opts;
     const tableNames = tables.map((tbl) => tbl.name).join(', ');
     const statements = [];
-    // Client configuration
+    // Client configuration (ORM wrapper with configure/getClient)
     statements.push(exportAllFrom('./client'));
-    // Entity and filter types
-    statements.push(exportAllFrom('./types'));
-    // Schema types (input, payload, enum types)
-    if (hasSchemaTypes) {
-        statements.push(exportAllFrom('./schema-types'));
-    }
     // Centralized query keys (for cache management)
     if (hasQueryKeys) {
         statements.push(exportAllFrom('./query-keys'));
@@ -118,8 +117,12 @@ export function generateMainBarrel(tables, options = {}) {
             "import { useCarsQuery, useCreateCarMutation } from './generated';",
             '',
             'function MyComponent() {',
-            '  const { data, isLoading } = useCarsQuery({ first: 10 });',
-            '  const { mutate } = useCreateCarMutation();',
+            '  const { data, isLoading } = useCarsQuery({',
+            '    selection: { fields: { id: true }, first: 10 },',
+            '  });',
+            '  const { mutate } = useCreateCarMutation({',
+            '    selection: { fields: { id: true } },',
+            '  });',
             '  // ...',
             '}',
             '```',
@@ -208,15 +211,15 @@ export function generateCustomMutationsBarrel(tables, customMutationNames) {
             statements.push(exportAllFrom(`./${createHookName}`));
             exportedHooks.add(createHookName);
         }
-        // Only add update/delete if they exist
-        if (table.query?.update !== null) {
+        // Only add update/delete if they exist AND table has valid PK
+        if (table.query?.update !== null && hasValidPrimaryKey(table)) {
             const updateHookName = getUpdateMutationHookName(table);
             if (!exportedHooks.has(updateHookName)) {
                 statements.push(exportAllFrom(`./${updateHookName}`));
                 exportedHooks.add(updateHookName);
             }
         }
-        if (table.query?.delete !== null) {
+        if (table.query?.delete !== null && hasValidPrimaryKey(table)) {
             const deleteHookName = getDeleteMutationHookName(table);
             if (!exportedHooks.has(deleteHookName)) {
                 statements.push(exportAllFrom(`./${deleteHookName}`));

package/esm/core/codegen/client.d.ts

@@ -1,14 +1,4 @@
-export interface GenerateClientFileOptions {
-    /**
-     * Generate browser-compatible code using native fetch
-     * When true (default), uses native W3C fetch API
-     * When false, uses undici fetch with dispatcher support for localhost DNS resolution
-     * @default true
-     */
-    browserCompatible?: boolean;
-}
 /**
- * Generate client.ts content
- * @param options - Generation options
+ * Generate client.ts content - ORM client wrapper with configure/getClient
  */
-export declare function generateClientFile(options?: GenerateClientFileOptions): string;
+export declare function generateClientFile(): string;

package/esm/core/codegen/client.js

@@ -1,43 +1,29 @@
 /**
- * Client generator - generates client.ts with configure() and execute()
+ * Client generator - generates client.ts as ORM client wrapper
  *
- * Reads from template files in the templates/ directory for proper type checking.
+ * Uses template-copy pattern: reads hooks-client.ts from templates/
+ * and writes it to the output directory with a generated file header.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { getGeneratedFileHeader } from './utils';
-/**
- * Find a template file path.
- * Templates are at ./templates/ relative to this file in both src/ and dist/.
- */
 function findTemplateFile(templateName) {
     const templatePath = path.join(__dirname, 'templates', templateName);
     if (fs.existsSync(templatePath)) {
         return templatePath;
     }
-    throw new Error(`Could not find template file: ${templateName}. ` +
-        `Searched in: ${templatePath}`);
+    throw new Error(`Could not find template file: ${templateName}. Searched in: ${templatePath}`);
 }
-/**
- * Read a template file and replace the header with generated file header
- */
 function readTemplateFile(templateName, description) {
     const templatePath = findTemplateFile(templateName);
     let content = fs.readFileSync(templatePath, 'utf-8');
-    // Replace the source file header comment with the generated file header
-    // Match the header pattern used in template files
     const headerPattern = /\/\*\*[\s\S]*?\* NOTE: This file is read at codegen time and written to output\.[\s\S]*?\*\/\n*/;
     content = content.replace(headerPattern, getGeneratedFileHeader(description) + '\n');
     return content;
 }
 /**
- * Generate client.ts content
- * @param options - Generation options
+ * Generate client.ts content - ORM client wrapper with configure/getClient
  */
-export function generateClientFile(options = {}) {
-    const { browserCompatible = true } = options;
-    const templateName = browserCompatible
-        ? 'client.browser.ts'
-        : 'client.node.ts';
-    return readTemplateFile(templateName, 'GraphQL client configuration and execution');
+export function generateClientFile() {
+    return readTemplateFile('hooks-client.ts', 'ORM client wrapper for React Query hooks');
 }

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

@@ -1,15 +1,3 @@
-/**
- * Custom mutation hook generators for non-table operations
- *
- * Generates hooks for operations discovered via schema introspection
- * that are NOT table CRUD operations (e.g., login, register, etc.)
- *
- * Output structure:
- * mutations/
- *   useLoginMutation.ts
- *   useRegisterMutation.ts
- *   ...
- */
 import type { CleanOperation, TypeRegistry } from '../../types/schema';
 export interface GeneratedCustomMutationFile {
     fileName: string;
@@ -19,7 +7,6 @@ export interface GeneratedCustomMutationFile {
 export interface GenerateCustomMutationHookOptions {
     operation: CleanOperation;
     typeRegistry: TypeRegistry;
-    maxDepth?: number;
     skipQueryField?: boolean;
     reactQueryEnabled?: boolean;
     tableTypeNames?: Set<string>;
@@ -29,7 +16,6 @@ export declare function generateCustomMutationHook(options: GenerateCustomMutati
 export interface GenerateAllCustomMutationHooksOptions {
     operations: CleanOperation[];
     typeRegistry: TypeRegistry;
-    maxDepth?: number;
     skipQueryField?: boolean;
     reactQueryEnabled?: boolean;
     tableTypeNames?: Set<string>;

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

@@ -1,16 +1,23 @@
+/**
+ * Custom mutation hook generators for non-table operations (Babel AST-based)
+ *
+ * Generates hooks for operations discovered via schema introspection
+ * that are NOT table CRUD operations (e.g., login, register, etc.)
+ *
+ * Delegates to ORM custom mutation operations:
+ *   getClient().mutation.operationName(args, { select }).unwrap()
+ *
+ * Output structure:
+ * mutations/
+ *   useLoginMutation.ts
+ *   useRegisterMutation.ts
+ *   ...
+ */
 import * as t from '@babel/types';
-import { generateCode, addJSDocComment, typedParam, createTypedCallExpression } from './babel-ast';
-import { buildCustomMutationString } from './schema-gql-ast';
-import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, createTypeTracker, } from './type-resolver';
-import { getGeneratedFileHeader } from './utils';
-function generateVariablesProperties(args, tracker) {
-    return args.map((arg) => ({
-        name: arg.name,
-        type: typeRefToTsType(arg.type, tracker),
-        optional: !isTypeRequired(arg.type),
-        docs: arg.description ? [arg.description] : undefined,
-    }));
-}
+import { buildSelectionArgsCall, callExpr, constDecl, createFunctionParam, createImportDeclaration, createSTypeParam, createTypeReExport, customSelectResultTypeLiteral, destructureParamsWithSelection, exportDeclareFunction, exportFunction, generateHookFileCode, getClientCustomCallUnwrap, objectProp, omitType, returnUseMutation, selectionConfigType, spreadObj, sRef, typeRef, useMutationOptionsType, useMutationResultType, voidStatement, } from './hooks-ast';
+import { getSelectTypeName } from './select-helpers';
+import { createTypeTracker, getOperationFileName, getOperationHookName, getTypeBaseName, typeRefToTsType, } from './type-resolver';
+import { ucFirst } from './utils';
 export function generateCustomMutationHook(options) {
     const { operation, reactQueryEnabled = true } = options;
     if (!reactQueryEnabled) {
@@ -26,95 +33,140 @@ export function generateCustomMutationHook(options) {
     }
 }
 function generateCustomMutationHookInternal(options) {
-    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, tableTypeNames, useCentralizedKeys = true, } = options;
+    const { operation, typeRegistry, tableTypeNames, useCentralizedKeys = true, } = options;
     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');
+    const varTypeName = `${ucFirst(operation.name)}Variables`;
     const tracker = createTypeTracker({ tableTypeNames });
-    const mutationDocument = buildCustomMutationString({
-        operation,
-        typeRegistry,
-        maxDepth,
-        skipQueryField,
-    });
+    const hasArgs = operation.args.length > 0;
+    typeRefToTsType(operation.returnType, tracker);
+    for (const arg of operation.args) {
+        typeRefToTsType(arg.type, tracker);
+    }
+    const selectTypeName = getSelectTypeName(operation.returnType);
+    const payloadTypeName = getTypeBaseName(operation.returnType);
+    const hasSelect = !!selectTypeName && !!payloadTypeName;
     const statements = [];
-    const variablesProps = operation.args.length > 0
-        ? generateVariablesProperties(operation.args, tracker)
-        : [];
-    const resultType = typeRefToTsType(operation.returnType, tracker);
-    const schemaTypes = tracker.getImportableTypes();
-    const tableTypes = tracker.getTableTypes();
-    const reactQueryImport = t.importDeclaration([t.importSpecifier(t.identifier('useMutation'), t.identifier('useMutation'))], t.stringLiteral('@tanstack/react-query'));
-    statements.push(reactQueryImport);
-    const reactQueryTypeImport = t.importDeclaration([t.importSpecifier(t.identifier('UseMutationOptions'), t.identifier('UseMutationOptions'))], t.stringLiteral('@tanstack/react-query'));
-    reactQueryTypeImport.importKind = 'type';
-    statements.push(reactQueryTypeImport);
-    const clientImport = t.importDeclaration([t.importSpecifier(t.identifier('execute'), t.identifier('execute'))], t.stringLiteral('../client'));
-    statements.push(clientImport);
-    if (tableTypes.length > 0) {
-        const typesImport = t.importDeclaration(tableTypes.map((tt) => t.importSpecifier(t.identifier(tt), t.identifier(tt))), t.stringLiteral('../types'));
-        typesImport.importKind = 'type';
-        statements.push(typesImport);
+    // Imports
+    statements.push(createImportDeclaration('@tanstack/react-query', ['useMutation']));
+    statements.push(createImportDeclaration('@tanstack/react-query', ['UseMutationOptions', 'UseMutationResult'], true));
+    statements.push(createImportDeclaration('../client', ['getClient']));
+    statements.push(createImportDeclaration('../selection', ['buildSelectionArgs']));
+    statements.push(createImportDeclaration('../selection', ['SelectionConfig'], true));
+    if (useCentralizedKeys) {
+        statements.push(createImportDeclaration('../mutation-keys', ['customMutationKeys']));
     }
-    if (schemaTypes.length > 0) {
-        const schemaTypesImport = t.importDeclaration(schemaTypes.map((st) => t.importSpecifier(t.identifier(st), t.identifier(st))), t.stringLiteral('../schema-types'));
-        schemaTypesImport.importKind = 'type';
-        statements.push(schemaTypesImport);
+    if (hasArgs) {
+        statements.push(createImportDeclaration('../../orm/mutation', [varTypeName], true));
     }
-    if (useCentralizedKeys) {
-        const mutationKeyImport = t.importDeclaration([t.importSpecifier(t.identifier('customMutationKeys'), t.identifier('customMutationKeys'))], t.stringLiteral('../mutation-keys'));
-        statements.push(mutationKeyImport);
+    const inputTypeImports = [];
+    if (hasSelect) {
+        inputTypeImports.push(selectTypeName);
+        inputTypeImports.push(payloadTypeName);
     }
-    const mutationDocConst = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier(documentConstName), t.templateLiteral([t.templateElement({ raw: '\n' + mutationDocument, cooked: '\n' + mutationDocument }, true)], [])),
-    ]);
-    const mutationDocExport = t.exportNamedDeclaration(mutationDocConst);
-    addJSDocComment(mutationDocExport, ['GraphQL mutation document']);
-    statements.push(mutationDocExport);
-    if (operation.args.length > 0) {
-        const variablesInterfaceProps = variablesProps.map((vp) => {
-            const prop = t.tsPropertySignature(t.identifier(vp.name), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(vp.type))));
-            prop.optional = vp.optional;
-            return prop;
-        });
-        const variablesInterface = t.tsInterfaceDeclaration(t.identifier(variablesTypeName), null, null, t.tsInterfaceBody(variablesInterfaceProps));
-        statements.push(t.exportNamedDeclaration(variablesInterface));
+    else {
+        for (const refType of tracker.referencedTypes) {
+            if (!inputTypeImports.includes(refType)) {
+                inputTypeImports.push(refType);
+            }
+        }
     }
-    const resultInterfaceBody = t.tsInterfaceBody([
-        t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(resultType)))),
-    ]);
-    const resultInterface = t.tsInterfaceDeclaration(t.identifier(resultTypeName), null, null, resultInterfaceBody);
-    statements.push(t.exportNamedDeclaration(resultInterface));
-    const hasArgs = operation.args.length > 0;
-    const hookBodyStatements = [];
-    const mutationOptions = [];
-    if (useCentralizedKeys) {
-        mutationOptions.push(t.objectProperty(t.identifier('mutationKey'), t.callExpression(t.memberExpression(t.identifier('customMutationKeys'), t.identifier(operation.name)), [])));
+    if (inputTypeImports.length > 0) {
+        statements.push(createImportDeclaration('../../orm/input-types', inputTypeImports, true));
     }
+    if (hasSelect) {
+        statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'StrictSelect'], true));
+    }
+    // Re-exports
     if (hasArgs) {
-        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)))], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables')], [
-            t.tsTypeReference(t.identifier(resultTypeName)),
-            t.tsTypeReference(t.identifier(variablesTypeName)),
-        ]))));
+        statements.push(createTypeReExport([varTypeName], '../../orm/mutation'));
+    }
+    if (hasSelect) {
+        statements.push(createTypeReExport([selectTypeName], '../../orm/input-types'));
+    }
+    // Hook
+    if (hasSelect) {
+        const mutationVarType = hasArgs
+            ? typeRef(varTypeName)
+            : t.tsVoidKeyword();
+        const selectedResultType = (sel) => customSelectResultTypeLiteral(operation.name, operation.returnType, payloadTypeName, sel);
+        // Overload 1: with selection.fields
+        const o1ParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(t.tsParenthesizedType(t.tsIntersectionType([
+                    t.tsTypeLiteral([
+                        t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(sRef())),
+                    ]),
+                    typeRef('StrictSelect', [sRef(), typeRef(selectTypeName)]),
+                ])))),
+            ]),
+            useMutationOptionsType(selectedResultType(sRef()), mutationVarType),
+        ]);
+        statements.push(exportDeclareFunction(hookName, createSTypeParam(selectTypeName), [createFunctionParam('params', o1ParamType)], useMutationResultType(selectedResultType(sRef()), mutationVarType)));
+        // Implementation
+        const implSelProp = t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(selectionConfigType(typeRef(selectTypeName))));
+        const implParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([implSelProp]),
+            omitType(typeRef('UseMutationOptions', [
+                t.tsAnyKeyword(),
+                typeRef('Error'),
+                mutationVarType,
+            ]), ['mutationFn']),
+        ]);
+        const body = [];
+        body.push(buildSelectionArgsCall(selectTypeName));
+        body.push(destructureParamsWithSelection('mutationOptions'));
+        body.push(voidStatement('_selection'));
+        const mutationKeyExpr = useCentralizedKeys
+            ? callExpr(t.memberExpression(t.identifier('customMutationKeys'), t.identifier(operation.name)), [])
+            : undefined;
+        const selectArgExpr = t.objectExpression([
+            objectProp('select', t.memberExpression(t.identifier('args'), t.identifier('select'))),
+        ]);
+        let mutationFnExpr;
+        if (hasArgs) {
+            const variablesParam = createFunctionParam('variables', typeRef(varTypeName));
+            mutationFnExpr = t.arrowFunctionExpression([variablesParam], getClientCustomCallUnwrap('mutation', operation.name, [t.identifier('variables')], selectArgExpr));
+        }
+        else {
+            mutationFnExpr = t.arrowFunctionExpression([], getClientCustomCallUnwrap('mutation', operation.name, [], selectArgExpr));
+        }
+        body.push(returnUseMutation(mutationFnExpr, [spreadObj(t.identifier('mutationOptions'))], mutationKeyExpr));
+        statements.push(exportFunction(hookName, null, [createFunctionParam('params', implParamType)], body));
     }
     else {
-        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName)], [t.tsTypeReference(t.identifier(resultTypeName))]))));
+        // Without select: simple hook (scalar return type)
+        const resultTypeStr = typeRefToTsType(operation.returnType, tracker);
+        const resultTypeLiteral = t.tsTypeLiteral([
+            t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(typeRef(resultTypeStr))),
+        ]);
+        const mutationVarType = hasArgs
+            ? typeRef(varTypeName)
+            : t.tsVoidKeyword();
+        const optionsType = omitType(typeRef('UseMutationOptions', [
+            resultTypeLiteral,
+            typeRef('Error'),
+            mutationVarType,
+        ]), ['mutationFn']);
+        const body = [];
+        body.push(constDecl('mutationOptions', t.logicalExpression('??', t.identifier('params'), t.objectExpression([]))));
+        const mutationKeyExpr = useCentralizedKeys
+            ? callExpr(t.memberExpression(t.identifier('customMutationKeys'), t.identifier(operation.name)), [])
+            : undefined;
+        let mutationFnExpr;
+        if (hasArgs) {
+            const variablesParam = createFunctionParam('variables', typeRef(varTypeName));
+            mutationFnExpr = t.arrowFunctionExpression([variablesParam], getClientCustomCallUnwrap('mutation', operation.name, [
+                t.identifier('variables'),
+            ]));
+        }
+        else {
+            mutationFnExpr = t.arrowFunctionExpression([], getClientCustomCallUnwrap('mutation', operation.name, []));
+        }
+        body.push(returnUseMutation(mutationFnExpr, [spreadObj(t.identifier('mutationOptions'))], mutationKeyExpr));
+        statements.push(exportFunction(hookName, null, [createFunctionParam('params', optionsType, true)], body));
     }
-    mutationOptions.push(t.spreadElement(t.identifier('options')));
-    hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useMutation'), [t.objectExpression(mutationOptions)])));
-    const optionsType = hasArgs
-        ? `Omit<UseMutationOptions<${resultTypeName}, Error, ${variablesTypeName}>, 'mutationFn'>`
-        : `Omit<UseMutationOptions<${resultTypeName}, Error, void>, 'mutationFn'>`;
-    const optionsParam = t.identifier('options');
-    optionsParam.optional = true;
-    optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(optionsType)));
-    const hookFunc = t.functionDeclaration(t.identifier(hookName), [optionsParam], t.blockStatement(hookBodyStatements));
-    const hookExport = t.exportNamedDeclaration(hookFunc);
-    statements.push(hookExport);
-    const code = generateCode(statements);
-    const content = getGeneratedFileHeader(`Custom mutation hook for ${operation.name}`) + '\n\n' + code;
+    const content = generateHookFileCode(`Custom mutation hook for ${operation.name}`, statements);
     return {
         fileName,
         content,
@@ -122,13 +174,12 @@ function generateCustomMutationHookInternal(options) {
     };
 }
 export function generateAllCustomMutationHooks(options) {
-    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames, useCentralizedKeys = true, } = options;
+    const { operations, typeRegistry, skipQueryField = true, reactQueryEnabled = true, tableTypeNames, useCentralizedKeys = true, } = options;
     return operations
         .filter((op) => op.kind === 'mutation')
         .map((operation) => generateCustomMutationHook({
         operation,
         typeRegistry,
-        maxDepth,
         skipQueryField,
         reactQueryEnabled,
         tableTypeNames,

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

@@ -1,15 +1,3 @@
-/**
- * Custom query hook generators for non-table operations
- *
- * Generates hooks for operations discovered via schema introspection
- * that are NOT table CRUD operations (e.g., currentUser, nodeById, etc.)
- *
- * Output structure:
- * queries/
- *   useCurrentUserQuery.ts
- *   useNodeQuery.ts
- *   ...
- */
 import type { CleanOperation, TypeRegistry } from '../../types/schema';
 export interface GeneratedCustomQueryFile {
     fileName: string;
@@ -19,7 +7,6 @@ export interface GeneratedCustomQueryFile {
 export interface GenerateCustomQueryHookOptions {
     operation: CleanOperation;
     typeRegistry: TypeRegistry;
-    maxDepth?: number;
     skipQueryField?: boolean;
     reactQueryEnabled?: boolean;
     tableTypeNames?: Set<string>;
@@ -29,7 +16,6 @@ export declare function generateCustomQueryHook(options: GenerateCustomQueryHook
 export interface GenerateAllCustomQueryHooksOptions {
     operations: CleanOperation[];
     typeRegistry: TypeRegistry;
-    maxDepth?: number;
     skipQueryField?: boolean;
     reactQueryEnabled?: boolean;
     tableTypeNames?: Set<string>;