@constructive-io/graphql-codegen 3.2.1 → 3.3.0

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

@@ -1,240 +1,531 @@
+/**
+ * Custom query 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., currentUser, nodeById, etc.)
+ *
+ * Delegates to ORM custom query operations:
+ *   getClient().query.operationName(args, { select }).unwrap()
+ *
+ * Output structure:
+ * queries/
+ *   useCurrentUserQuery.ts
+ *   useNodeQuery.ts
+ *   ...
+ */
 import * as t from '@babel/types';
-import { generateCode, addJSDocComment, typedParam, createTypedCallExpression } from './babel-ast';
-import { buildCustomQueryString } from './schema-gql-ast';
-import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, getQueryKeyName, createTypeTracker, } from './type-resolver';
-import { ucFirst, 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 { asConst } from './babel-ast';
+import { addJSDocComment, buildSelectionArgsCall, callExpr, constDecl, createFunctionParam, createImportDeclaration, createSAndTDataTypeParams, createSTypeParam, createTDataTypeParam, createTypeReExport, customSelectResultTypeLiteral, destructureParamsWithSelection, exportAsyncDeclareFunction, exportAsyncFunction, exportDeclareFunction, exportFunction, generateHookFileCode, getClientCustomCallUnwrap, objectProp, omitType, returnUseQuery, selectionConfigType, spreadObj, sRef, typeRef, useQueryOptionsImplType, voidStatement, } from './hooks-ast';
+import { getSelectTypeName } from './select-helpers';
+import { createTypeTracker, getOperationFileName, getOperationHookName, getQueryKeyName, getTypeBaseName, isTypeRequired, typeRefToTsType, } from './type-resolver';
+import { ucFirst } from './utils';
 export function generateCustomQueryHook(options) {
-    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames, useCentralizedKeys = true, } = options;
+    const { operation, typeRegistry, reactQueryEnabled = true, tableTypeNames, useCentralizedKeys = true, } = options;
     const hookName = getOperationHookName(operation.name, 'query');
     const fileName = getOperationFileName(operation.name, 'query');
-    const variablesTypeName = getOperationVariablesTypeName(operation.name, 'query');
-    const resultTypeName = getOperationResultTypeName(operation.name, 'query');
-    const documentConstName = getDocumentConstName(operation.name, 'query');
     const queryKeyName = getQueryKeyName(operation.name);
+    const varTypeName = `${ucFirst(operation.name)}Variables`;
     const tracker = createTypeTracker({ tableTypeNames });
-    const queryDocument = buildCustomQueryString({
-        operation,
-        typeRegistry,
-        maxDepth,
-        skipQueryField,
-    });
-    const statements = [];
-    const variablesProps = operation.args.length > 0
-        ? generateVariablesProperties(operation.args, tracker)
-        : [];
+    const hasArgs = operation.args.length > 0;
+    const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
     const resultType = typeRefToTsType(operation.returnType, tracker);
-    const schemaTypes = tracker.getImportableTypes();
-    const tableTypes = tracker.getTableTypes();
+    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 = [];
+    // Imports
     if (reactQueryEnabled) {
-        const reactQueryImport = t.importDeclaration([t.importSpecifier(t.identifier('useQuery'), t.identifier('useQuery'))], t.stringLiteral('@tanstack/react-query'));
-        statements.push(reactQueryImport);
-        const reactQueryTypeImport = t.importDeclaration([
-            t.importSpecifier(t.identifier('UseQueryOptions'), t.identifier('UseQueryOptions')),
-            t.importSpecifier(t.identifier('QueryClient'), t.identifier('QueryClient')),
-        ], t.stringLiteral('@tanstack/react-query'));
-        reactQueryTypeImport.importKind = 'type';
-        statements.push(reactQueryTypeImport);
+        statements.push(createImportDeclaration('@tanstack/react-query', ['useQuery']));
+        statements.push(createImportDeclaration('@tanstack/react-query', ['UseQueryOptions', 'UseQueryResult', 'QueryClient'], true));
     }
-    const clientImport = t.importDeclaration([t.importSpecifier(t.identifier('execute'), t.identifier('execute'))], t.stringLiteral('../client'));
-    statements.push(clientImport);
-    const clientTypeImport = t.importDeclaration([t.importSpecifier(t.identifier('ExecuteOptions'), t.identifier('ExecuteOptions'))], t.stringLiteral('../client'));
-    clientTypeImport.importKind = 'type';
-    statements.push(clientTypeImport);
-    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);
+    statements.push(createImportDeclaration('../client', ['getClient']));
+    statements.push(createImportDeclaration('../selection', ['buildSelectionArgs']));
+    statements.push(createImportDeclaration('../selection', ['SelectionConfig'], true));
+    if (useCentralizedKeys) {
+        statements.push(createImportDeclaration('../query-keys', ['customQueryKeys']));
     }
