@constructive-io/graphql-codegen 2.23.3 → 2.24.1

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

@@ -1,381 +1,248 @@
-import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, createConst, } from './ts-ast';
+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 } from './utils';
-/**
- * Generate a custom query hook file
- */
+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,
+    }));
+}
 export function generateCustomQueryHook(options) {
-    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames } = options;
-    const project = createProject();
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, 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);
-    // Create type tracker to collect referenced types (with table type awareness)
     const tracker = createTypeTracker({ tableTypeNames });
-    // Generate GraphQL document
     const queryDocument = buildCustomQueryString({
         operation,
         typeRegistry,
         maxDepth,
         skipQueryField,
     });
-    const sourceFile = createSourceFile(project, fileName);
-    // Add file header
-    const headerText = reactQueryEnabled
-        ? `Custom query hook for ${operation.name}`
-        : `Custom query functions for ${operation.name}`;
-    sourceFile.insertText(0, createFileHeader(headerText) + '\n\n');
-    // Generate variables interface if there are arguments (with tracking)
-    let variablesProps = [];
-    if (operation.args.length > 0) {
-        variablesProps = generateVariablesProperties(operation.args, tracker);
-    }
-    // Generate result interface (with tracking)
+    const statements = [];
+    const variablesProps = operation.args.length > 0
+        ? generateVariablesProperties(operation.args, tracker)
+        : [];
     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 = [];
+    const schemaTypes = tracker.getImportableTypes();
+    const tableTypes = tracker.getTableTypes();
     if (reactQueryEnabled) {
-        imports.push(createImport({
-            moduleSpecifier: '@tanstack/react-query',
-            namedImports: ['useQuery'],
-            typeOnlyNamedImports: ['UseQueryOptions', 'QueryClient'],
-        }));
+        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);
     }
-    imports.push(createImport({
-        moduleSpecifier: '../client',
-        namedImports: ['execute'],
-        typeOnlyNamedImports: ['ExecuteOptions'],
-    }));
-    // Add types.ts import for table entity types
+    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) {
-        imports.push(createImport({
-            moduleSpecifier: '../types',
-            typeOnlyNamedImports: tableTypes,
-        }));
+        const typesImport = t.importDeclaration(tableTypes.map((tt) => t.importSpecifier(t.identifier(tt), t.identifier(tt))), t.stringLiteral('../types'));
+        typesImport.importKind = 'type';
+        statements.push(typesImport);
     }
-    // Add schema-types import for Input/Payload/Enum types
     if (schemaTypes.length > 0) {
-        imports.push(createImport({
-            moduleSpecifier: '../schema-types',
-            typeOnlyNamedImports: schemaTypes,
-        }));
+        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);
     }
-    sourceFile.addImportDeclarations(imports);
-    // Add query document constant
-    sourceFile.addVariableStatement(createConst(documentConstName, '`\n' + queryDocument + '`', {
-        docs: ['GraphQL query document'],
-    }));
-    // Add variables interface
-    if (operation.args.length > 0) {
-        sourceFile.addInterface(createInterface(variablesTypeName, variablesProps));
+    if (useCentralizedKeys) {
+        const queryKeyImport = t.importDeclaration([t.importSpecifier(t.identifier('customQueryKeys'), t.identifier('customQueryKeys'))], t.stringLiteral('../query-keys'));
+        statements.push(queryKeyImport);
     }
-    // Add result interface
-    sourceFile.addInterface(createInterface(resultTypeName, resultProps));
-    // Query key factory
+    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) {
-        sourceFile.addVariableStatement(createConst(queryKeyName, `(variables?: ${variablesTypeName}) =>
-  ['${operation.name}', variables] as const`, { docs: ['Query key factory for caching'] }));
+        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));
+    }
+    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));
+    if (useCentralizedKeys) {
+        const queryKeyConst = t.variableDeclaration('const', [
+            t.variableDeclarator(t.identifier(queryKeyName), t.memberExpression(t.identifier('customQueryKeys'), t.identifier(operation.name))),
+        ]);
+        const queryKeyExport = t.exportNamedDeclaration(queryKeyConst);
+        addJSDocComment(queryKeyExport, ['Query key factory - re-exported from query-keys.ts']);
+        statements.push(queryKeyExport);
+    }
+    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 {
-        sourceFile.addVariableStatement(createConst(queryKeyName, `() => ['${operation.name}'] as const`, {
-            docs: ['Query key factory for caching'],
-        }));
+        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);
     }
