@constructive-io/graphql-codegen 2.18.0 → 2.20.0

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

@@ -0,0 +1,346 @@
+import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, } from '../ts-ast';
+import { ucFirst } from '../utils';
+import { typeRefToTsType, isTypeRequired, getTypeBaseName } from '../type-resolver';
+import { SCALAR_NAMES } from '../scalars';
+/**
+ * Collect all input type names used by operations
+ */
+function collectInputTypeNamesFromOps(operations) {
+    const inputTypes = new Set();
+    for (const op of operations) {
+        for (const arg of op.args) {
+            const baseName = getTypeBaseName(arg.type);
+            if (baseName && (baseName.endsWith('Input') || baseName.endsWith('Filter'))) {
+                inputTypes.add(baseName);
+            }
+        }
+    }
+    return Array.from(inputTypes);
+}
+// Types that don't need Select types
+const NON_SELECT_TYPES = new Set([...SCALAR_NAMES, 'Query', 'Mutation']);
+/**
+ * Collect all payload/return type names from operations (for Select types)
+ * Filters out scalar types
+ */
+function collectPayloadTypeNamesFromOps(operations) {
+    const payloadTypes = new Set();
+    for (const op of operations) {
+        const baseName = getTypeBaseName(op.returnType);
+        if (baseName &&
+            !baseName.endsWith('Connection') &&
+            baseName !== 'Query' &&
+            baseName !== 'Mutation' &&
+            !NON_SELECT_TYPES.has(baseName)) {
+            payloadTypes.add(baseName);
+        }
+    }
+    return Array.from(payloadTypes);
+}
+/**
+ * Get the Select type name for a return type
+ * Returns null for scalar types, Connection types (no select needed)
+ */
+function getSelectTypeName(returnType) {
+    const baseName = getTypeBaseName(returnType);
+    if (baseName &&
+        !NON_SELECT_TYPES.has(baseName) &&
+        baseName !== 'Query' &&
+        baseName !== 'Mutation' &&
+        !baseName.endsWith('Connection')) {
+        return `${baseName}Select`;
+    }
+    return null;
+}
+/**
+ * Generate the query/index.ts file for custom query operations
+ */
+export function generateCustomQueryOpsFile(operations) {
+    const project = createProject();
+    const sourceFile = createSourceFile(project, 'index.ts');
+    // 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');
+    // 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
+    if (allTypeImports.length > 0) {
+        sourceFile.addImportDeclarations([
+            createImport({
+                moduleSpecifier: '../input-types',
+                typeOnlyNamedImports: allTypeImports,
+            }),
+        ]);
+    }
+    // Generate variable definitions type for each operation
+    sourceFile.addStatements('\n// ============================================================================');
+    sourceFile.addStatements('// Variable Types');
+    sourceFile.addStatements('// ============================================================================\n');
+    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`);
+        }
+    }
+    // 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    ')},
+  };`,
+    });
+    return {
+        fileName: 'query/index.ts',
+        content: getFormattedOutput(sourceFile),
+    };
+}
+/**
+ * Generate the mutation/index.ts file for custom mutation operations
+ */
+export function generateCustomMutationOpsFile(operations) {
+    const project = createProject();
+    const sourceFile = createSourceFile(project, 'index.ts');
+    // 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');
+    // 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
+    if (allTypeImports.length > 0) {
+        sourceFile.addImportDeclarations([
+            createImport({
+                moduleSpecifier: '../input-types',
+                typeOnlyNamedImports: allTypeImports,
+            }),
+        ]);
+    }
+    // Generate variable definitions type for each operation
+    sourceFile.addStatements('\n// ============================================================================');
+    sourceFile.addStatements('// Variable Types');
+    sourceFile.addStatements('// ============================================================================\n');
+    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`);
+        }
+    }
+    // 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    ')},
+  };`,
+    });
+    return {
+        fileName: 'mutation/index.ts',
+        content: getFormattedOutput(sourceFile),
+    };
+}
+/**
+ * Format a CleanTypeRef to GraphQL type string
+ */
+function formatGraphQLType(typeRef) {
+    let result = '';
+    if (typeRef.kind === 'NON_NULL') {
+        if (typeRef.ofType) {
+            result = formatGraphQLType(typeRef.ofType) + '!';
+        }
+        else {
+            result = (typeRef.name ?? 'String') + '!';
+        }
+    }
+    else if (typeRef.kind === 'LIST') {
+        if (typeRef.ofType) {
+            result = `[${formatGraphQLType(typeRef.ofType)}]`;
+        }
+        else {
+            result = '[String]';
+        }
+    }
+    else {
+        result = typeRef.name ?? 'String';
+    }
+    return result;
+}

package/esm/cli/codegen/orm/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ORM Generator Orchestrator
+ *
+ * Main entry point for ORM code generation. Coordinates all generators
+ * and produces the complete ORM client output.
+ */
+import type { CleanTable, CleanOperation, TypeRegistry } from '../../../types/schema';
+import type { ResolvedConfig } from '../../../types/config';
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export interface GenerateOrmOptions {
+    tables: CleanTable[];
+    customOperations?: {
+        queries: CleanOperation[];
+        mutations: CleanOperation[];
+        typeRegistry?: TypeRegistry;
+    };
+    config: ResolvedConfig;
+}
+export interface GenerateOrmResult {
+    files: GeneratedFile[];
+    stats: {
+        tables: number;
+        customQueries: number;
+        customMutations: number;
+        totalFiles: number;
+    };
+}
+/**
+ * Generate all ORM client files
+ */
+export declare function generateOrm(options: GenerateOrmOptions): GenerateOrmResult;
+export { generateOrmClientFile, generateQueryBuilderFile, generateSelectTypesFile } from './client-generator';
+export { generateModelFile, generateAllModelFiles } from './model-generator';
+export { generateCustomQueryOpsFile, generateCustomMutationOpsFile } from './custom-ops-generator';
+export { generateModelsBarrel, generateTypesBarrel } from './barrel';