-    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/query', [varTypeName], true));
     }
-    if (useCentralizedKeys) {
-        const queryKeyImport = t.importDeclaration([t.importSpecifier(t.identifier('customQueryKeys'), t.identifier('customQueryKeys'))], t.stringLiteral('../query-keys'));
-        statements.push(queryKeyImport);
+    const inputTypeImports = [];
+    if (hasSelect) {
+        inputTypeImports.push(selectTypeName);
+        inputTypeImports.push(payloadTypeName);
+    }
+    else {
+        const baseName = getTypeBaseName(operation.returnType);
+        if (baseName && !tracker.referencedTypes.has('__skip__')) {
+            for (const refType of tracker.referencedTypes) {
+                if (!inputTypeImports.includes(refType)) {
+                    inputTypeImports.push(refType);
+                }
+            }
+        }
+    }
+    if (inputTypeImports.length > 0) {
+        statements.push(createImportDeclaration('../../orm/input-types', inputTypeImports, true));
+    }
+    if (hasSelect) {
+        statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'StrictSelect'], true));
     }
-    const queryDocConst = t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier(documentConstName), t.templateLiteral([t.templateElement({ raw: '\n' + queryDocument, cooked: '\n' + queryDocument }, true)], [])),
-    ]);
-    const queryDocExport = t.exportNamedDeclaration(queryDocConst);
-    addJSDocComment(queryDocExport, ['GraphQL query document']);
-    statements.push(queryDocExport);
-    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));
+    // Re-exports
+    if (hasArgs) {
+        statements.push(createTypeReExport([varTypeName], '../../orm/query'));
+    }
+    if (hasSelect) {
+        statements.push(createTypeReExport([selectTypeName], '../../orm/input-types'));
     }
-    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));
+    // Query key
     if (useCentralizedKeys) {
-        const queryKeyConst = t.variableDeclaration('const', [
+        const keyDecl = t.exportNamedDeclaration(t.variableDeclaration('const', [
             t.variableDeclarator(t.identifier(queryKeyName), t.memberExpression(t.identifier('customQueryKeys'), t.identifier(operation.name))),
+        ]));
+        addJSDocComment(keyDecl, [
+            'Query key factory - re-exported from query-keys.ts',
         ]);
-        const queryKeyExport = t.exportNamedDeclaration(queryKeyConst);
-        addJSDocComment(queryKeyExport, ['Query key factory - re-exported from query-keys.ts']);
-        statements.push(queryKeyExport);
+        statements.push(keyDecl);
     }
-    else if (operation.args.length > 0) {
-        const queryKeyArrow = t.arrowFunctionExpression([typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)), true)], t.tsAsExpression(t.arrayExpression([t.stringLiteral(operation.name), t.identifier('variables')]), t.tsTypeReference(t.identifier('const'))));
-        const queryKeyConst = t.variableDeclaration('const', [
-            t.variableDeclarator(t.identifier(queryKeyName), queryKeyArrow),
-        ]);
-        const queryKeyExport = t.exportNamedDeclaration(queryKeyConst);
-        addJSDocComment(queryKeyExport, ['Query key factory for caching']);
-        statements.push(queryKeyExport);
+    else if (hasArgs) {
+        const keyFn = t.arrowFunctionExpression([createFunctionParam('variables', typeRef(varTypeName), true)], asConst(t.arrayExpression([
+            t.stringLiteral(operation.name),
+            t.identifier('variables'),
+        ])));
+        const keyDecl = t.exportNamedDeclaration(t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier(queryKeyName), keyFn),
+        ]));
+        addJSDocComment(keyDecl, ['Query key factory for caching']);
+        statements.push(keyDecl);
     }
     else {
-        const queryKeyArrow = t.arrowFunctionExpression([], t.tsAsExpression(t.arrayExpression([t.stringLiteral(operation.name)]), t.tsTypeReference(t.identifier('const'))));
-        const queryKeyConst = t.variableDeclaration('const', [
-            t.variableDeclarator(t.identifier(queryKeyName), queryKeyArrow),
-        ]);
-        const queryKeyExport = t.exportNamedDeclaration(queryKeyConst);
-        addJSDocComment(queryKeyExport, ['Query key factory for caching']);
-        statements.push(queryKeyExport);
+        const keyFn = t.arrowFunctionExpression([], asConst(t.arrayExpression([t.stringLiteral(operation.name)])));
+        const keyDecl = t.exportNamedDeclaration(t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier(queryKeyName), keyFn),
+        ]));
+        addJSDocComment(keyDecl, ['Query key factory for caching']);
+        statements.push(keyDecl);
     }