-    // Generate hook function (only if React Query is enabled)
     if (reactQueryEnabled) {
-        const hookParams = generateHookParameters(operation, variablesTypeName, resultTypeName);
-        const hookBody = generateHookBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName);
-        const hookDoc = generateHookDoc(operation, hookName);
-        sourceFile.addFunction({
-            name: hookName,
-            isExported: true,
-            parameters: hookParams,
-            statements: hookBody,
-            docs: [{ description: hookDoc }],
-        });
+        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)))));
+            }
+        }
+        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))]))));
+        }
+        useQueryOptions.push(t.spreadElement(t.identifier('options')));
+        hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useQuery'), [t.objectExpression(useQueryOptions)])));
+        const hookParams = [];
+        if (hasArgs) {
+            hookParams.push(typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)), !hasRequiredArgs));
+        }
+        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,
+            '',
+            '@example',
+            '```tsx',
+            `const { data, isLoading } = ${exampleCall};`,
+            '',
+            `if (data?.${operation.name}) {`,
+            `  console.log(data.${operation.name});`,
+            '}',
+            '```',
+        ]);
+        statements.push(hookExport);
     }
-    // Add standalone functions section
-    sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Standalone Functions (non-React)');
-    sourceFile.addStatements('// ============================================================================\n');
-    // Generate standalone fetch function
     const fetchFnName = `fetch${ucFirst(operation.name)}Query`;
-    const fetchParams = generateFetchParameters(operation, variablesTypeName);
-    const fetchBody = generateFetchBody(operation, documentConstName, variablesTypeName, resultTypeName);
-    const fetchDoc = generateFetchDoc(operation, fetchFnName);
-    sourceFile.addFunction({
-        name: fetchFnName,
-        isExported: true,
-        isAsync: true,
-        parameters: fetchParams,
-        returnType: `Promise<${resultTypeName}>`,
-        statements: fetchBody,
-        docs: [{ description: fetchDoc }],
-    });
-    // Generate prefetch function (only if React Query is enabled)
-    if (reactQueryEnabled) {
-        const prefetchFnName = `prefetch${ucFirst(operation.name)}Query`;
-        const prefetchParams = generatePrefetchParameters(operation, variablesTypeName);
-        const prefetchBody = generatePrefetchBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName);
-        const prefetchDoc = generatePrefetchDoc(operation, prefetchFnName);
-        sourceFile.addFunction({
-            name: prefetchFnName,
-            isExported: true,
-            isAsync: true,
-            parameters: prefetchParams,
-            returnType: 'Promise<void>',
-            statements: prefetchBody,
-            docs: [{ description: prefetchDoc }],
-        });
-    }
-    return {
-        fileName,
-        content: getFormattedOutput(sourceFile),
-        operationName: operation.name,
-    };
-}
-// ============================================================================
-// Helper functions
-// ============================================================================
-/**
- * Generate interface properties from CleanArguments
- */
-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,
-    }));
-}
-/**
- * Generate hook function parameters
- */
-function generateHookParameters(operation, variablesTypeName, resultTypeName) {
-    const params = [];
-    // Add variables parameter if there are required args
-    const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
-    if (operation.args.length > 0) {
-        params.push({
-            name: 'variables',
-            type: variablesTypeName,
-            hasQuestionToken: !hasRequiredArgs,
-        });
-    }
-    // Add options parameter
-    params.push({
-        name: 'options',
-        type: `Omit<UseQueryOptions<${resultTypeName}, Error>, 'queryKey' | 'queryFn'>`,
-        hasQuestionToken: true,
-    });
-    return params;
-}
-/**
- * Generate hook function body
- */
-function generateHookBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName) {
     const hasArgs = operation.args.length > 0;
     const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
+    const fetchBodyStatements = [];
     if (hasArgs) {
-        // With variables
-        const enabledCondition = hasRequiredArgs
-            ? `enabled: !!variables && (options?.enabled !== false),`
-            : '';
-        return `return useQuery({
-    queryKey: ${queryKeyName}(variables),
-    queryFn: () => execute<${resultTypeName}, ${variablesTypeName}>(
-      ${documentConstName},
-      variables
-    ),
-    ${enabledCondition}
-    ...options,
-  });`;
+        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)),
+        ])));
     }
     else {
-        // No variables
-        return `return useQuery({
-    queryKey: ${queryKeyName}(),
-    queryFn: () => execute<${resultTypeName}>(${documentConstName}),
-    ...options,
-  });`;
+        fetchBodyStatements.push(t.returnStatement(createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('undefined'), t.identifier('options')], [t.tsTypeReference(t.identifier(resultTypeName))])));
     }
