@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/cli/codegen/custom-queries.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCustomQueryHook = generateCustomQueryHook;
+exports.generateAllCustomQueryHooks = generateAllCustomQueryHooks;
+const ts_ast_1 = require("./ts-ast");
+const schema_gql_ast_1 = require("./schema-gql-ast");
+const type_resolver_1 = require("./type-resolver");
+const utils_1 = require("./utils");
+/**
+ * Generate a custom query hook file
+ */
+function generateCustomQueryHook(options) {
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true } = options;
+    const project = (0, ts_ast_1.createProject)();
+    const hookName = (0, type_resolver_1.getOperationHookName)(operation.name, 'query');
+    const fileName = (0, type_resolver_1.getOperationFileName)(operation.name, 'query');
+    const variablesTypeName = (0, type_resolver_1.getOperationVariablesTypeName)(operation.name, 'query');
+    const resultTypeName = (0, type_resolver_1.getOperationResultTypeName)(operation.name, 'query');
+    const documentConstName = (0, type_resolver_1.getDocumentConstName)(operation.name, 'query');
+    const queryKeyName = (0, type_resolver_1.getQueryKeyName)(operation.name);
+    // Generate GraphQL document
+    const queryDocument = (0, schema_gql_ast_1.buildCustomQueryString)({
+        operation,
+        typeRegistry,
+        maxDepth,
+        skipQueryField,
+    });
+    const sourceFile = (0, ts_ast_1.createSourceFile)(project, fileName);
+    // Add file header
+    sourceFile.insertText(0, (0, ts_ast_1.createFileHeader)(`Custom query hook for ${operation.name}`) + '\n\n');
+    // Add imports
+    sourceFile.addImportDeclarations([
+        (0, ts_ast_1.createImport)({
+            moduleSpecifier: '@tanstack/react-query',
+            namedImports: ['useQuery'],
+            typeOnlyNamedImports: ['UseQueryOptions', 'QueryClient'],
+        }),
+        (0, ts_ast_1.createImport)({
+            moduleSpecifier: '../client',
+            namedImports: ['execute'],
+            typeOnlyNamedImports: ['ExecuteOptions'],
+        }),
+    ]);
+    // Add query document constant
+    sourceFile.addVariableStatement((0, ts_ast_1.createConst)(documentConstName, '`\n' + queryDocument + '`', {
+        docs: ['GraphQL query document'],
+    }));
+    // Generate variables interface if there are arguments
+    if (operation.args.length > 0) {
+        const variablesProps = generateVariablesProperties(operation.args);
+        sourceFile.addInterface((0, ts_ast_1.createInterface)(variablesTypeName, variablesProps));
+    }
+    // Generate result interface
+    const resultType = (0, type_resolver_1.typeRefToTsType)(operation.returnType);
+    const resultProps = [
+        { name: operation.name, type: resultType },
+    ];
+    sourceFile.addInterface((0, ts_ast_1.createInterface)(resultTypeName, resultProps));
+    // Query key factory
+    if (operation.args.length > 0) {
+        sourceFile.addVariableStatement((0, ts_ast_1.createConst)(queryKeyName, `(variables?: ${variablesTypeName}) =>
+  ['${operation.name}', variables] as const`, { docs: ['Query key factory for caching'] }));
+    }
+    else {
+        sourceFile.addVariableStatement((0, ts_ast_1.createConst)(queryKeyName, `() => ['${operation.name}'] as const`, {
+            docs: ['Query key factory for caching'],
+        }));
+    }
+    // Generate hook function
+    const hookParams = generateHookParameters(operation, variablesTypeName, resultTypeName);
+    const hookBody = generateHookBody(operation, documentConstName, queryKeyName, variablesTypeName, resultTypeName);
+    const hookDoc = generateHookDoc(operation, hookName);
+    sourceFile.addFunction({
+        name: hookName,
+        isExported: true,
+        parameters: hookParams,
+        statements: hookBody,
+        docs: [{ description: hookDoc }],
+    });
+    // Add standalone functions section
+    sourceFile.addStatements('\n// ============================================================================');
+    sourceFile.addStatements('// Standalone Functions (non-React)');
+    sourceFile.addStatements('// ============================================================================\n');
+    // Generate standalone fetch function
+    const fetchFnName = `fetch${(0, utils_1.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
+    const prefetchFnName = `prefetch${(0, utils_1.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: (0, ts_ast_1.getFormattedOutput)(sourceFile),
+        operationName: operation.name,
+    };
+}
+// ============================================================================
+// Helper functions
+// ============================================================================
+/**
+ * Generate interface properties from CleanArguments
+ */
+function generateVariablesProperties(args) {
+    return args.map((arg) => ({
+        name: arg.name,
+        type: (0, type_resolver_1.typeRefToTsType)(arg.type),
+        optional: !(0, type_resolver_1.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) => (0, type_resolver_1.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) => (0, type_resolver_1.isTypeRequired)(arg.type));
+    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,
+  });`;
+    }
+    else {
+        // No variables
+        return `return useQuery({
+    queryKey: ${queryKeyName}(),
+    queryFn: () => execute<${resultTypeName}>(${documentConstName}),
+    ...options,
+  });`;
+    }
+}
+/**
+ * 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;
+    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) => (0, type_resolver_1.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}();
+\`\`\``;
+    }
+}
+/**
+ * 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) => (0, type_resolver_1.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);
+\`\`\``;
+    }
+}
+/**
+ * Generate all custom query hook files
+ */
+function generateAllCustomQueryHooks(options) {
+    const { operations, typeRegistry, maxDepth = 2, skipQueryField = true } = options;
+    return operations
+        .filter((op) => op.kind === 'query')
+        .map((operation) => generateCustomQueryHook({
+        operation,
+        typeRegistry,
+        maxDepth,
+        skipQueryField,
+    }));
+}

package/cli/codegen/filters.d.ts

@@ -0,0 +1,27 @@
+/**
+ * PostGraphile filter type generators
+ *
+ * Generates TypeScript interfaces for PostGraphile filter types:
+ * - Base scalar filters (StringFilter, IntFilter, etc.)
+ * - Table-specific filters (CarFilter, UserFilter, etc.)
+ * - OrderBy enum types
+ */
+import type { CleanTable } from '../../types/schema';
+/**
+ * Generate all base PostGraphile filter types
+ * These are shared across all tables
+ */
+export declare function generateBaseFilterTypes(): string;
+/**
+ * Generate filter interface for a specific table
+ */
+export declare function generateTableFilter(table: CleanTable): string;
+/**
+ * Generate OrderBy type for a specific table
+ */
+export declare function generateTableOrderBy(table: CleanTable): string;
+/**
+ * Generate inline filter and orderBy types for a query hook file
+ * These are embedded directly in the hook file for self-containment
+ */
+export declare function generateInlineFilterTypes(table: CleanTable): string;