@constructive-io/graphql-codegen 2.23.2 → 2.24.0

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

@@ -1,13 +1,18 @@
-import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, createConst, } from './ts-ast';
+import * as t from '@babel/types';
+import { generateCode, addJSDocComment, typedParam } from './babel-ast';
 import { buildCustomMutationString } from './schema-gql-ast';
 import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, createTypeTracker, } from './type-resolver';
-/**
- * Generate a custom mutation hook file
- * When reactQueryEnabled is false, returns null since mutations require React Query
- */
+import { getGeneratedFileHeader } from './utils';
+function generateVariablesProperties(args, tracker) {
+    return args.map((arg) => ({
+        name: arg.name,
+        type: typeRefToTsType(arg.type, tracker),
+        optional: !isTypeRequired(arg.type),
+        docs: arg.description ? [arg.description] : undefined,
+    }));
+}
 export function generateCustomMutationHook(options) {
     const { operation, reactQueryEnabled = true } = options;
-    // Mutations require React Query - skip generation when disabled
     if (!reactQueryEnabled) {
         return null;
     }
@@ -21,150 +26,103 @@ export function generateCustomMutationHook(options) {
     }
 }
 function generateCustomMutationHookInternal(options) {
-    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, tableTypeNames } = options;
-    const project = createProject();
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, tableTypeNames, useCentralizedKeys = true, } = options;
     const hookName = getOperationHookName(operation.name, 'mutation');
     const fileName = getOperationFileName(operation.name, 'mutation');
     const variablesTypeName = getOperationVariablesTypeName(operation.name, 'mutation');
     const resultTypeName = getOperationResultTypeName(operation.name, 'mutation');
     const documentConstName = getDocumentConstName(operation.name, 'mutation');
-    // Create type tracker to collect referenced types (with table type awareness)
     const tracker = createTypeTracker({ tableTypeNames });
-    // Generate GraphQL document
     const mutationDocument = buildCustomMutationString({
         operation,
         typeRegistry,
         maxDepth,
         skipQueryField,
     });
-    const sourceFile = createSourceFile(project, fileName);
-    // Add file header
-    sourceFile.insertText(0, createFileHeader(`Custom mutation hook for ${operation.name}`) + '\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
-    const imports = [
-        createImport({
-            moduleSpecifier: '@tanstack/react-query',
-            namedImports: ['useMutation'],
-            typeOnlyNamedImports: ['UseMutationOptions'],
-        }),
-        createImport({
-            moduleSpecifier: '../client',
-            namedImports: ['execute'],
-        }),
-    ];
-    // Add types.ts import for table entity types
+    const schemaTypes = tracker.getImportableTypes();
+    const tableTypes = tracker.getTableTypes();
+    const reactQueryImport = t.importDeclaration([t.importSpecifier(t.identifier('useMutation'), t.identifier('useMutation'))], t.stringLiteral('@tanstack/react-query'));
+    statements.push(reactQueryImport);
+    const reactQueryTypeImport = t.importDeclaration([t.importSpecifier(t.identifier('UseMutationOptions'), t.identifier('UseMutationOptions'))], t.stringLiteral('@tanstack/react-query'));
+    reactQueryTypeImport.importKind = 'type';
+    statements.push(reactQueryTypeImport);
+    const clientImport = t.importDeclaration([t.importSpecifier(t.identifier('execute'), t.identifier('execute'))], t.stringLiteral('../client'));
+    statements.push(clientImport);
     if (tableTypes.length > 0) {
-        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 mutation document constant
-    sourceFile.addVariableStatement(createConst(documentConstName, '`\n' + mutationDocument + '`', {
-        docs: ['GraphQL mutation document'],
-    }));
-    // Add variables interface
+    if (useCentralizedKeys) {
+        const mutationKeyImport = t.importDeclaration([t.importSpecifier(t.identifier('customMutationKeys'), t.identifier('customMutationKeys'))], t.stringLiteral('../mutation-keys'));
+        statements.push(mutationKeyImport);
+    }
+    const mutationDocConst = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier(documentConstName), t.templateLiteral([t.templateElement({ raw: '\n' + mutationDocument, cooked: '\n' + mutationDocument }, true)], [])),
+    ]);
+    const mutationDocExport = t.exportNamedDeclaration(mutationDocConst);
+    addJSDocComment(mutationDocExport, ['GraphQL mutation document']);
+    statements.push(mutationDocExport);
     if (operation.args.length > 0) {
-        sourceFile.addInterface(createInterface(variablesTypeName, variablesProps));
+        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));
     }
