@constructive-io/graphql-codegen 2.23.3 → 2.24.1

package/esm/cli/codegen/orm/custom-ops-generator.js

@@ -1,5 +1,6 @@
-import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, } from '../ts-ast';
-import { ucFirst } from '../utils';
+import * as t from '@babel/types';
+import { generateCode } from '../babel-ast';
+import { ucFirst, getGeneratedFileHeader } from '../utils';
 import { typeRefToTsType, isTypeRequired, getTypeBaseName, } from '../type-resolver';
 import { SCALAR_NAMES } from '../scalars';
 /**
@@ -61,274 +62,197 @@ function getSelectTypeName(returnType) {
     }
     return null;
 }
+function createImportDeclaration(moduleSpecifier, namedImports, typeOnly = false) {
+    const specifiers = namedImports.map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
+    const decl = t.importDeclaration(specifiers, t.stringLiteral(moduleSpecifier));
+    decl.importKind = typeOnly ? 'type' : 'value';
+    return decl;
+}
+function createVariablesInterface(op) {
+    if (op.args.length === 0)
+        return null;
+    const varTypeName = `${ucFirst(op.name)}Variables`;
+    const props = op.args.map((arg) => {
+        const optional = !isTypeRequired(arg.type);
+        const prop = t.tsPropertySignature(t.identifier(arg.name), t.tsTypeAnnotation(parseTypeAnnotation(typeRefToTsType(arg.type))));
+        prop.optional = optional;
+        return prop;
+    });
+    const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(varTypeName), null, null, t.tsInterfaceBody(props));
+    return t.exportNamedDeclaration(interfaceDecl);
+}
+function parseTypeAnnotation(typeStr) {
+    if (typeStr === 'string')
+        return t.tsStringKeyword();
+    if (typeStr === 'number')
+        return t.tsNumberKeyword();
+    if (typeStr === 'boolean')
+        return t.tsBooleanKeyword();
+    if (typeStr === 'null')
+        return t.tsNullKeyword();
+    if (typeStr === 'undefined')
+        return t.tsUndefinedKeyword();
+    if (typeStr === 'unknown')
+        return t.tsUnknownKeyword();
+    if (typeStr.includes(' | ')) {
+        const parts = typeStr.split(' | ').map((p) => parseTypeAnnotation(p.trim()));
+        return t.tsUnionType(parts);
+    }
+    if (typeStr.endsWith('[]')) {
+        return t.tsArrayType(parseTypeAnnotation(typeStr.slice(0, -2)));
+    }
+    return t.tsTypeReference(t.identifier(typeStr));
+}
+function buildOperationMethod(op, operationType) {
+    const hasArgs = op.args.length > 0;
+    const varTypeName = `${ucFirst(op.name)}Variables`;
+    const varDefs = op.args.map((arg) => ({
+        name: arg.name,
+        type: formatGraphQLType(arg.type),
+    }));
+    const selectTypeName = getSelectTypeName(op.returnType);
+    const payloadTypeName = getTypeBaseName(op.returnType);
+    // Build the arrow function parameters
+    const params = [];
+    if (hasArgs) {
+        const argsParam = t.identifier('args');
+        argsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(varTypeName)));
+        params.push(argsParam);
+    }
+    const optionsParam = t.identifier('options');
+    optionsParam.optional = true;
+    if (selectTypeName) {
+        optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeLiteral([
+            (() => {
+                const prop = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('S'))));
+                prop.optional = true;
+                return prop;
+            })(),
+        ]));
+    }
+    else {
+        optionsParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeLiteral([
+            (() => {
+                const prop = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([t.tsStringKeyword(), t.tsUnknownKeyword()]))));
+                prop.optional = true;
+                return prop;
+            })(),
+        ]));
+    }
+    params.push(optionsParam);
+    // Build the QueryBuilder call
+    const queryBuilderArgs = t.objectExpression([
+        t.objectProperty(t.identifier('client'), t.identifier('client'), false, true),
+        t.objectProperty(t.identifier('operation'), t.stringLiteral(operationType)),
+        t.objectProperty(t.identifier('operationName'), t.stringLiteral(ucFirst(op.name))),
+        t.objectProperty(t.identifier('fieldName'), t.stringLiteral(op.name)),
+        t.spreadElement(t.callExpression(t.identifier('buildCustomDocument'), [
+            t.stringLiteral(operationType),
+            t.stringLiteral(ucFirst(op.name)),
+            t.stringLiteral(op.name),
+            t.optionalMemberExpression(t.identifier('options'), t.identifier('select'), false, true),
+            hasArgs ? t.identifier('args') : t.identifier('undefined'),
+            t.arrayExpression(varDefs.map((v) => t.objectExpression([
+                t.objectProperty(t.identifier('name'), t.stringLiteral(v.name)),
+                t.objectProperty(t.identifier('type'), t.stringLiteral(v.type)),
+            ]))),
+        ])),
+    ]);
+    const newExpr = t.newExpression(t.identifier('QueryBuilder'), [queryBuilderArgs]);
+    // Add type parameter if we have a select type
+    if (selectTypeName && payloadTypeName) {
+        newExpr.typeParameters = t.tsTypeParameterInstantiation([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(op.name), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('InferSelectResult'), t.tsTypeParameterInstantiation([
+                    t.tsTypeReference(t.identifier(payloadTypeName)),
+                    t.tsTypeReference(t.identifier('S')),
+                ])))),
+            ]),
+        ]);
+    }
+    const arrowFunc = t.arrowFunctionExpression(params, newExpr);
+    // Add type parameters to arrow function if we have a select type
+    if (selectTypeName) {
+        const typeParam = t.tsTypeParameter(t.tsTypeReference(t.identifier(selectTypeName)), null, 'S');
+        typeParam.const = true;
+        arrowFunc.typeParameters = t.tsTypeParameterDeclaration([typeParam]);
+    }
+    return t.objectProperty(t.identifier(op.name), arrowFunc);
+}
 /**
  * Generate the query/index.ts file for custom query operations
  */
 export function generateCustomQueryOpsFile(operations) {
-    const project = createProject();
-    const sourceFile = createSourceFile(project, 'index.ts');
+    const statements = [];
     // Collect all input type names and payload type names
     const inputTypeNames = collectInputTypeNamesFromOps(operations);
     const payloadTypeNames = collectPayloadTypeNamesFromOps(operations);
-    // Generate Select type names for payloads
     const selectTypeNames = payloadTypeNames.map((p) => `${p}Select`);
-    // Combine all type imports
-    const allTypeImports = [
-        ...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames]),
-    ];
-    // Add file header
-    sourceFile.insertText(0, createFileHeader('Custom query operations') + '\n\n');
+    const allTypeImports = [...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames])];
     // Add imports