+    // Helper to build query key call expression
+    const buildQueryKeyCall = (withVars) => {
+        if (useCentralizedKeys) {
+            return withVars
+                ? callExpr(t.identifier(queryKeyName), [t.identifier('variables')])
+                : callExpr(t.identifier(queryKeyName), []);
+        }
+        return withVars
+            ? callExpr(t.identifier(queryKeyName), [t.identifier('variables')])
+            : callExpr(t.identifier(queryKeyName), []);
+    };
+    // Helper to build the fields+StrictSelect intersection type
+    const fieldsSelectionType = (s) => t.tsParenthesizedType(t.tsIntersectionType([
+        t.tsTypeLiteral([
+            t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(s)),
+        ]),
+        typeRef('StrictSelect', [s, typeRef(selectTypeName)]),
+    ]));
+    const selectedResultType = (sel) => customSelectResultTypeLiteral(operation.name, operation.returnType, payloadTypeName, sel);
+    // Hook
     if (reactQueryEnabled) {
-        const hasArgs = operation.args.length > 0;
-        const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
-        const hookBodyStatements = [];
-        const useQueryOptions = [];
-        if (hasArgs) {
-            useQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [t.identifier('variables')])));
-            useQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables')], [
-                t.tsTypeReference(t.identifier(resultTypeName)),
-                t.tsTypeReference(t.identifier(variablesTypeName)),
-            ]))));
-            if (hasRequiredArgs) {
-                useQueryOptions.push(t.objectProperty(t.identifier('enabled'), t.logicalExpression('&&', t.unaryExpression('!', t.unaryExpression('!', t.identifier('variables'))), t.binaryExpression('!==', t.optionalMemberExpression(t.identifier('options'), t.identifier('enabled'), false, true), t.booleanLiteral(false)))));
+        const description = operation.description || `Query hook for ${operation.name}`;
+        const argNames = operation.args.map((a) => a.name).join(', ');
+        const exampleCall = hasArgs
+            ? hasSelect
+                ? `${hookName}({ variables: { ${argNames} }, selection: { fields: { id: true } } })`
+                : `${hookName}({ variables: { ${argNames} } })`
+            : hasSelect
+                ? `${hookName}({ selection: { fields: { id: true } } })`
+                : `${hookName}()`;
+        if (hasSelect) {
+            // Overload 1: with selection.fields
+            const o1Props = [];
+            if (hasArgs) {
+                const varType = hasRequiredArgs
+                    ? typeRef(varTypeName)
+                    : t.tsUnionType([typeRef(varTypeName), t.tsUndefinedKeyword()]);
+                o1Props.push(t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(varType)));
             }
+            o1Props.push(t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(fieldsSelectionType(sRef()))));
+            const o1ParamType = t.tsIntersectionType([
+                t.tsTypeLiteral(o1Props),
+                omitType(typeRef('UseQueryOptions', [
+                    selectedResultType(sRef()),
+                    typeRef('Error'),
+                    typeRef('TData'),
+                ]), ['queryKey', 'queryFn']),
+            ]);
+            const o1 = exportDeclareFunction(hookName, createSAndTDataTypeParams(selectTypeName, selectedResultType(sRef())), [createFunctionParam('params', o1ParamType)], typeRef('UseQueryResult', [typeRef('TData')]));
+            addJSDocComment(o1, [
+                description,
+                '',
+                '@example',
+                '```tsx',
+                `const { data, isLoading } = ${exampleCall};`,
+                '',
+                `if (data?.${operation.name}) {`,
+                `  console.log(data.${operation.name});`,
+                '}',
+                '```',
+            ]);
+            statements.push(o1);
+            // Implementation
+            const implProps = [];
+            if (hasArgs) {
+                const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+                if (!hasRequiredArgs)
+                    varProp.optional = true;
+                implProps.push(varProp);
+            }
+            const implSelProp = t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(selectionConfigType(typeRef(selectTypeName))));
+            implProps.push(implSelProp);
+            const implParamType = t.tsIntersectionType([
+                t.tsTypeLiteral(implProps),
+                useQueryOptionsImplType(),
+            ]);
+            const implParam = createFunctionParam('params', implParamType, false);
+            const body = [];
+            if (hasArgs) {
+                body.push(constDecl('variables', hasRequiredArgs
+                    ? t.memberExpression(t.identifier('params'), t.identifier('variables'))
+                    : t.logicalExpression('??', t.memberExpression(t.identifier('params'), t.identifier('variables')), t.objectExpression([]))));
+            }
+            body.push(buildSelectionArgsCall(selectTypeName));
+            if (hasArgs) {
+                const destructPattern = t.objectPattern([
+                    t.objectProperty(t.identifier('variables'), t.identifier('_variables'), false, false),
+                    t.objectProperty(t.identifier('selection'), t.identifier('_selection'), false, false),
+                    t.restElement(t.identifier('queryOptions')),
+                ]);
+                body.push(t.variableDeclaration('const', [
+                    t.variableDeclarator(destructPattern, t.logicalExpression('??', t.identifier('params'), t.objectExpression([]))),
+                ]));
+                body.push(voidStatement('_variables'));
+                body.push(voidStatement('_selection'));
+            }
+            else {
+                body.push(destructureParamsWithSelection('queryOptions'));
+                body.push(voidStatement('_selection'));
+            }
+            const selectArgExpr = t.objectExpression([
+                objectProp('select', t.memberExpression(t.identifier('args'), t.identifier('select'))),
+            ]);
+            const queryFnArgs = hasArgs
+                ? [
+                    hasRequiredArgs
+                        ? t.tsNonNullExpression(t.identifier('variables'))
+                        : t.identifier('variables'),
+                    selectArgExpr,
+                ]
+                : [selectArgExpr];
+            const queryFnExpr = t.arrowFunctionExpression([], getClientCustomCallUnwrap('query', operation.name, queryFnArgs));
+            const extraProps = [];
+            const enabledExpr = hasRequiredArgs
+                ? t.logicalExpression('&&', t.unaryExpression('!', t.unaryExpression('!', t.identifier('variables'))), t.binaryExpression('!==', t.optionalMemberExpression(t.identifier('params'), t.identifier('enabled'), false, true), t.booleanLiteral(false)))
+                : undefined;
+            extraProps.push(spreadObj(t.identifier('queryOptions')));
+            body.push(returnUseQuery(buildQueryKeyCall(hasArgs), queryFnExpr, extraProps, enabledExpr));
+            statements.push(exportFunction(hookName, null, [implParam], body));
         }
         else {
-            useQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [])));
-            useQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName)], [t.tsTypeReference(t.identifier(resultTypeName))]))));
+            // Without select: simple hook (scalar return type)
+            const resultTypeLiteral = t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(typeRef(resultType))),
+            ]);
+            const optType = omitType(typeRef('UseQueryOptions', [
+                resultTypeLiteral,
+                typeRef('Error'),
+                typeRef('TData'),
+            ]), ['queryKey', 'queryFn']);
+            let paramType;
+            if (hasArgs) {
+                const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+                if (!hasRequiredArgs)
+                    varProp.optional = true;
+                paramType = t.tsIntersectionType([t.tsTypeLiteral([varProp]), optType]);
+            }
+            else {
+                paramType = optType;
+            }
+            const implParam = createFunctionParam('params', paramType, !hasRequiredArgs);
+            const hookDecl = exportDeclareFunction(hookName, createTDataTypeParam(resultTypeLiteral), [implParam], typeRef('UseQueryResult', [typeRef('TData')]));
+            addJSDocComment(hookDecl, [
+                description,
+                '',
+                '@example',
+                '```tsx',
+                `const { data, isLoading } = ${exampleCall};`,
+                '',
+                `if (data?.${operation.name}) {`,
+                `  console.log(data.${operation.name});`,
+                '}',
+                '```',
+            ]);
+            const body = [];
+            if (hasArgs) {
+                body.push(constDecl('variables', hasRequiredArgs
+                    ? t.optionalMemberExpression(t.identifier('params'), t.identifier('variables'), false, true)
+                    : t.logicalExpression('??', t.optionalMemberExpression(t.identifier('params'), t.identifier('variables'), false, true), t.objectExpression([]))));
+                const destructPattern = t.objectPattern([
+                    t.objectProperty(t.identifier('variables'), t.identifier('_variables'), false, false),
+                    t.restElement(t.identifier('queryOptions')),
+                ]);
+                body.push(t.variableDeclaration('const', [
+                    t.variableDeclarator(destructPattern, t.logicalExpression('??', t.identifier('params'), t.objectExpression([]))),
+                ]));
+                body.push(voidStatement('_variables'));
+            }
+            else {
+                body.push(constDecl('queryOptions', t.logicalExpression('??', t.identifier('params'), t.objectExpression([]))));
+            }
+            const queryFnArgs = hasArgs
+                ? [
+                    hasRequiredArgs
+                        ? t.tsNonNullExpression(t.identifier('variables'))
+                        : t.identifier('variables'),
+                ]
+                : [];
+            const queryFnExpr = t.arrowFunctionExpression([], getClientCustomCallUnwrap('query', operation.name, queryFnArgs));
+            const enabledExpr = hasRequiredArgs
+                ? t.logicalExpression('&&', t.unaryExpression('!', t.unaryExpression('!', t.identifier('variables'))), t.binaryExpression('!==', t.optionalMemberExpression(t.identifier('params'), t.identifier('enabled'), false, true), t.booleanLiteral(false)))
+                : undefined;
+            body.push(returnUseQuery(buildQueryKeyCall(hasArgs), queryFnExpr, [spreadObj(t.identifier('queryOptions'))], enabledExpr));
+            // We need the implementation version (not declare), with return type
+            statements.push(hookDecl);
+            statements.push(exportFunction(hookName, createTDataTypeParam(resultTypeLiteral), [implParam], body, typeRef('UseQueryResult', [typeRef('TData')])));
         }
