@constructive-io/graphql-codegen 2.23.3 → 2.24.1

package/cli/codegen/mutation-keys.js

@@ -0,0 +1,247 @@
+"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.generateMutationKeysFile = generateMutationKeysFile;
+const utils_1 = require("./utils");
+const t = __importStar(require("@babel/types"));
+const babel_ast_1 = require("./babel-ast");
+/**
+ * Generate mutation keys declaration for a single table entity
+ */
+function generateEntityMutationKeysDeclaration(table, relationships) {
+    const { typeName, singularName } = (0, utils_1.getTableNames)(table);
+    const entityKey = typeName.toLowerCase();
+    const keysName = `${(0, utils_1.lcFirst)(typeName)}MutationKeys`;
+    const relationship = relationships[entityKey];
+    const properties = [];
+    // all property
+    const allProp = t.objectProperty(t.identifier('all'), (0, babel_ast_1.constArray)([t.stringLiteral('mutation'), t.stringLiteral(entityKey)]));
+    (0, babel_ast_1.addJSDocComment)(allProp, [`All ${singularName} mutation keys`]);
+    properties.push(allProp);
+    // create property
+    let createProp;
+    if (relationship) {
+        const fkParam = t.identifier(relationship.foreignKey);
+        fkParam.optional = true;
+        fkParam.typeAnnotation = t.tsTypeAnnotation(t.tsStringKeyword());
+        const arrowFn = t.arrowFunctionExpression([fkParam], t.conditionalExpression(t.identifier(relationship.foreignKey), (0, babel_ast_1.constArray)([
+            t.stringLiteral('mutation'),
+            t.stringLiteral(entityKey),
+            t.stringLiteral('create'),
+            t.objectExpression([
+                t.objectProperty(t.identifier(relationship.foreignKey), t.identifier(relationship.foreignKey), false, true)
+            ]),
+        ]), (0, babel_ast_1.constArray)([
+            t.stringLiteral('mutation'),
+            t.stringLiteral(entityKey),
+            t.stringLiteral('create'),
+        ])));
+        createProp = t.objectProperty(t.identifier('create'), arrowFn);
+    }
+    else {
+        const arrowFn = t.arrowFunctionExpression([], (0, babel_ast_1.constArray)([
+            t.stringLiteral('mutation'),
+            t.stringLiteral(entityKey),
+            t.stringLiteral('create'),
+        ]));
+        createProp = t.objectProperty(t.identifier('create'), arrowFn);
+    }
+    (0, babel_ast_1.addJSDocComment)(createProp, [`Create ${singularName} mutation key`]);
+    properties.push(createProp);
+    // update property
+    const updateArrowFn = t.arrowFunctionExpression([(0, babel_ast_1.typedParam)('id', t.tsUnionType([t.tsStringKeyword(), t.tsNumberKeyword()]))], (0, babel_ast_1.constArray)([
+        t.stringLiteral('mutation'),
+        t.stringLiteral(entityKey),
+        t.stringLiteral('update'),
+        t.identifier('id'),
+    ]));
+    const updateProp = t.objectProperty(t.identifier('update'), updateArrowFn);
+    (0, babel_ast_1.addJSDocComment)(updateProp, [`Update ${singularName} mutation key`]);
+    properties.push(updateProp);
+    // delete property
+    const deleteArrowFn = t.arrowFunctionExpression([(0, babel_ast_1.typedParam)('id', t.tsUnionType([t.tsStringKeyword(), t.tsNumberKeyword()]))], (0, babel_ast_1.constArray)([
+        t.stringLiteral('mutation'),
+        t.stringLiteral(entityKey),
+        t.stringLiteral('delete'),
+        t.identifier('id'),
+    ]));
+    const deleteProp = t.objectProperty(t.identifier('delete'), deleteArrowFn);
+    (0, babel_ast_1.addJSDocComment)(deleteProp, [`Delete ${singularName} mutation key`]);
+    properties.push(deleteProp);
+    return t.exportNamedDeclaration(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier(keysName), (0, babel_ast_1.asConst)(t.objectExpression(properties)))
+    ]));
+}
+/**
+ * Generate custom mutation keys declaration
+ */
+function generateCustomMutationKeysDeclaration(operations) {
+    if (operations.length === 0)
+        return null;
+    const properties = [];
+    for (const op of operations) {
+        const hasArgs = op.args.length > 0;
+        let prop;
+        if (hasArgs) {
+            const identifierParam = t.identifier('identifier');
+            identifierParam.optional = true;
+            identifierParam.typeAnnotation = t.tsTypeAnnotation(t.tsStringKeyword());
+            const arrowFn = t.arrowFunctionExpression([identifierParam], t.conditionalExpression(t.identifier('identifier'), (0, babel_ast_1.constArray)([
+                t.stringLiteral('mutation'),
+                t.stringLiteral(op.name),
+                t.identifier('identifier'),
+            ]), (0, babel_ast_1.constArray)([t.stringLiteral('mutation'), t.stringLiteral(op.name)])));
+            prop = t.objectProperty(t.identifier(op.name), arrowFn);
+        }
+        else {
+            const arrowFn = t.arrowFunctionExpression([], (0, babel_ast_1.constArray)([t.stringLiteral('mutation'), t.stringLiteral(op.name)]));
+            prop = t.objectProperty(t.identifier(op.name), arrowFn);
+        }
+        (0, babel_ast_1.addJSDocComment)(prop, [`Mutation key for ${op.name}`]);
+        properties.push(prop);
+    }
+    return t.exportNamedDeclaration(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('customMutationKeys'), (0, babel_ast_1.asConst)(t.objectExpression(properties)))
+    ]));
+}
+/**
+ * Generate the unified mutation keys store declaration
+ */
+function generateUnifiedMutationStoreDeclaration(tables, hasCustomMutations) {
+    const properties = [];
+    for (const table of tables) {
+        const { typeName } = (0, utils_1.getTableNames)(table);
+        const keysName = `${(0, utils_1.lcFirst)(typeName)}MutationKeys`;
+        properties.push(t.objectProperty(t.identifier((0, utils_1.lcFirst)(typeName)), t.identifier(keysName)));
+    }
+    if (hasCustomMutations) {
+        properties.push(t.objectProperty(t.identifier('custom'), t.identifier('customMutationKeys')));
+    }
+    const decl = t.exportNamedDeclaration(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('mutationKeys'), (0, babel_ast_1.asConst)(t.objectExpression(properties)))
+    ]));
+    (0, babel_ast_1.addJSDocComment)(decl, [
+        'Unified mutation key store',
+        '',
+        'Use this for tracking in-flight mutations with useIsMutating.',
+        '',
+        '@example',
+        '```ts',
+        "import { useIsMutating } from '@tanstack/react-query';",
+        "import { mutationKeys } from './generated';",
+        '',
+        '// Check if any user mutations are in progress',
+        'const isMutatingUser = useIsMutating({ mutationKey: mutationKeys.user.all });',
+        '',
+        '// Check if a specific user is being updated',
+        'const isUpdating = useIsMutating({ mutationKey: mutationKeys.user.update(userId) });',
+        '```',
+    ]);
+    return decl;
+}
+/**
+ * Generate the complete mutation-keys.ts file
+ */
+function generateMutationKeysFile(options) {
+    const { tables, customMutations, config } = options;
+    const { relationships } = config;
+    const statements = [];
+    // Generate entity mutation keys
+    for (const table of tables) {
+        statements.push(generateEntityMutationKeysDeclaration(table, relationships));
+    }
+    // Generate custom mutation keys
+    const mutationOperations = customMutations.filter((op) => op.kind === 'mutation');
+    const customKeysDecl = generateCustomMutationKeysDeclaration(mutationOperations);
+    if (customKeysDecl) {
+        statements.push(customKeysDecl);
+    }
+    // Generate unified store
+    statements.push(generateUnifiedMutationStoreDeclaration(tables, mutationOperations.length > 0));
+    // Generate code from AST
+    const code = (0, babel_ast_1.generateCode)(statements);
+    // Build final content with header and section comments
+    const header = (0, utils_1.getGeneratedFileHeader)('Centralized mutation key factory');
+    const description = `// ============================================================================
+// Mutation keys for tracking in-flight mutations
+//
+// Benefits:
+// - Track mutation state with useIsMutating
+// - Implement optimistic updates with proper rollback
+// - Deduplicate identical mutations
+// - Coordinate related mutations
+// ============================================================================`;
+    let content = `${header}
+
+${description}
+
+// ============================================================================
+// Entity Mutation Keys
+// ============================================================================
+
+`;
+    // Insert section comments into the generated code
+    const codeLines = code.split('\n');
+    let addedCustomSection = false;
+    let addedUnifiedSection = false;
+    for (let i = 0; i < codeLines.length; i++) {
+        const line = codeLines[i];
+        // Detect custom mutation keys section
+        if (!addedCustomSection && line.startsWith('export const customMutationKeys')) {
+            content += `
+// ============================================================================
+// Custom Mutation Keys
+// ============================================================================
+
+`;
+            addedCustomSection = true;
+        }
+        // Detect unified store section
+        if (!addedUnifiedSection && line.includes('* Unified mutation key store')) {
+            content += `
+// ============================================================================
+// Unified Mutation Key Store
+// ============================================================================
+
+`;
+            addedUnifiedSection = true;
+        }
+        content += line + '\n';
+    }
+    return {
+        fileName: 'mutation-keys.ts',
+        content,
+    };
+}