-    sourceFile.addImportDeclarations([
-        createImport({
-            moduleSpecifier: '../client',
-            namedImports: ['OrmClient'],
-        }),
-        createImport({
-            moduleSpecifier: '../query-builder',
-            namedImports: ['QueryBuilder', 'buildCustomDocument'],
-        }),
-        createImport({
-            moduleSpecifier: '../select-types',
-            typeOnlyNamedImports: ['InferSelectResult'],
-        }),
-    ]);
-    // Import types from input-types if we have any
+    statements.push(createImportDeclaration('../client', ['OrmClient']));
+    statements.push(createImportDeclaration('../query-builder', ['QueryBuilder', 'buildCustomDocument']));
+    statements.push(createImportDeclaration('../select-types', ['InferSelectResult'], true));
     if (allTypeImports.length > 0) {
-        sourceFile.addImportDeclarations([
-            createImport({
-                moduleSpecifier: '../input-types',
-                typeOnlyNamedImports: allTypeImports,
-            }),
-        ]);
+        statements.push(createImportDeclaration('../input-types', allTypeImports, true));
     }
-    // Generate variable definitions type for each operation
-    sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Variable Types');
-    sourceFile.addStatements('// ============================================================================\n');
+    // Generate variable interfaces
     for (const op of operations) {
-        if (op.args.length > 0) {
-            const varTypeName = `${ucFirst(op.name)}Variables`;
-            const props = op.args.map((arg) => {
-                const optional = !isTypeRequired(arg.type);
-                return `${arg.name}${optional ? '?' : ''}: ${typeRefToTsType(arg.type)};`;
-            });
-            sourceFile.addStatements(`export interface ${varTypeName} {\n  ${props.join('\n  ')}\n}\n`);
-        }
+        const varInterface = createVariablesInterface(op);
+        if (varInterface)
+            statements.push(varInterface);
     }
     // Generate factory function