-        useQueryOptions.push(t.spreadElement(t.identifier('options')));
-        hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useQuery'), [t.objectExpression(useQueryOptions)])));
-        const hookParams = [];
+    }
+    // Fetch function (non-hook)
+    const fetchFnName = `fetch${ucFirst(operation.name)}Query`;
+    const fetchArgNames = operation.args.map((a) => a.name).join(', ');
+    const fetchExampleCall = hasArgs
+        ? hasSelect
+            ? `${fetchFnName}({ variables: { ${fetchArgNames} }, selection: { fields: { id: true } } })`
+            : `${fetchFnName}({ variables: { ${fetchArgNames} } })`
+        : hasSelect
+            ? `${fetchFnName}({ selection: { fields: { id: true } } })`
+            : `${fetchFnName}()`;
+    if (hasSelect) {
+        // Overload 1: with fields
+        const f1Props = [];
         if (hasArgs) {
-            hookParams.push(typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)), !hasRequiredArgs));
+            const varType = hasRequiredArgs
+                ? typeRef(varTypeName)
+                : t.tsUnionType([typeRef(varTypeName), t.tsUndefinedKeyword()]);
+            f1Props.push(t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(varType)));
         }
-        const optionsTypeStr = `Omit<UseQueryOptions<${resultTypeName}, Error>, 'queryKey' | 'queryFn'>`;
-        const optionsParam = t.identifier('options');
-        optionsParam.optional = true;
-        optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(optionsTypeStr)));
-        hookParams.push(optionsParam);
-        const hookFunc = t.functionDeclaration(t.identifier(hookName), hookParams, t.blockStatement(hookBodyStatements));
-        const hookExport = t.exportNamedDeclaration(hookFunc);
-        const description = operation.description || `Query hook for ${operation.name}`;
-        const argNames = operation.args.map((a) => a.name).join(', ');
-        const exampleCall = hasArgs ? `${hookName}({ ${argNames} })` : `${hookName}()`;
-        addJSDocComment(hookExport, [
-            description,
+        f1Props.push(t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(fieldsSelectionType(sRef()))));
+        const f1Decl = exportAsyncDeclareFunction(fetchFnName, createSTypeParam(selectTypeName), [createFunctionParam('params', t.tsTypeLiteral(f1Props))], typeRef('Promise', [selectedResultType(sRef())]));
+        addJSDocComment(f1Decl, [
+            `Fetch ${operation.name} without React hooks`,
             '',
             '@example',
-            '```tsx',
-            `const { data, isLoading } = ${exampleCall};`,
-            '',
-            `if (data?.${operation.name}) {`,
-            `  console.log(data.${operation.name});`,
-            '}',
+            '```ts',
+            `const data = await ${fetchExampleCall};`,
             '```',
         ]);
-        statements.push(hookExport);
-    }
-    const fetchFnName = `fetch${ucFirst(operation.name)}Query`;
-    const hasArgs = operation.args.length > 0;
-    const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
-    const fetchBodyStatements = [];
-    if (hasArgs) {
-        fetchBodyStatements.push(t.returnStatement(createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables'), t.identifier('options')], [
-            t.tsTypeReference(t.identifier(resultTypeName)),
-            t.tsTypeReference(t.identifier(variablesTypeName)),
-        ])));
+        statements.push(f1Decl);
+        // Implementation
+        const fImplProps = [];
+        if (hasArgs) {
+            const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+            if (!hasRequiredArgs)
+                varProp.optional = true;
+            fImplProps.push(varProp);
+        }
+        const fImplSelProp = t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(selectionConfigType(typeRef(selectTypeName))));
+        fImplProps.push(fImplSelProp);
+        const fBody = [];
+        if (hasArgs) {
+            fBody.push(constDecl('variables', hasRequiredArgs
+                ? t.memberExpression(t.identifier('params'), t.identifier('variables'))
+                : t.logicalExpression('??', t.memberExpression(t.identifier('params'), t.identifier('variables')), t.objectExpression([]))));
+        }
+        fBody.push(buildSelectionArgsCall(selectTypeName));
+        const selectArgExpr = t.objectExpression([
+            objectProp('select', t.memberExpression(t.identifier('args'), t.identifier('select'))),
+        ]);
+        const fCallArgs = hasArgs
+            ? [
+                hasRequiredArgs
+                    ? t.tsNonNullExpression(t.identifier('variables'))
+                    : t.identifier('variables'),
+                selectArgExpr,
+            ]
+            : [selectArgExpr];
+        fBody.push(t.returnStatement(getClientCustomCallUnwrap('query', operation.name, fCallArgs)));
+        statements.push(exportAsyncFunction(fetchFnName, null, [
+            createFunctionParam('params', t.tsTypeLiteral(fImplProps), false),
+        ], fBody));
     }
     else {
-        fetchBodyStatements.push(t.returnStatement(createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('undefined'), t.identifier('options')], [t.tsTypeReference(t.identifier(resultTypeName))])));
-    }
-    const fetchParams = [];
-    if (hasArgs) {
-        fetchParams.push(typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)), !hasRequiredArgs));
+        const fBody = [];
+        if (hasArgs) {
+            const fProps = [];
+            const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+            if (!hasRequiredArgs)
+                varProp.optional = true;
+            fProps.push(varProp);
+            fBody.push(constDecl('variables', hasRequiredArgs
+                ? t.optionalMemberExpression(t.identifier('params'), t.identifier('variables'), false, true)
+                : t.logicalExpression('??', t.optionalMemberExpression(t.identifier('params'), t.identifier('variables'), false, true), t.objectExpression([]))));
+            const fCallArgs = hasRequiredArgs
+                ? [t.tsNonNullExpression(t.identifier('variables'))]
+                : [t.identifier('variables')];
+            fBody.push(t.returnStatement(getClientCustomCallUnwrap('query', operation.name, fCallArgs)));
+            const fDecl = exportAsyncFunction(fetchFnName, null, [
+                createFunctionParam('params', t.tsTypeLiteral(fProps), !hasRequiredArgs),
+            ], fBody);
+            addJSDocComment(fDecl, [
+                `Fetch ${operation.name} without React hooks`,
+                '',
+                '@example',
+                '```ts',
+                `const data = await ${fetchExampleCall};`,
+                '```',
+            ]);
+            statements.push(fDecl);
+        }
+        else {
+            fBody.push(t.returnStatement(getClientCustomCallUnwrap('query', operation.name, [])));
+            const fDecl = exportAsyncFunction(fetchFnName, null, [], fBody);
+            addJSDocComment(fDecl, [
+                `Fetch ${operation.name} without React hooks`,
+                '',
+                '@example',
+                '```ts',
+                `const data = await ${fetchExampleCall};`,
+                '```',
+            ]);
+            statements.push(fDecl);
+        }
     }