package/cli/codegen/mutations.d.ts

@@ -1,5 +1,5 @@
 /**
- * Mutation hook generators using AST-based code generation
+ * Mutation hook generators using Babel AST-based code generation
  *
  * Output structure:
  * mutations/
@@ -13,28 +13,14 @@ export interface GeneratedMutationFile {
     content: string;
 }
 export interface MutationGeneratorOptions {
-    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
     reactQueryEnabled?: boolean;
-    /** Enum type names that are available from schema-types.ts */
     enumsFromSchemaTypes?: string[];
+    useCentralizedKeys?: boolean;
+    hasRelationships?: boolean;
+    /** All table type names for determining which types to import from types.ts vs schema-types.ts */
+    tableTypeNames?: Set<string>;
 }
-/**
- * Generate create mutation hook file content using AST
- * When reactQueryEnabled is false, returns null since mutations require React Query
- */
 export declare function generateCreateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
-/**
- * Generate update mutation hook file content using AST
- * When reactQueryEnabled is false, returns null since mutations require React Query
- */
 export declare function generateUpdateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
-/**
- * Generate delete mutation hook file content using AST
- * When reactQueryEnabled is false, returns null since mutations require React Query
- */
 export declare function generateDeleteMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
-/**
- * Generate all mutation hook files for all tables
- * When reactQueryEnabled is false, returns empty array since mutations require React Query
- */
 export declare function generateAllMutationHooks(tables: CleanTable[], options?: MutationGeneratorOptions): GeneratedMutationFile[];