@constructive-io/graphql-codegen 2.19.0 → 2.20.1

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

@@ -0,0 +1,354 @@
+import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, createConst, } from './ts-ast';
+import { buildCustomQueryString } from './schema-gql-ast';
+import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, getQueryKeyName, } from './type-resolver';
+import { ucFirst } from './utils';
+/**
+ * Generate a custom query hook file
+ */
+export function generateCustomQueryHook(options) {
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true } = options;
+    const project = createProject();
+    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);
+    // Generate GraphQL document
+    const queryDocument = buildCustomQueryString({
+        operation,
+        typeRegistry,
+        maxDepth,
+        skipQueryField,
+    });
+    const sourceFile = createSourceFile(project, fileName);
+    // Add file header
+    sourceFile.insertText(0, createFileHeader(`Custom query hook for ${operation.name}`) + '\n\n');
+    // Add imports
+    sourceFile.addImportDeclarations([
+        createImport({
+            moduleSpecifier: '@tanstack/react-query',
+            namedImports: ['useQuery'],
+            typeOnlyNamedImports: ['UseQueryOptions', 'QueryClient'],
+        }),
+        createImport({
+            moduleSpecifier: '../client',
+            namedImports: ['execute'],
+            typeOnlyNamedImports: ['ExecuteOptions'],
+        }),
+    ]);
+    // Add query document constant
+    sourceFile.addVariableStatement(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(createInterface(variablesTypeName, variablesProps));
+    }
+    // Generate result interface
+    const resultType = typeRefToTsType(operation.returnType);
+    const resultProps = [
+        { name: operation.name, type: resultType },
+    ];
+    sourceFile.addInterface(createInterface(resultTypeName, resultProps));
+    // Query key factory
+    if (operation.args.length > 0) {
+        sourceFile.addVariableStatement(createConst(queryKeyName, `(variables?: ${variablesTypeName}) =>
+  ['${operation.name}', variables] as const`, { docs: ['Query key factory for caching'] }));
+    }
+    else {
+        sourceFile.addVariableStatement(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${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${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) {
+    return args.map((arg) => ({
+        name: arg.name,
+        type: typeRefToTsType(arg.type),
+        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));
+    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) => 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) => 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
+ */
+export 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/esm/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;