-    sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Query Operations Factory');
-    sourceFile.addStatements('// ============================================================================\n');
-    // Build the operations object
-    const operationMethods = operations.map((op) => {
-        const hasArgs = op.args.length > 0;
-        const varTypeName = `${ucFirst(op.name)}Variables`;
-        const varDefs = op.args.map((arg) => ({
-            name: arg.name,
-            type: formatGraphQLType(arg.type),
-        }));
-        const varDefsJson = JSON.stringify(varDefs);
-        // Get Select type for return type
-        const selectTypeName = getSelectTypeName(op.returnType);
-        const payloadTypeName = getTypeBaseName(op.returnType);
-        // Use typed select if available, otherwise fall back to Record<string, unknown>
-        const selectType = selectTypeName ?? 'Record<string, unknown>';
-        const returnTypePart = selectTypeName && payloadTypeName
-            ? `{ ${op.name}: InferSelectResult<${payloadTypeName}, S> }`
-            : 'unknown';
-        if (hasArgs) {
-            if (selectTypeName) {
-                return `${op.name}: <const S extends ${selectType}>(args: ${varTypeName}, options?: { select?: S }) =>
-      new QueryBuilder<${returnTypePart}>({
-        client,
-        operation: 'query',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('query', '${ucFirst(op.name)}', '${op.name}', options?.select, args, ${varDefsJson}),
-      })`;
-            }
-            else {
-                return `${op.name}: (args: ${varTypeName}, options?: { select?: Record<string, unknown> }) =>
-      new QueryBuilder({
-        client,
-        operation: 'query',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('query', '${ucFirst(op.name)}', '${op.name}', options?.select, args, ${varDefsJson}),
-      })`;
-            }
-        }
-        else {
-            // No args - still provide typed select
-            if (selectTypeName) {
-                return `${op.name}: <const S extends ${selectType}>(options?: { select?: S }) =>
-      new QueryBuilder<${returnTypePart}>({
-        client,
-        operation: 'query',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('query', '${ucFirst(op.name)}', '${op.name}', options?.select, undefined, []),
-      })`;
-            }
-            else {
-                return `${op.name}: (options?: { select?: Record<string, unknown> }) =>
-      new QueryBuilder({
-        client,
-        operation: 'query',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('query', '${ucFirst(op.name)}', '${op.name}', options?.select, undefined, []),
-      })`;
-            }
-        }
-    });
-    sourceFile.addFunction({
-        name: 'createQueryOperations',
-        isExported: true,
-        parameters: [{ name: 'client', type: 'OrmClient' }],
-        statements: `return {
-    ${operationMethods.join(',\n    ')},
-  };`,
-    });
+    const operationProperties = operations.map((op) => buildOperationMethod(op, 'query'));
+    const returnObj = t.objectExpression(operationProperties);
+    const returnStmt = t.returnStatement(returnObj);
+    const clientParam = t.identifier('client');
+    clientParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('OrmClient')));
+    const factoryFunc = t.functionDeclaration(t.identifier('createQueryOperations'), [clientParam], t.blockStatement([returnStmt]));
+    statements.push(t.exportNamedDeclaration(factoryFunc));
+    const header = getGeneratedFileHeader('Custom query operations');
+    const code = generateCode(statements);
     return {
         fileName: 'query/index.ts',
-        content: getFormattedOutput(sourceFile),
+        content: header + '\n' + code,
     };
 }
 /**
  * Generate the mutation/index.ts file for custom mutation operations
  */
 export function generateCustomMutationOpsFile(operations) {
-    const project = createProject();
-    const sourceFile = createSourceFile(project, 'index.ts');
+    const statements = [];
     // Collect all input type names and payload type names
     const inputTypeNames = collectInputTypeNamesFromOps(operations);
     const payloadTypeNames = collectPayloadTypeNamesFromOps(operations);
-    // Generate Select type names for payloads
     const selectTypeNames = payloadTypeNames.map((p) => `${p}Select`);
-    // Combine all type imports
-    const allTypeImports = [
-        ...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames]),
-    ];
-    // Add file header
-    sourceFile.insertText(0, createFileHeader('Custom mutation operations') + '\n\n');
+    const allTypeImports = [...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames])];
     // Add imports
