@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/esm/cli/codegen/schema-gql-ast.js

@@ -0,0 +1,343 @@
+/**
+ * Dynamic GraphQL AST builders for custom operations
+ *
+ * Generates GraphQL query/mutation documents from CleanOperation data
+ * using gql-ast library for proper AST construction.
+ */
+import * as t from 'gql-ast';
+import { print } from 'graphql';
+import { getBaseTypeKind, shouldSkipField } from './type-resolver';
+// ============================================================================
+// Type Node Builders (GraphQL Type AST)
+// ============================================================================
+/**
+ * Build a GraphQL type node from CleanTypeRef
+ * Handles NON_NULL, LIST, and named types
+ */
+function buildTypeNode(typeRef) {
+    switch (typeRef.kind) {
+        case 'NON_NULL':
+            if (typeRef.ofType) {
+                const innerType = buildTypeNode(typeRef.ofType);
+                // Can't wrap NON_NULL in NON_NULL
+                if (innerType.kind === 'NonNullType') {
+                    return innerType;
+                }
+                return t.nonNullType({ type: innerType });
+            }
+            return t.namedType({ type: 'String' });
+        case 'LIST':
+            if (typeRef.ofType) {
+                return t.listType({ type: buildTypeNode(typeRef.ofType) });
+            }
+            return t.listType({ type: t.namedType({ type: 'String' }) });
+        case 'SCALAR':
+        case 'ENUM':
+        case 'OBJECT':
+        case 'INPUT_OBJECT':
+            return t.namedType({ type: typeRef.name ?? 'String' });
+        default:
+            return t.namedType({ type: typeRef.name ?? 'String' });
+    }
+}
+// ============================================================================
+// Variable Definition Builders
+// ============================================================================
+/**
+ * Build variable definitions from operation arguments
+ */
+export function buildVariableDefinitions(args) {
+    return args.map((arg) => t.variableDefinition({
+        variable: t.variable({ name: arg.name }),
+        type: buildTypeNode(arg.type),
+    }));
+}
+/**
+ * Build argument nodes that reference variables
+ */
+function buildArgumentNodes(args) {
+    return args.map((arg) => t.argument({
+        name: arg.name,
+        value: t.variable({ name: arg.name }),
+    }));
+}
+// ============================================================================
+// Field Selection Builders
+// ============================================================================
+/**
+ * Check if a type should have selections (is an object type)
+ */
+function typeNeedsSelections(typeRef) {
+    const baseKind = getBaseTypeKind(typeRef);
+    return baseKind === 'OBJECT';
+}
+/**
+ * Get the resolved fields for a type reference
+ * Uses type registry for deep resolution
+ */
+function getResolvedFields(typeRef, typeRegistry) {
+    // First check if fields are directly on the typeRef
+    if (typeRef.fields) {
+        return typeRef.fields;
+    }
+    // For wrapper types, unwrap and check
+    if (typeRef.ofType) {
+        return getResolvedFields(typeRef.ofType, typeRegistry);
+    }
+    // Look up in type registry
+    if (typeRegistry && typeRef.name) {
+        const resolved = typeRegistry.get(typeRef.name);
+        if (resolved?.fields) {
+            return resolved.fields;
+        }
+    }
+    return undefined;
+}
+/**
+ * Build field selections for an object type
+ * Recursively handles nested objects up to maxDepth
+ */
+export function buildFieldSelections(typeRef, config, currentDepth = 0) {
+    const { maxDepth, skipQueryField, typeRegistry } = config;
+    // Stop recursion at max depth
+    if (currentDepth >= maxDepth) {
+        return [];
+    }
+    const fields = getResolvedFields(typeRef, typeRegistry);
+    if (!fields || fields.length === 0) {
+        return [];
+    }
+    const selections = [];
+    for (const field of fields) {
+        // Skip internal fields
+        if (shouldSkipField(field.name, skipQueryField)) {
+            continue;
+        }
+        const fieldKind = getBaseTypeKind(field.type);
+        // For scalar and enum types, just add the field
+        if (fieldKind === 'SCALAR' || fieldKind === 'ENUM') {
+            selections.push(t.field({ name: field.name }));
+            continue;
+        }
+        // For object types, recurse if within depth limit
+        if (fieldKind === 'OBJECT' && currentDepth < maxDepth - 1) {
+            const nestedSelections = buildFieldSelections(field.type, config, currentDepth + 1);
+            if (nestedSelections.length > 0) {
+                selections.push(t.field({
+                    name: field.name,
+                    selectionSet: t.selectionSet({ selections: nestedSelections }),
+                }));
+            }
+        }
+    }
+    return selections;
+}
+/**
+ * Build selections for a return type, handling connections and payloads
+ */
+function buildReturnTypeSelections(returnType, config) {
+    const fields = getResolvedFields(returnType, config.typeRegistry);
+    if (!fields || fields.length === 0) {
+        return [];
+    }
+    // Check if this is a connection type
+    const hasNodes = fields.some((f) => f.name === 'nodes');
+    const hasTotalCount = fields.some((f) => f.name === 'totalCount');
+    if (hasNodes && hasTotalCount) {
+        return buildConnectionSelections(fields, config);
+    }
+    // Check if this is a mutation payload (has clientMutationId)
+    const hasClientMutationId = fields.some((f) => f.name === 'clientMutationId');
+    if (hasClientMutationId) {
+        return buildPayloadSelections(fields, config);
+    }
+    // Regular object - build normal selections
+    return buildFieldSelections(returnType, config);
+}
+/**
+ * Build selections for a connection type
+ */
+function buildConnectionSelections(fields, config) {
+    const selections = [];
+    // Add totalCount
+    const totalCountField = fields.find((f) => f.name === 'totalCount');
+    if (totalCountField) {
+        selections.push(t.field({ name: 'totalCount' }));
+    }
+    // Add nodes with nested selections
+    const nodesField = fields.find((f) => f.name === 'nodes');
+    if (nodesField) {
+        const nodeSelections = buildFieldSelections(nodesField.type, config);
+        if (nodeSelections.length > 0) {
+            selections.push(t.field({
+                name: 'nodes',
+                selectionSet: t.selectionSet({ selections: nodeSelections }),
+            }));
+        }
+    }
+    // Add pageInfo
+    const pageInfoField = fields.find((f) => f.name === 'pageInfo');
+    if (pageInfoField) {
+        selections.push(t.field({
+            name: 'pageInfo',
+            selectionSet: t.selectionSet({
+                selections: [
+                    t.field({ name: 'hasNextPage' }),
+                    t.field({ name: 'hasPreviousPage' }),
+                    t.field({ name: 'startCursor' }),
+                    t.field({ name: 'endCursor' }),
+                ],
+            }),
+        }));
+    }
+    return selections;
+}
+/**
+ * Build selections for a mutation payload type
+ */
+function buildPayloadSelections(fields, config) {
+    const selections = [];
+    for (const field of fields) {
+        // Skip query field
+        if (shouldSkipField(field.name, config.skipQueryField)) {
+            continue;
+        }
+        const fieldKind = getBaseTypeKind(field.type);
+        // Add scalar fields directly
+        if (fieldKind === 'SCALAR' || fieldKind === 'ENUM') {
+            selections.push(t.field({ name: field.name }));
+            continue;
+        }
+        // For object fields (like the returned entity), add with selections
+        if (fieldKind === 'OBJECT') {
+            const nestedSelections = buildFieldSelections(field.type, config);
+            if (nestedSelections.length > 0) {
+                selections.push(t.field({
+                    name: field.name,
+                    selectionSet: t.selectionSet({ selections: nestedSelections }),
+                }));
+            }
+        }
+    }
+    return selections;
+}
+/**
+ * Build a custom query AST from a CleanOperation
+ */
+export function buildCustomQueryAST(config) {
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, } = config;
+    const operationName = `${ucFirst(operation.name)}Query`;
+    // Build variable definitions
+    const variableDefinitions = buildVariableDefinitions(operation.args);
+    // Build arguments that reference the variables
+    const args = buildArgumentNodes(operation.args);
+    // Build return type selections
+    const fieldSelectionConfig = {
+        maxDepth,
+        skipQueryField,
+        typeRegistry,
+    };
+    const returnTypeNeedsSelections = typeNeedsSelections(operation.returnType);
+    let selections = [];
+    if (returnTypeNeedsSelections) {
+        selections = buildReturnTypeSelections(operation.returnType, fieldSelectionConfig);
+    }
+    // Build the query field
+    const queryField = selections.length > 0
+        ? t.field({
+            name: operation.name,
+            args: args.length > 0 ? args : undefined,
+            selectionSet: t.selectionSet({ selections }),
+        })
+        : t.field({
+            name: operation.name,
+            args: args.length > 0 ? args : undefined,
+        });
+    return t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'query',
+                name: operationName,
+                variableDefinitions: variableDefinitions.length > 0 ? variableDefinitions : undefined,
+                selectionSet: t.selectionSet({
+                    selections: [queryField],
+                }),
+            }),
+        ],
+    });
+}
+/**
+ * Build a custom mutation AST from a CleanOperation
+ */
+export function buildCustomMutationAST(config) {
+    const { operation, typeRegistry, maxDepth = 2, skipQueryField = true, } = config;
+    const operationName = `${ucFirst(operation.name)}Mutation`;
+    // Build variable definitions
+    const variableDefinitions = buildVariableDefinitions(operation.args);
+    // Build arguments that reference the variables
+    const args = buildArgumentNodes(operation.args);
+    // Build return type selections
+    const fieldSelectionConfig = {
+        maxDepth,
+        skipQueryField,
+        typeRegistry,
+    };
+    const returnTypeNeedsSelections = typeNeedsSelections(operation.returnType);
+    let selections = [];
+    if (returnTypeNeedsSelections) {
+        selections = buildReturnTypeSelections(operation.returnType, fieldSelectionConfig);
+    }
+    // Build the mutation field
+    const mutationField = selections.length > 0
+        ? t.field({
+            name: operation.name,
+            args: args.length > 0 ? args : undefined,
+            selectionSet: t.selectionSet({ selections }),
+        })
+        : t.field({
+            name: operation.name,
+            args: args.length > 0 ? args : undefined,
+        });
+    return t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'mutation',
+                name: operationName,
+                variableDefinitions: variableDefinitions.length > 0 ? variableDefinitions : undefined,
+                selectionSet: t.selectionSet({
+                    selections: [mutationField],
+                }),
+            }),
+        ],
+    });
+}
+// ============================================================================
+// Print Utilities
+// ============================================================================
+/**
+ * Print a document AST to GraphQL string
+ */
+export function printGraphQL(ast) {
+    return print(ast);
+}
+/**
+ * Build and print a custom query in one call
+ */
+export function buildCustomQueryString(config) {
+    return printGraphQL(buildCustomQueryAST(config));
+}
+/**
+ * Build and print a custom mutation in one call
+ */
+export function buildCustomMutationString(config) {
+    return printGraphQL(buildCustomMutationAST(config));
+}
+// ============================================================================
+// Helper Utilities
+// ============================================================================
+/**
+ * Uppercase first character
+ */
+function ucFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/esm/cli/codegen/ts-ast.d.ts