-}
-/**
- * Generate hook JSDoc documentation
- */
-function generateHookDoc(operation, hookName) {
-    const description = operation.description
-        ? operation.description
-        : `Query hook for ${operation.name}`;
-    const hasArgs = operation.args.length > 0;
-    let example;
+    const fetchParams = [];
     if (hasArgs) {
-        const argNames = operation.args.map((a) => a.name).join(', ');
-        example = `
-@example
-\`\`\`tsx
-const { data, isLoading } = ${hookName}({ ${argNames} });
-
-if (data?.${operation.name}) {
-  console.log(data.${operation.name});
-}
-\`\`\``;
-    }
-    else {
-        example = `
-@example
-\`\`\`tsx
-const { data, isLoading } = ${hookName}();
-
-if (data?.${operation.name}) {
-  console.log(data.${operation.name});
-}
-\`\`\``;
-    }
-    return description + '\n' + example;
-}
-// ============================================================================
-// Standalone function generators
-// ============================================================================
-/**
- * Generate fetch function parameters
- */
-function generateFetchParameters(operation, variablesTypeName) {
-    const params = [];
-    if (operation.args.length > 0) {
-        const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
-        params.push({
-            name: 'variables',
-            type: variablesTypeName,
-            hasQuestionToken: !hasRequiredArgs,
-        });
-    }
-    params.push({
-        name: 'options',
-        type: 'ExecuteOptions',
-        hasQuestionToken: true,
-    });
-    return params;
-}
-/**
- * Generate fetch function body
- */
-function generateFetchBody(operation, documentConstName, variablesTypeName, resultTypeName) {
-    if (operation.args.length > 0) {
-        return `return execute<${resultTypeName}, ${variablesTypeName}>(
-    ${documentConstName},
-    variables,
-    options
-  );`;
-    }
-    else {
-        return `return execute<${resultTypeName}>(${documentConstName}, undefined, options);`;
-    }
-}
-/**
- * Generate fetch function documentation
- */
-function generateFetchDoc(operation, fnName) {
-    const description = `Fetch ${operation.name} without React hooks`;
-    if (operation.args.length > 0) {
-        const argNames = operation.args.map((a) => a.name).join(', ');
-        return `${description}
-
-@example
-\`\`\`ts
-const data = await ${fnName}({ ${argNames} });
-\`\`\``;
-    }
-    else {
-        return `${description}
-
-@example
-\`\`\`ts
-const data = await ${fnName}();
-\`\`\``;
+        fetchParams.push(typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)), !hasRequiredArgs));
     }