-    sourceFile.addImportDeclarations([
-        createImport({
-            moduleSpecifier: '../client',
-            namedImports: ['OrmClient'],
-        }),
-        createImport({
-            moduleSpecifier: '../query-builder',
-            namedImports: ['QueryBuilder', 'buildCustomDocument'],
-        }),
-        createImport({
-            moduleSpecifier: '../select-types',
-            typeOnlyNamedImports: ['InferSelectResult'],
-        }),
-    ]);
-    // Import types from input-types if we have any
+    statements.push(createImportDeclaration('../client', ['OrmClient']));
+    statements.push(createImportDeclaration('../query-builder', ['QueryBuilder', 'buildCustomDocument']));
+    statements.push(createImportDeclaration('../select-types', ['InferSelectResult'], true));
     if (allTypeImports.length > 0) {
-        sourceFile.addImportDeclarations([
-            createImport({
-                moduleSpecifier: '../input-types',
-                typeOnlyNamedImports: allTypeImports,
-            }),
-        ]);
+        statements.push(createImportDeclaration('../input-types', allTypeImports, true));
     }
-    // Generate variable definitions type for each operation
-    sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Variable Types');
-    sourceFile.addStatements('// ============================================================================\n');
+    // Generate variable interfaces
     for (const op of operations) {
-        if (op.args.length > 0) {
-            const varTypeName = `${ucFirst(op.name)}Variables`;
-            const props = op.args.map((arg) => {
-                const optional = !isTypeRequired(arg.type);
-                return `${arg.name}${optional ? '?' : ''}: ${typeRefToTsType(arg.type)};`;
-            });
-            sourceFile.addStatements(`export interface ${varTypeName} {\n  ${props.join('\n  ')}\n}\n`);
-        }
+        const varInterface = createVariablesInterface(op);
+        if (varInterface)
+            statements.push(varInterface);
     }
     // Generate factory function