@@ -0,0 +1,122 @@
+/**
+ * TypeScript AST builders using ts-morph
+ *
+ * Provides utilities for generating TypeScript code via AST manipulation
+ * instead of string concatenation.
+ */
+import { Project, SourceFile, type InterfaceDeclarationStructure, type FunctionDeclarationStructure, type VariableStatementStructure, type ImportDeclarationStructure, type TypeAliasDeclarationStructure } from 'ts-morph';
+/**
+ * Create a new ts-morph project for code generation
+ */
+export declare function createProject(): Project;
+/**
+ * Create a source file in the project
+ */
+export declare function createSourceFile(project: Project, fileName: string): SourceFile;
+/**
+ * Get formatted output from source file
+ */
+export declare function getFormattedOutput(sourceFile: SourceFile): string;
+/**
+ * Get output with minimal formatting (preserves intentional blank lines)
+ * Post-processes to fix indentation and section comment spacing
+ *
+ * ts-morph generates type alias bodies with extra indentation:
+ * - Properties get 6 spaces (we want 2)
+ * - Closing brace gets 4 spaces (we want 0)
+ *
+ * For interfaces it uses 4 spaces which we convert to 2.
+ */
+export declare function getMinimalFormattedOutput(sourceFile: SourceFile): string;
+/**
+ * Create a file header comment
+ */
+export declare function createFileHeader(description: string): string;
+/**
+ * Create JSDoc comment for a declaration
+ */
+export declare function createJsDoc(lines: string[]): string;
+export interface ImportSpec {
+    moduleSpecifier: string;
+    namedImports?: string[];
+    typeOnlyNamedImports?: string[];
+    defaultImport?: string;
+}
+/**
+ * Create import declaration structure
+ */
+export declare function createImport(spec: ImportSpec): ImportDeclarationStructure;
+export interface InterfaceProperty {
+    name: string;
+    type: string;
+    optional?: boolean;
+    docs?: string[];
+}
+/**
+ * Create interface declaration structure
+ */
+export declare function createInterface(name: string, properties: InterfaceProperty[], options?: {
+    docs?: string[];
+    isExported?: boolean;
+    extends?: string[];
+}): InterfaceDeclarationStructure;
+/**
+ * Create filter interface with standard PostGraphile operators
+ */
+export declare function createFilterInterface(name: string, fieldFilters: Array<{
+    fieldName: string;
+    filterType: string;
+}>): InterfaceDeclarationStructure;
+/**
+ * Create type alias declaration structure
+ */
+export declare function createTypeAlias(name: string, type: string, options?: {
+    docs?: string[];
+    isExported?: boolean;
+}): TypeAliasDeclarationStructure;
+/**
+ * Create union type from string literals
+ */
+export declare function createUnionType(values: string[]): string;
+/**
+ * Create const variable statement structure
+ */
+export declare function createConst(name: string, initializer: string, options?: {
+    docs?: string[];
+    isExported?: boolean;
+    type?: string;
+}): VariableStatementStructure;
+/**
+ * Create a template literal string (for GraphQL documents)
+ */
+export declare function createTemplateLiteral(content: string): string;
+export interface FunctionParameter {
+    name: string;
+    type: string;
+    optional?: boolean;
+    initializer?: string;
+}
+/**
+ * Create function declaration structure
+ */
+export declare function createFunction(name: string, parameters: FunctionParameter[], returnType: string, body: string, options?: {
+    docs?: string[];
+    isExported?: boolean;
+    isAsync?: boolean;
+}): FunctionDeclarationStructure;
+/**
+ * Create re-export statement
+ */
+export declare function createReExport(names: string[], moduleSpecifier: string, isTypeOnly?: boolean): string;
+/**
+ * Create barrel export statement
+ */
+export declare function createBarrelExport(moduleSpecifier: string): string;
+/**
+ * Create a section divider comment for generated code
+ */
+export declare function createSectionComment(title: string): string;
+/**
+ * Add a section comment to source file with proper spacing
+ */
+export declare function addSectionComment(sourceFile: SourceFile, title: string): void;