-    // Add result interface
-    sourceFile.addInterface(createInterface(resultTypeName, resultProps));
-    // Generate hook function
-    const hookParams = generateHookParameters(operation, variablesTypeName, resultTypeName);
-    const hookBody = generateHookBody(operation, documentConstName, variablesTypeName, resultTypeName);
-    // Note: docs can cause ts-morph issues with certain content, so we skip them
-    sourceFile.addFunction({
-        name: hookName,
-        isExported: true,
-        parameters: hookParams,
-        statements: hookBody,
-    });
-    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 hasArgs = operation.args.length > 0;
-    // Mutation hooks use UseMutationOptions with variables as the second type param
-    const optionsType = hasArgs
-        ? `Omit<UseMutationOptions<${resultTypeName}, Error, ${variablesTypeName}>, 'mutationFn'>`
-        : `Omit<UseMutationOptions<${resultTypeName}, Error, void>, 'mutationFn'>`;
-    return [
-        {
-            name: 'options',
-            type: optionsType,
-            hasQuestionToken: true,
-        },
-    ];
-}
-/**
- * Generate hook function body
- */
-function generateHookBody(operation, documentConstName, variablesTypeName, resultTypeName) {
+    const resultInterfaceBody = t.tsInterfaceBody([
+        t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(resultType)))),
+    ]);
+    const resultInterface = t.tsInterfaceDeclaration(t.identifier(resultTypeName), null, null, resultInterfaceBody);
+    statements.push(t.exportNamedDeclaration(resultInterface));
     const hasArgs = operation.args.length > 0;
+    const hookBodyStatements = [];
+    const mutationOptions = [];
+    if (useCentralizedKeys) {
+        mutationOptions.push(t.objectProperty(t.identifier('mutationKey'), t.callExpression(t.memberExpression(t.identifier('customMutationKeys'), t.identifier(operation.name)), [])));
+    }
     if (hasArgs) {
-        return `return useMutation({
-    mutationFn: (variables: ${variablesTypeName}) =>
-      execute<${resultTypeName}, ${variablesTypeName}>(
-        ${documentConstName},
-        variables
-      ),
-    ...options,
-  });`;
+        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)))], t.callExpression(t.identifier('execute'), [
+            t.identifier(documentConstName),
+            t.identifier('variables'),
+        ]))));
     }
     else {
-        return `return useMutation({
-    mutationFn: () => execute<${resultTypeName}>(${documentConstName}),
-    ...options,
-  });`;
+        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [t.identifier(documentConstName)]))));
     }
+    mutationOptions.push(t.spreadElement(t.identifier('options')));
+    hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useMutation'), [t.objectExpression(mutationOptions)])));
+    const optionsType = hasArgs
+        ? `Omit<UseMutationOptions<${resultTypeName}, Error, ${variablesTypeName}>, 'mutationFn'>`
+        : `Omit<UseMutationOptions<${resultTypeName}, Error, void>, 'mutationFn'>`;
+    const optionsParam = t.identifier('options');
+    optionsParam.optional = true;
+    optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(optionsType)));
+    const hookFunc = t.functionDeclaration(t.identifier(hookName), [optionsParam], t.blockStatement(hookBodyStatements));
+    const hookExport = t.exportNamedDeclaration(hookFunc);
+    statements.push(hookExport);
+    const code = generateCode(statements);
+    const content = getGeneratedFileHeader(`Custom mutation hook for ${operation.name}`) + '\n\n' + code;
+    return {
+        fileName,
+        content,
+        operationName: operation.name,
+    };
 }
-/**
- * Generate all custom mutation hook files
- * When reactQueryEnabled is false, returns empty array since mutations require React Query
- */
 export function generateAllCustomMutationHooks(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 === 'mutation')
         .map((operation) => generateCustomMutationHook({
@@ -174,6 +132,7 @@ export function generateAllCustomMutationHooks(options) {
         skipQueryField,
         reactQueryEnabled,
         tableTypeNames,
+        useCentralizedKeys,
     }))
         .filter((result) => result !== null);
 }

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

@@ -21,26 +21,18 @@ export interface GenerateCustomQueryHookOptions {
     typeRegistry: TypeRegistry;
     maxDepth?: number;
     skipQueryField?: boolean;
-    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
     reactQueryEnabled?: boolean;
-    /** Table entity type names (for import path resolution) */
     tableTypeNames?: Set<string>;
+    useCentralizedKeys?: boolean;
 }
-/**
- * Generate a custom query hook file
- */
 export declare function generateCustomQueryHook(options: GenerateCustomQueryHookOptions): GeneratedCustomQueryFile;
 export interface GenerateAllCustomQueryHooksOptions {
     operations: CleanOperation[];
     typeRegistry: TypeRegistry;
     maxDepth?: number;
     skipQueryField?: boolean;
-    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
     reactQueryEnabled?: boolean;
-    /** Table entity type names (for import path resolution) */
     tableTypeNames?: Set<string>;
+    useCentralizedKeys?: boolean;
 }
-/**
- * Generate all custom query hook files
- */
 export declare function generateAllCustomQueryHooks(options: GenerateAllCustomQueryHooksOptions): GeneratedCustomQueryFile[];