-    fetchParams.push(typedParam('options', t.tsTypeReference(t.identifier('ExecuteOptions')), true));
-    const fetchFunc = t.functionDeclaration(t.identifier(fetchFnName), fetchParams, t.blockStatement(fetchBodyStatements));
-    fetchFunc.async = true;
-    fetchFunc.returnType = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(resultTypeName))])));
-    const fetchExport = t.exportNamedDeclaration(fetchFunc);
-    const argNames = operation.args.map((a) => a.name).join(', ');
-    const fetchExampleCall = hasArgs ? `${fetchFnName}({ ${argNames} })` : `${fetchFnName}()`;
-    addJSDocComment(fetchExport, [
-        `Fetch ${operation.name} without React hooks`,
-        '',
-        '@example',
-        '```ts',
-        `const data = await ${fetchExampleCall};`,
-        '```',
-    ]);
-    statements.push(fetchExport);
+    // Prefetch function
     if (reactQueryEnabled) {
         const prefetchFnName = `prefetch${ucFirst(operation.name)}Query`;
-        const prefetchBodyStatements = [];
-        const prefetchQueryOptions = [];
-        if (hasArgs) {
-            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [t.identifier('variables')])));
-            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables'), t.identifier('options')], [
-                t.tsTypeReference(t.identifier(resultTypeName)),
-                t.tsTypeReference(t.identifier(variablesTypeName)),
-            ]))));
+        const prefetchArgNames = operation.args.map((a) => a.name).join(', ');
+        const prefetchExampleCall = hasArgs
+            ? hasSelect
+                ? `${prefetchFnName}(queryClient, { variables: { ${prefetchArgNames} }, selection: { fields: { id: true } } })`
+                : `${prefetchFnName}(queryClient, { variables: { ${prefetchArgNames} } })`
+            : hasSelect
+                ? `${prefetchFnName}(queryClient, { selection: { fields: { id: true } } })`
+                : `${prefetchFnName}(queryClient)`;
+        if (hasSelect) {
+            // Overload 1: with fields
+            const p1Props = [];
+            if (hasArgs) {
+                const varType = hasRequiredArgs
+                    ? typeRef(varTypeName)
+                    : t.tsUnionType([typeRef(varTypeName), t.tsUndefinedKeyword()]);
+                p1Props.push(t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(varType)));
+            }
+            p1Props.push(t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(fieldsSelectionType(sRef()))));
+            const p1Decl = exportAsyncDeclareFunction(prefetchFnName, createSTypeParam(selectTypeName), [
+                createFunctionParam('queryClient', typeRef('QueryClient')),
+                createFunctionParam('params', t.tsTypeLiteral(p1Props)),
+            ], typeRef('Promise', [t.tsVoidKeyword()]));
+            addJSDocComment(p1Decl, [
+                `Prefetch ${operation.name} for SSR or cache warming`,
+                '',
+                '@example',
+                '```ts',
+                `await ${prefetchExampleCall};`,
+                '```',
+            ]);
+            statements.push(p1Decl);
+            // Implementation
+            const pImplProps = [];
+            if (hasArgs) {
+                const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+                if (!hasRequiredArgs)
+                    varProp.optional = true;
+                pImplProps.push(varProp);
+            }
+            const pImplSelProp = t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(selectionConfigType(typeRef(selectTypeName))));
+            pImplProps.push(pImplSelProp);
+            const pBody = [];
+            if (hasArgs) {
+                pBody.push(constDecl('variables', hasRequiredArgs
+                    ? t.memberExpression(t.identifier('params'), t.identifier('variables'))
+                    : t.logicalExpression('??', t.memberExpression(t.identifier('params'), t.identifier('variables')), t.objectExpression([]))));
+            }
+            pBody.push(buildSelectionArgsCall(selectTypeName));
+            const selectArgExpr = t.objectExpression([
+                objectProp('select', t.memberExpression(t.identifier('args'), t.identifier('select'))),
+            ]);
+            const pCallArgs = hasArgs
+                ? [
+                    hasRequiredArgs
+                        ? t.tsNonNullExpression(t.identifier('variables'))
+                        : t.identifier('variables'),
+                    selectArgExpr,
+                ]
+                : [selectArgExpr];
+            const prefetchQueryCall = callExpr(t.memberExpression(t.identifier('queryClient'), t.identifier('prefetchQuery')), [
+                t.objectExpression([
+                    objectProp('queryKey', buildQueryKeyCall(hasArgs)),
+                    objectProp('queryFn', t.arrowFunctionExpression([], getClientCustomCallUnwrap('query', operation.name, pCallArgs))),
+                ]),
+            ]);
+            pBody.push(t.expressionStatement(t.awaitExpression(prefetchQueryCall)));
+            statements.push(exportAsyncFunction(prefetchFnName, null, [
+                createFunctionParam('queryClient', typeRef('QueryClient')),
+                createFunctionParam('params', t.tsTypeLiteral(pImplProps), false),
+            ], pBody, typeRef('Promise', [t.tsVoidKeyword()])));
         }
         else {
-            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [])));
-            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('undefined'), t.identifier('options')], [t.tsTypeReference(t.identifier(resultTypeName))]))));
-        }
-        prefetchBodyStatements.push(t.expressionStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('queryClient'), t.identifier('prefetchQuery')), [t.objectExpression(prefetchQueryOptions)]))));
-        const prefetchParams = [
-            typedParam('queryClient', t.tsTypeReference(t.identifier('QueryClient'))),
-        ];
-        if (hasArgs) {
-            prefetchParams.push(typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)), !hasRequiredArgs));
+            // Without select
+            const pBody = [];
+            const pParams = [
+                createFunctionParam('queryClient', typeRef('QueryClient')),
+            ];
+            if (hasArgs) {
+                const pProps = [];
+                const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+                if (!hasRequiredArgs)
+                    varProp.optional = true;
+                pProps.push(varProp);
+                pParams.push(createFunctionParam('params', t.tsTypeLiteral(pProps), !hasRequiredArgs));
+                pBody.push(constDecl('variables', hasRequiredArgs
+                    ? t.optionalMemberExpression(t.identifier('params'), t.identifier('variables'), false, true)
+                    : t.logicalExpression('??', t.optionalMemberExpression(t.identifier('params'), t.identifier('variables'), false, true), t.objectExpression([]))));
+                const pCallArgs = hasRequiredArgs
+                    ? [t.tsNonNullExpression(t.identifier('variables'))]
+                    : [t.identifier('variables')];
+                const prefetchQueryCall = callExpr(t.memberExpression(t.identifier('queryClient'), t.identifier('prefetchQuery')), [
+                    t.objectExpression([
+                        objectProp('queryKey', buildQueryKeyCall(true)),
+                        objectProp('queryFn', t.arrowFunctionExpression([], getClientCustomCallUnwrap('query', operation.name, pCallArgs))),
+                    ]),
+                ]);
+                pBody.push(t.expressionStatement(t.awaitExpression(prefetchQueryCall)));
+            }
+            else {
+                const prefetchQueryCall = callExpr(t.memberExpression(t.identifier('queryClient'), t.identifier('prefetchQuery')), [
+                    t.objectExpression([
+                        objectProp('queryKey', buildQueryKeyCall(false)),
+                        objectProp('queryFn', t.arrowFunctionExpression([], getClientCustomCallUnwrap('query', operation.name, []))),
+                    ]),
+                ]);
+                pBody.push(t.expressionStatement(t.awaitExpression(prefetchQueryCall)));
+            }
+            const pDecl = exportAsyncFunction(prefetchFnName, null, pParams, pBody, typeRef('Promise', [t.tsVoidKeyword()]));
+            addJSDocComment(pDecl, [
+                `Prefetch ${operation.name} for SSR or cache warming`,
+                '',
+                '@example',
+                '```ts',
+                `await ${prefetchExampleCall};`,
+                '```',
+            ]);
+            statements.push(pDecl);
         }