package/esm/cli/codegen/orm/index.js

@@ -0,0 +1,75 @@
+import { generateOrmClientFile, generateQueryBuilderFile, generateSelectTypesFile, generateCreateClientFile, } from './client-generator';
+import { generateAllModelFiles } from './model-generator';
+import { generateCustomQueryOpsFile, generateCustomMutationOpsFile, } from './custom-ops-generator';
+import { generateModelsBarrel, generateTypesBarrel } from './barrel';
+import { generateInputTypesFile, collectInputTypeNames, collectPayloadTypeNames } from './input-types-generator';
+/**
+ * Generate all ORM client files
+ */
+export function generateOrm(options) {
+    const { tables, customOperations, config } = options;
+    const files = [];
+    const useSharedTypes = config.orm?.useSharedTypes ?? true;
+    const hasCustomQueries = (customOperations?.queries.length ?? 0) > 0;
+    const hasCustomMutations = (customOperations?.mutations.length ?? 0) > 0;
+    const typeRegistry = customOperations?.typeRegistry;
+    // 1. Generate runtime files (client, query-builder, select-types)
+    const clientFile = generateOrmClientFile();
+    files.push({ path: clientFile.fileName, content: clientFile.content });
+    const queryBuilderFile = generateQueryBuilderFile();
+    files.push({ path: queryBuilderFile.fileName, content: queryBuilderFile.content });
+    const selectTypesFile = generateSelectTypesFile();
+    files.push({ path: selectTypesFile.fileName, content: selectTypesFile.content });
+    // 2. Generate model files
+    const modelFiles = generateAllModelFiles(tables, useSharedTypes);
+    for (const modelFile of modelFiles) {
+        files.push({
+            path: `models/${modelFile.fileName}`,
+            content: modelFile.content,
+        });
+    }
+    // 3. Generate models barrel
+    const modelsBarrel = generateModelsBarrel(tables);
+    files.push({ path: modelsBarrel.fileName, content: modelsBarrel.content });
+    // 4. Generate comprehensive input types (entities, filters, orderBy, CRUD inputs, custom inputs, payload types)
+    // Always generate if we have tables or custom operations
+    if (tables.length > 0 || (typeRegistry && (hasCustomQueries || hasCustomMutations))) {
+        const allOps = [
+            ...(customOperations?.queries ?? []),
+            ...(customOperations?.mutations ?? []),
+        ];
+        const usedInputTypes = collectInputTypeNames(allOps);
+        const usedPayloadTypes = collectPayloadTypeNames(allOps);
+        const inputTypesFile = generateInputTypesFile(typeRegistry ?? new Map(), usedInputTypes, tables, usedPayloadTypes);
+        files.push({ path: inputTypesFile.fileName, content: inputTypesFile.content });
+    }
+    // 5. Generate custom operations (if any)
+    if (hasCustomQueries && customOperations?.queries) {
+        const queryOpsFile = generateCustomQueryOpsFile(customOperations.queries);
+        files.push({ path: queryOpsFile.fileName, content: queryOpsFile.content });
+    }
+    if (hasCustomMutations && customOperations?.mutations) {
+        const mutationOpsFile = generateCustomMutationOpsFile(customOperations.mutations);
+        files.push({ path: mutationOpsFile.fileName, content: mutationOpsFile.content });
+    }
+    // 6. Generate types barrel
+    const typesBarrel = generateTypesBarrel(useSharedTypes);
+    files.push({ path: typesBarrel.fileName, content: typesBarrel.content });
+    // 7. Generate main index.ts with createClient
+    const indexFile = generateCreateClientFile(tables, hasCustomQueries, hasCustomMutations);
+    files.push({ path: indexFile.fileName, content: indexFile.content });
+    return {
+        files,
+        stats: {
+            tables: tables.length,
+            customQueries: customOperations?.queries.length ?? 0,
+            customMutations: customOperations?.mutations.length ?? 0,
+            totalFiles: files.length,
+        },
+    };
+}
+// Re-export generators for direct use
+export { generateOrmClientFile, generateQueryBuilderFile, generateSelectTypesFile } from './client-generator';
+export { generateModelFile, generateAllModelFiles } from './model-generator';
+export { generateCustomQueryOpsFile, generateCustomMutationOpsFile } from './custom-ops-generator';
+export { generateModelsBarrel, generateTypesBarrel } from './barrel';

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

@@ -0,0 +1,21 @@
+import type { TypeRegistry, CleanArgument, CleanTable } from '../../../types/schema';
+export interface GeneratedInputTypesFile {
+    fileName: string;
+    content: string;
+}
+/**
+ * Collect all input type names used by operations
+ */
+export declare function collectInputTypeNames(operations: Array<{
+    args: CleanArgument[];
+}>): Set<string>;
+/**
+ * Collect all payload type names from operation return types
+ */
+export declare function collectPayloadTypeNames(operations: Array<{
+    returnType: CleanArgument['type'];
+}>): Set<string>;
+/**
+ * Generate comprehensive input-types.ts file using ts-morph AST
+ */
+export declare function generateInputTypesFile(typeRegistry: TypeRegistry, usedInputTypes: Set<string>, tables?: CleanTable[], usedPayloadTypes?: Set<string>): GeneratedInputTypesFile;