bunsane 0.1.4 → 0.2.0

package/gql/orchestration/GraphQLSchemaOrchestrator.ts

@@ -0,0 +1,241 @@
+import { GraphQLSchema } from "graphql";
+import { createSchema } from "graphql-yoga";
+import { logger } from "../../core/Logger";
+import { ServiceScanner } from "../scanner/ServiceScanner";
+import { SchemaGraph } from "../graph/SchemaGraph";
+import { VisitorComposer } from "../visitors/VisitorComposer";
+import { ArchetypePreprocessorVisitor } from "../visitors/ArchetypePreprocessorVisitor";
+import { DeduplicationVisitor } from "../visitors/DeduplicationVisitor";
+import { SchemaGeneratorVisitor } from "../visitors/SchemaGeneratorVisitor";
+import { ResolverGeneratorVisitor } from "../visitors/ResolverGeneratorVisitor";
+
+/**
+ * Orchestrates the complete GraphQL schema generation process using the graph-based architecture.
+ * Coordinates service scanning, visitor execution, and final schema assembly.
+ *
+ * This class implements the high-level workflow for Phase 6 of the refactor.
+ */
+export class GraphQLSchemaOrchestrator {
+    private serviceScanner: ServiceScanner;
+    private schemaGraph: SchemaGraph;
+    private services: any[] = [];
+
+    constructor() {
+        this.schemaGraph = new SchemaGraph();
+        this.serviceScanner = new ServiceScanner(this.schemaGraph);
+    }
+
+    /**
+     * Generate a complete GraphQL schema from service instances.
+     * This is the main entry point that orchestrates the entire generation process.
+     */
+    generateSchema(services: any[]): GraphQLSchema | null {
+        try {
+            logger.info("Starting GraphQL schema generation with orchestrator");
+
+            // Store services for use in visitors
+            this.services = services;
+
+            // Phase 1: Build graph from services
+            this.buildGraphFromServices(services);
+
+            // Phase 2: Run preprocessing visitors
+            this.runPreprocessingVisitors();
+
+            // Phase 3: Run generation visitors
+            const generationResults = this.runGenerationVisitors();
+
+            // Phase 4: Sort operations alphabetically
+            this.sortOperationsAlphabetically(generationResults);
+
+            // Phase 5: Create final GraphQL schema
+            const schema = this.createGraphQLSchema(generationResults);
+
+            logger.info("GraphQL schema generation completed successfully");
+            return schema;
+
+        } catch (error) {
+            logger.error(`Failed to generate GraphQL schema: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Schema generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+    /**
+     * Phase 1: Build the schema graph from service instances using the ServiceScanner.
+     */
+    private buildGraphFromServices(services: any[]): void {
+
+        // Clear any existing nodes
+        this.schemaGraph.clear();
+
+        // Scan all services - this adds nodes directly to the graph
+        this.serviceScanner.scanServices(services);
+    }
+
+    /**
+     * Phase 2: Run preprocessing visitors to prepare the graph for generation.
+     */
+    private runPreprocessingVisitors(): void {
+
+        const composer = new VisitorComposer();
+
+        // Add preprocessing visitors
+        composer.addVisitor(new ArchetypePreprocessorVisitor());
+        composer.addVisitor(new DeduplicationVisitor());
+
+        // Run visitors on the graph
+        composer.visitGraph(this.schemaGraph);
+
+        // Get results and apply any necessary modifications
+        const results = composer.getResults();
+
+        // Log preprocessing results
+        const archetypeResults = results["visitor-0"];
+        const deduplicationResults = results["visitor-1"];
+
+        
+    }
+
+    /**
+     * Phase 3: Run generation visitors to produce typeDefs and resolvers.
+     */
+    private runGenerationVisitors(): {
+        typeDefs: string;
+        resolvers: Record<string, any>;
+    } {
+
+        const composer = new VisitorComposer();
+
+        // Add generation visitors
+        composer.addVisitor(new SchemaGeneratorVisitor());
+        composer.addVisitor(new ResolverGeneratorVisitor(this.services));
+
+        // Run visitors on the graph
+        composer.visitGraph(this.schemaGraph);
+
+        // Get results
+        const results = composer.getResults();
+        const schemaResults = results["visitor-0"];
+        const resolverResults = results["visitor-1"];
+
+        // Add field resolvers from services (for archetype field resolvers)
+        this.addFieldResolvers(resolverResults);
+
+        // Filter out empty resolver types to avoid schema validation errors
+        const filteredResolvers: Record<string, any> = {};
+        for (const [type, typeResolvers] of Object.entries(resolverResults || {})) {
+            if (typeResolvers && Object.keys(typeResolvers).length > 0) {
+                filteredResolvers[type] = typeResolvers;
+            }
+        }
+
+        
+
+        return {
+            typeDefs: schemaResults?.typeDefs || "",
+            resolvers: filteredResolvers
+        };
+    }
+
+    /**
+     * Add field resolvers from services (registered via archetype.registerFieldResolvers)
+     */
+    private addFieldResolvers(resolvers: Record<string, any>): void {
+        for (const service of this.services) {
+            const fields = service.__graphqlFields || service.constructor.prototype.__graphqlFields;
+            if (!fields) continue;
+
+            for (const fieldMeta of fields) {
+                const { type, field, propertyKey } = fieldMeta;
+                
+                // Ensure the type exists in resolvers
+                if (!resolvers[type]) {
+                    resolvers[type] = {};
+                }
+
+                // Add field resolver
+                resolvers[type][field] = async (parent: any, args: any, context: any, info: any) => {
+                    try {
+                        return await service[propertyKey](parent, args, context, info);
+                    } catch (error) {
+                        logger.error(`Error in field resolver ${type}.${field}: ${error instanceof Error ? error.message : String(error)}`);
+                        throw error;
+                    }
+                };
+            }
+        }
+    }
+
+    /**
+     * Phase 4: Sort operations alphabetically within each operation type.
+     */
+    private sortOperationsAlphabetically(generationResults: {
+        typeDefs: string;
+        resolvers: Record<string, any>;
+    }): void {
+
+        // Sort resolvers alphabetically within each type
+        const operationTypes = ["Query", "Mutation", "Subscription"] as const;
+
+        for (const operationType of operationTypes) {
+            if (generationResults.resolvers[operationType]) {
+                const sortedResolvers: Record<string, any> = {};
+
+                // Sort operation names alphabetically
+                const sortedKeys = Object.keys(generationResults.resolvers[operationType]).sort();
+
+                for (const key of sortedKeys) {
+                    sortedResolvers[key] = generationResults.resolvers[operationType][key];
+                }
+
+                generationResults.resolvers[operationType] = sortedResolvers;
+            }
+        }
+
+    }
+
+    /**
+     * Phase 5: Create the final GraphQL schema using the generated typeDefs and resolvers.
+     */
+    private createGraphQLSchema(generationResults: {
+        typeDefs: string;
+        resolvers: Record<string, any>;
+    }): GraphQLSchema | null {
+        // Check if there are any operations to create a schema for
+        const hasOperations = Object.values(generationResults.resolvers).some(
+            (typeResolvers: any) => Object.keys(typeResolvers).length > 0
+        );
+
+        if (!hasOperations && generationResults.typeDefs.trim() === "") {
+            logger.warn("No operations or type definitions found, returning null schema");
+            return null;
+        }
+
+        try {
+            const schema = createSchema({
+                typeDefs: generationResults.typeDefs,
+                resolvers: generationResults.resolvers
+            });
+
+            return schema;
+
+        } catch (error) {
+            logger.error({error},"Failed to create GraphQL schema");
+            throw new Error(`Schema creation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+    /**
+     * Get the current schema graph (for debugging/testing purposes).
+     */
+    getSchemaGraph(): SchemaGraph {
+        return this.schemaGraph;
+    }
+
+    /**
+     * Clear the orchestrator state for reuse.
+     */
+    clear(): void {
+        this.schemaGraph.clear();
+    }
+}

package/gql/orchestration/index.ts

@@ -0,0 +1 @@
+export { GraphQLSchemaOrchestrator } from "./GraphQLSchemaOrchestrator";

package/gql/scanner/ServiceScanner.ts

@@ -0,0 +1,347 @@
+import type BaseService from "../../service/Service";
+import type { GraphQLObjectTypeMeta, GraphQLOperationMeta, GraphQLSubscriptionMeta } from "../Generator";
+import { SchemaGraph } from "../graph/SchemaGraph";
+import { ScalarNode, TypeNode, OperationNode, FieldNode, InputNode } from "../graph/GraphNode";
+import { OperationType, GraphQLTypeKind } from "../graph/GraphNode";
+import { isSchemaInput } from "../schema";
+
+/**
+ * ServiceScanner extracts GraphQL metadata from services and converts it into graph nodes.
+ * This class is responsible for scanning service instances and their prototypes to collect
+ * all GraphQL-related metadata and create corresponding nodes in the schema graph.
+ */
+export class ServiceScanner {
+    private graph: SchemaGraph;
+    private allScalarTypes: Set<string> = new Set(['Upload']); // Include default scalars
+
+    constructor(graph: SchemaGraph) {
+        this.graph = graph;
+    }
+
+    /**
+     * Scans all provided services and extracts their GraphQL metadata into graph nodes.
+     * @param services Array of service instances to scan
+     */
+    public scanServices(services: BaseService[]): void {
+        // First pass: collect all scalar types
+        for (const service of services) {
+            const scalarTypes = this.getServiceMetadata(service, '__graphqlScalarTypes') as string[];
+            if (scalarTypes) {
+                for (const scalarName of scalarTypes) {
+                    this.allScalarTypes.add(scalarName);
+                }
+            }
+        }
+        
+        // Second pass: scan services with scalar types available
+        for (const service of services) {
+            this.scanService(service);
+        }
+    }
+
+    /**
+     * Scans a single service instance for GraphQL metadata.
+     * @param service The service instance to scan
+     */
+    private scanService(service: BaseService): void {
+        // Extract scalar types
+        this.extractScalarTypes(service);
+
+        // Extract object types
+        this.extractObjectTypes(service);
+
+        // Extract operations (queries/mutations)
+        this.extractOperations(service);
+
+        // Extract subscriptions
+        this.extractSubscriptions(service);
+
+        // Extract fields
+        this.extractFields(service);
+    }
+
+    /**
+     * Extracts scalar type definitions from a service.
+     * @param service The service to extract scalar types from
+     */
+    public extractScalarTypes(service: BaseService): void {
+        const scalarTypes = this.getServiceMetadata(service, '__graphqlScalarTypes') as string[];
+        if (!scalarTypes) return;
+
+        for (const scalarName of scalarTypes) {
+            const scalarNode = new ScalarNode(scalarName, scalarName, {
+                serviceName: service.constructor.name,
+                description: `Scalar type defined in ${service.constructor.name}`
+            });
+            this.graph.addNode(scalarNode);
+        }
+    }
+
+    /**
+     * Extracts object type definitions from a service.
+     * @param service The service to extract object types from
+     */
+    public extractObjectTypes(service: BaseService): void {
+        const objectTypes = this.getServiceMetadata(service, '__graphqlObjectType') as GraphQLObjectTypeMeta[];
+        if (!objectTypes) return;
+
+        for (const meta of objectTypes) {
+            const typeNode = new TypeNode(meta.name, meta.name, GraphQLTypeKind.OBJECT, `type ${meta.name} {\n${Object.entries(meta.fields).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}`, {
+                serviceName: service.constructor.name,
+                fields: meta.fields,
+                description: `Object type defined in ${service.constructor.name}`
+            });
+            this.graph.addNode(typeNode);
+        }
+    }
+
+    /**
+     * Extracts GraphQL operations (queries and mutations) from a service.
+     * @param service The service to extract operations from
+     */
+    public extractOperations(service: BaseService): void {
+        const operations = this.getServiceMetadata(service, '__graphqlOperations') as GraphQLOperationMeta[];
+        if (!operations) return;
+
+        for (const op of operations) {
+            // Create input node if input is a plain object (not Zod schema, not Schema DSL)
+            let inputNodeId: string | undefined;
+            if (op.input && typeof op.input === 'object' && !Array.isArray(op.input) && !('_def' in op.input) && !isSchemaInput(op.input)) {
+                const inputTypeName = this.extractTypeNameFromInput(op.input, op.name!);
+                
+                // Only create node if it doesn't already exist
+                if (inputTypeName && !this.graph.getNode(inputTypeName)) {
+                    const inputFields = Object.entries(op.input as Record<string, any>)
+                        .map(([key, type]) => `  ${key}: ${type}`)
+                        .join('\n');
+                    const inputTypeDef = `input ${inputTypeName} {\n${inputFields}\n}`;
+                    const inputNode = new InputNode(
+                        inputTypeName,
+                        inputTypeName,
+                        inputTypeDef,
+                        false,
+                        {
+                            serviceName: service.constructor.name,
+                            operationName: op.name,
+                            description: `Input type for ${op.name} operation`
+                        }
+                    );
+                    this.graph.addNode(inputNode);
+                }
+                inputNodeId = inputTypeName || undefined;
+            }
+
+            const operationType = op.type.toLowerCase() === 'query' ? OperationType.QUERY : OperationType.MUTATION;
+            const operationNode = new OperationNode(
+                op.name!,
+                op.name!,
+                operationType,
+                `${op.name}: String`, // Placeholder field definition
+                inputNodeId,
+                undefined, // outputNodeId
+                {
+                    serviceName: service.constructor.name,
+                    propertyKey: op.propertyKey,
+                    input: op.input,
+                    output: op.output,
+                    scalarTypes: this.allScalarTypes,
+                    description: `${op.type} operation defined in ${service.constructor.name}`
+                }
+            );
+            this.graph.addNode(operationNode);
+
+            // Add dependencies: operation depends on input and output types
+            this.addOperationDependencies(operationNode, op);
+        }
+    }
+
+    /**
+     * Extracts GraphQL subscriptions from a service.
+     * @param service The service to extract subscriptions from
+     */
+    public extractSubscriptions(service: BaseService): void {
+        const subscriptions = this.getServiceMetadata(service, '__graphqlSubscriptions') as GraphQLSubscriptionMeta[];
+        if (!subscriptions) return;
+
+        for (const sub of subscriptions) {
+            const subscriptionNode = new OperationNode(
+                sub.name!,
+                sub.name!,
+                OperationType.SUBSCRIPTION,
+                `${sub.name}: String`, // Placeholder field definition
+                undefined, // inputNodeId
+                undefined, // outputNodeId
+                {
+                    serviceName: service.constructor.name,
+                    propertyKey: sub.propertyKey,
+                    input: sub.input,
+                    output: sub.output,
+                    scalarTypes: this.allScalarTypes,
+                    description: `Subscription defined in ${service.constructor.name}`
+                }
+            );
+            this.graph.addNode(subscriptionNode);
+
+            // Add dependencies: subscription depends on input and output types
+            this.addSubscriptionDependencies(subscriptionNode, sub);
+        }
+    }
+
+    /**
+     * Extracts GraphQL field definitions from a service.
+     * @param service The service to extract fields from
+     */
+    public extractFields(service: BaseService): void {
+        const fields = this.getServiceMetadata(service, '__graphqlFields') as any[];
+        if (!fields) return;
+
+        for (const field of fields) {
+            // Create a unique ID for the field node to avoid conflicts across services
+            const fieldId = `${service.constructor.name}-${field.field}`;
+            
+            // Skip if field node already exists (duplicate field definition)
+            if (this.graph.getNode(fieldId)) {
+                continue;
+            }
+            
+            const fieldNode = new FieldNode(
+                fieldId,
+                'unknown', // typeName - we don't know the parent type yet
+                field.field,
+                field.type,
+                {
+                    serviceName: service.constructor.name,
+                    propertyKey: field.propertyKey,
+                    description: `Field defined in ${service.constructor.name}`
+                }
+            );
+            this.graph.addNode(fieldNode);
+        }
+    }
+
+    /**
+     * Adds dependency edges for an operation node based on its input and output types.
+     * @param operationNode The operation node to add dependencies for
+     * @param operationMeta The operation metadata
+     */
+    private addOperationDependencies(operationNode: OperationNode, operationMeta: GraphQLOperationMeta): void {
+        // Add dependency on input type if it exists
+        if (operationMeta.input) {
+            const inputTypeName = this.extractTypeNameFromInput(operationMeta.input, operationMeta.name!);
+            if (inputTypeName && this.graph.getNode(inputTypeName)) {
+                this.graph.addDependency(operationNode.id, inputTypeName);
+            }
+        }
+
+        // Add dependency on output type if it exists in the graph
+        // Note: Archetype types may not exist yet - they're added by ArchetypePreprocessorVisitor
+        const outputTypeName = this.extractTypeNameFromOutput(operationMeta.output);
+        if (outputTypeName && this.graph.getNode(outputTypeName)) {
+            this.graph.addDependency(operationNode.id, outputTypeName);
+        }
+    }
+
+    /**
+     * Adds dependency edges for a subscription node based on its input and output types.
+     * @param subscriptionNode The subscription node to add dependencies for
+     * @param subscriptionMeta The subscription metadata
+     */
+    private addSubscriptionDependencies(subscriptionNode: OperationNode, subscriptionMeta: GraphQLSubscriptionMeta): void {
+        // Add dependency on input type if it exists
+        if (subscriptionMeta.input) {
+            const inputTypeName = this.extractTypeNameFromInput(subscriptionMeta.input, subscriptionMeta.name!);
+            if (inputTypeName && this.graph.getNode(inputTypeName)) {
+                this.graph.addDependency(subscriptionNode.id, inputTypeName);
+            }
+        }
+
+        // Add dependency on output type if it exists in the graph
+        // Note: Archetype types may not exist yet - they're added by ArchetypePreprocessorVisitor
+        const outputTypeName = this.extractTypeNameFromOutput(subscriptionMeta.output);
+        if (outputTypeName && this.graph.getNode(outputTypeName)) {
+            this.graph.addDependency(subscriptionNode.id, outputTypeName);
+        }
+    }
+
+    /**
+     * Extracts a type name from operation input metadata.
+     * @param input The input metadata
+     * @param operationName The operation name for naming derived types
+     * @returns The type name or null if not found
+     */
+    private extractTypeNameFromInput(input: any, operationName: string): string | null {
+        if (typeof input === 'string') {
+            return input;
+        }
+
+        // For Zod schemas, generate input type name
+        if (input && typeof input === 'object' && '_def' in input) {
+            return `${operationName}Input`;
+        }
+
+        // For object inputs, use operation name
+        if (typeof input === 'object') {
+            return `${operationName}Input`;
+        }
+
+        return null;
+    }
+
+    /**
+     * Extracts a type name from operation output metadata.
+     * @param output The output metadata
+     * @returns The type name or null if not found
+     */
+    private extractTypeNameFromOutput(output: any): string | null {
+        if (typeof output === 'string') {
+            return output;
+        }
+
+        // Handle arrays of archetypes first
+        if (Array.isArray(output) && output.length > 0) {
+            const firstItem = output[0];
+            if (firstItem && typeof firstItem === 'object' && firstItem.constructor) {
+                const constructorName = firstItem.constructor.name;
+                if (constructorName && constructorName !== 'Object') {
+                    return constructorName;
+                }
+            }
+        }
+
+        // Handle BaseArcheType instances
+        if (output && typeof output === 'object' && output.constructor) {
+            const constructorName = output.constructor.name;
+            if (constructorName && constructorName !== 'Object') {
+                return constructorName;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Retrieves metadata from a service instance or its prototype chain.
+     * @param service The service instance
+     * @param key The metadata key to retrieve
+     * @returns The metadata value or null if not found
+     */
+    private getServiceMetadata(service: BaseService, key: string): any {
+        // Check instance first
+        if (service[key as keyof BaseService]) {
+            return service[key as keyof BaseService];
+        }
+
+        // Check prototype
+        const prototype = service.constructor.prototype;
+        if (prototype && prototype[key]) {
+            return prototype[key];
+        }
+
+        // Check constructor
+        if (service.constructor[key as keyof typeof service.constructor]) {
+            return service.constructor[key as keyof typeof service.constructor];
+        }
+
+        return null;
+    }
+}