@constructive-io/graphql-codegen 2.23.3 → 2.24.0

package/cli/codegen/custom-mutations.js

@@ -1,17 +1,55 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCustomMutationHook = generateCustomMutationHook;
 exports.generateAllCustomMutationHooks = generateAllCustomMutationHooks;
-const ts_ast_1 = require("./ts-ast");
+const t = __importStar(require("@babel/types"));
+const babel_ast_1 = require("./babel-ast");
 const schema_gql_ast_1 = require("./schema-gql-ast");
 const type_resolver_1 = require("./type-resolver");
-/**
- * Generate a custom mutation hook file
- * When reactQueryEnabled is false, returns null since mutations require React Query
- */
+const utils_1 = require("./utils");
+function generateVariablesProperties(args, tracker) {
+    return args.map((arg) => ({
+        name: arg.name,
+        type: (0, type_resolver_1.typeRefToTsType)(arg.type, tracker),
+        optional: !(0, type_resolver_1.isTypeRequired)(arg.type),
+        docs: arg.description ? [arg.description] : undefined,
+    }));
+}
 function generateCustomMutationHook(options) {
     const { operation, reactQueryEnabled = true } = options;
-    // Mutations require React Query - skip generation when disabled
     if (!reactQueryEnabled) {
         return null;
     }
@@ -25,150 +63,103 @@ function generateCustomMutationHook(options) {
     }
 }
 function generateCustomMutationHookInternal(options) {
-    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, tableTypeNames } = options;
-    const project = (0, ts_ast_1.createProject)();
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, tableTypeNames, useCentralizedKeys = true, } = options;
     const hookName = (0, type_resolver_1.getOperationHookName)(operation.name, 'mutation');
     const fileName = (0, type_resolver_1.getOperationFileName)(operation.name, 'mutation');
     const variablesTypeName = (0, type_resolver_1.getOperationVariablesTypeName)(operation.name, 'mutation');
     const resultTypeName = (0, type_resolver_1.getOperationResultTypeName)(operation.name, 'mutation');
     const documentConstName = (0, type_resolver_1.getDocumentConstName)(operation.name, 'mutation');
-    // Create type tracker to collect referenced types (with table type awareness)
     const tracker = (0, type_resolver_1.createTypeTracker)({ tableTypeNames });
-    // Generate GraphQL document
     const mutationDocument = (0, schema_gql_ast_1.buildCustomMutationString)({
         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 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 = (0, type_resolver_1.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 = [
-        (0, ts_ast_1.createImport)({
-            moduleSpecifier: '@tanstack/react-query',
-            namedImports: ['useMutation'],
-            typeOnlyNamedImports: ['UseMutationOptions'],
-        }),
-        (0, ts_ast_1.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((0, ts_ast_1.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((0, ts_ast_1.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((0, ts_ast_1.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);
+    (0, babel_ast_1.addJSDocComment)(mutationDocExport, ['GraphQL mutation document']);
+    statements.push(mutationDocExport);
     if (operation.args.length > 0) {
-        sourceFile.addInterface((0, ts_ast_1.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((0, ts_ast_1.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: (0, ts_ast_1.getFormattedOutput)(sourceFile),
-        operationName: operation.name,
-    };
-}
-// ============================================================================
-// Helper functions
-// ============================================================================
-/**
- * Generate interface properties from CleanArguments
- */
-function generateVariablesProperties(args, tracker) {
-    return args.map((arg) => ({
-        name: arg.name,
-        type: (0, type_resolver_1.typeRefToTsType)(arg.type, tracker),
-        optional: !(0, type_resolver_1.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([(0, babel_ast_1.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 = (0, babel_ast_1.generateCode)(statements);
+    const content = (0, utils_1.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
- */
 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({
@@ -178,6 +169,7 @@ function generateAllCustomMutationHooks(options) {
         skipQueryField,
         reactQueryEnabled,
         tableTypeNames,
+        useCentralizedKeys,
     }))
         .filter((result) => result !== null);
 }

package/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[];