-        prefetchParams.push(typedParam('options', t.tsTypeReference(t.identifier('ExecuteOptions')), true));
-        const prefetchFunc = t.functionDeclaration(t.identifier(prefetchFnName), prefetchParams, t.blockStatement(prefetchBodyStatements));
-        prefetchFunc.async = true;
-        prefetchFunc.returnType = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tsVoidKeyword()])));
-        const prefetchExport = t.exportNamedDeclaration(prefetchFunc);
-        const prefetchExampleCall = hasArgs
-            ? `${prefetchFnName}(queryClient, { ${argNames} })`
-            : `${prefetchFnName}(queryClient)`;
-        addJSDocComment(prefetchExport, [
-            `Prefetch ${operation.name} for SSR or cache warming`,
-            '',
-            '@example',
-            '```ts',
-            `await ${prefetchExampleCall};`,
-            '```',
-        ]);
-        statements.push(prefetchExport);
     }
-    const code = generateCode(statements);
     const headerText = reactQueryEnabled
         ? `Custom query hook for ${operation.name}`
         : `Custom query functions for ${operation.name}`;
-    const content = getGeneratedFileHeader(headerText) + '\n\n' + code;
+    const content = generateHookFileCode(headerText, statements);
     return {
         fileName,
         content,
@@ -242,13 +533,12 @@ export function generateCustomQueryHook(options) {
     };
 }
 export function generateAllCustomQueryHooks(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 === 'query')
         .map((operation) => generateCustomQueryHook({
         operation,
         typeRegistry,
-        maxDepth,
         skipQueryField,
         reactQueryEnabled,
         tableTypeNames,