-}
-/**
- * Generate prefetch function parameters
- */
-function generatePrefetchParameters(operation, variablesTypeName) {
-    const params = [
-        { name: 'queryClient', type: 'QueryClient' },
-    ];
-    if (operation.args.length > 0) {
-        const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
-        params.push({
-            name: 'variables',
-            type: variablesTypeName,
-            hasQuestionToken: !hasRequiredArgs,
-        });
-    }
-    params.push({
-        name: 'options',
-        type: 'ExecuteOptions',
-        hasQuestionToken: true,
-    });
-    return params;
-}
-/**
- * Generate prefetch function body
- */
-function generatePrefetchBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName) {
-    if (operation.args.length > 0) {
-        return `await queryClient.prefetchQuery({
-    queryKey: ${queryKeyName}(variables),
-    queryFn: () => execute<${resultTypeName}, ${variablesTypeName}>(
-      ${documentConstName},
-      variables,
-      options
-    ),
-  });`;
-    }
-    else {
-        return `await queryClient.prefetchQuery({
-    queryKey: ${queryKeyName}(),
-    queryFn: () => execute<${resultTypeName}>(${documentConstName}, undefined, options),
-  });`;
-    }
-}
-/**
- * Generate prefetch function documentation
- */
-function generatePrefetchDoc(operation, fnName) {
-    const description = `Prefetch ${operation.name} for SSR or cache warming`;
-    if (operation.args.length > 0) {
-        const argNames = operation.args.map((a) => a.name).join(', ');
-        return `${description}
-
-@example
-\`\`\`ts
-await ${fnName}(queryClient, { ${argNames} });
-\`\`\``;
-    }
-    else {
-        return `${description}
-
-@example
-\`\`\`ts
-await ${fnName}(queryClient);
-\`\`\``;
+    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);
+    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)),
+            ]))));
+        }
+        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));
+        }
+        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;
+    return {
+        fileName,
+        content,
+        operationName: operation.name,
+    };
 }
-/**
- * Generate all custom query hook files
- */
 export function generateAllCustomQueryHooks(options) {
-    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames } = options;
+    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true, reactQueryEnabled = true, tableTypeNames, useCentralizedKeys = true, } = options;
     return operations
         .filter((op) => op.kind === 'query')
         .map((operation) => generateCustomQueryHook({
@@ -385,5 +252,6 @@ export function generateAllCustomQueryHooks(options) {
         skipQueryField,
         reactQueryEnabled,
         tableTypeNames,
+        useCentralizedKeys,
     }));
 }

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, getPrimaryKeyInfo, ucFirst, } from './utils';
+import { getTableNames, getAllRowsQueryName, getSingleRowQueryName, getCreateMutationName, getUpdateMutationName, getDeleteMutationName, getFilterTypeName, getConditionTypeName, getOrderByTypeName, getScalarFields, getPrimaryKeyInfo, ucFirst, } from './utils';
 // ============================================================================
 // Field selection builders
 // ============================================================================
@@ -39,22 +39,39 @@ export function buildListQueryAST(config) {
     const { table } = config;
     const queryName = getAllRowsQueryName(table);
     const filterType = getFilterTypeName(table);
+    const conditionType = getConditionTypeName(table);
     const orderByType = getOrderByTypeName(table);
     const scalarFields = getScalarFields(table);
-    // Variable definitions
+    // Variable definitions - all pagination arguments from PostGraphile
     const variableDefinitions = [
         t.variableDefinition({
             variable: t.variable({ name: 'first' }),
             type: t.namedType({ type: 'Int' }),
         }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'last' }),
+            type: t.namedType({ type: 'Int' }),
+        }),
         t.variableDefinition({
             variable: t.variable({ name: 'offset' }),
             type: t.namedType({ type: 'Int' }),
         }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'before' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'after' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }),
         t.variableDefinition({
             variable: t.variable({ name: 'filter' }),
             type: t.namedType({ type: filterType }),
         }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'condition' }),
+            type: t.namedType({ type: conditionType }),
+        }),
         t.variableDefinition({
             variable: t.variable({ name: 'orderBy' }),
             type: t.listType({
@@ -65,8 +82,12 @@ export function buildListQueryAST(config) {
     // Query arguments
     const args = [
         t.argument({ name: 'first', value: t.variable({ name: 'first' }) }),
+        t.argument({ name: 'last', value: t.variable({ name: 'last' }) }),
         t.argument({ name: 'offset', value: t.variable({ name: 'offset' }) }),
+        t.argument({ name: 'before', value: t.variable({ name: 'before' }) }),
+        t.argument({ name: 'after', value: t.variable({ name: 'after' }) }),
         t.argument({ name: 'filter', value: t.variable({ name: 'filter' }) }),
+        t.argument({ name: 'condition', value: t.variable({ name: 'condition' }) }),
         t.argument({ name: 'orderBy', value: t.variable({ name: 'orderBy' }) }),
     ];
     // Field selections