-    sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Mutation Operations Factory');
-    sourceFile.addStatements('// ============================================================================\n');
-    // Build the operations object
-    const operationMethods = operations.map((op) => {
-        const hasArgs = op.args.length > 0;
-        const varTypeName = `${ucFirst(op.name)}Variables`;
-        const varDefs = op.args.map((arg) => ({
-            name: arg.name,
-            type: formatGraphQLType(arg.type),
-        }));
-        const varDefsJson = JSON.stringify(varDefs);
-        // Get Select type for return type
-        const selectTypeName = getSelectTypeName(op.returnType);
-        const payloadTypeName = getTypeBaseName(op.returnType);
-        // Use typed select if available, otherwise fall back to Record<string, unknown>
-        const selectType = selectTypeName ?? 'Record<string, unknown>';
-        const returnTypePart = selectTypeName && payloadTypeName
-            ? `{ ${op.name}: InferSelectResult<${payloadTypeName}, S> }`
-            : 'unknown';
-        if (hasArgs) {
-            if (selectTypeName) {
-                return `${op.name}: <const S extends ${selectType}>(args: ${varTypeName}, options?: { select?: S }) =>
-      new QueryBuilder<${returnTypePart}>({
-        client,
-        operation: 'mutation',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('mutation', '${ucFirst(op.name)}', '${op.name}', options?.select, args, ${varDefsJson}),
-      })`;
-            }
-            else {
-                return `${op.name}: (args: ${varTypeName}, options?: { select?: Record<string, unknown> }) =>
-      new QueryBuilder({
-        client,
-        operation: 'mutation',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('mutation', '${ucFirst(op.name)}', '${op.name}', options?.select, args, ${varDefsJson}),
-      })`;
-            }
-        }
-        else {
-            // No args - still provide typed select
-            if (selectTypeName) {
-                return `${op.name}: <const S extends ${selectType}>(options?: { select?: S }) =>
-      new QueryBuilder<${returnTypePart}>({
-        client,
-        operation: 'mutation',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('mutation', '${ucFirst(op.name)}', '${op.name}', options?.select, undefined, []),
-      })`;
-            }
-            else {
-                return `${op.name}: (options?: { select?: Record<string, unknown> }) =>
-      new QueryBuilder({
-        client,
-        operation: 'mutation',
-        operationName: '${ucFirst(op.name)}',
-        fieldName: '${op.name}',
-        ...buildCustomDocument('mutation', '${ucFirst(op.name)}', '${op.name}', options?.select, undefined, []),
-      })`;
-            }
-        }
-    });
-    sourceFile.addFunction({
-        name: 'createMutationOperations',
-        isExported: true,
-        parameters: [{ name: 'client', type: 'OrmClient' }],
-        statements: `return {
-    ${operationMethods.join(',\n    ')},
-  };`,
-    });
+    const operationProperties = operations.map((op) => buildOperationMethod(op, 'mutation'));
+    const returnObj = t.objectExpression(operationProperties);
+    const returnStmt = t.returnStatement(returnObj);
+    const clientParam = t.identifier('client');
+    clientParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier('OrmClient')));
+    const factoryFunc = t.functionDeclaration(t.identifier('createMutationOperations'), [clientParam], t.blockStatement([returnStmt]));
+    statements.push(t.exportNamedDeclaration(factoryFunc));
+    const header = getGeneratedFileHeader('Custom mutation operations');
+    const code = generateCode(statements);
     return {
         fileName: 'mutation/index.ts',
-        content: getFormattedOutput(sourceFile),
+        content: header + '\n' + code,
     };
 }
 /**

package/esm/cli/codegen/orm/input-types-generator.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Input types generator for ORM client (Babel AST-based)
+ *
+ * Generates TypeScript interfaces for:
+ * 1. Scalar filter types (StringFilter, IntFilter, UUIDFilter, etc.)
+ * 2. Entity interfaces (User, Order, etc.)
+ * 3. Table filter types (UserFilter, OrderFilter, etc.)
+ * 4. OrderBy enums (UsersOrderBy, OrdersOrderBy, etc.)
+ * 5. Input types (LoginInput, CreateUserInput, etc.)
+ *
+ * Uses Babel AST for robust code generation.
+ */
 import type { TypeRegistry, CleanArgument, CleanTable } from '../../../types/schema';
 export interface GeneratedInputTypesFile {
     fileName: string;
@@ -16,6 +28,6 @@ export declare function collectPayloadTypeNames(operations: Array<{
     returnType: CleanArgument['type'];
 }>): Set<string>;
 /**
- * Generate comprehensive input-types.ts file using ts-morph AST
+ * Generate comprehensive input-types.ts file using Babel AST
  */
 export declare function generateInputTypesFile(typeRegistry: TypeRegistry, usedInputTypes: Set<string>, tables?: CleanTable[], usedPayloadTypes?: Set<string>): GeneratedInputTypesFile;