bunsane 0.1.4 → 0.2.0

package/gql/visitors/DeduplicationVisitor.ts

@@ -0,0 +1,82 @@
+import { GraphVisitor } from "./GraphVisitor";
+import { TypeNode, OperationNode, FieldNode, InputNode, ScalarNode } from "../graph/GraphNode";
+
+/**
+ * Visitor that tracks and eliminates duplicate type definitions.
+ * Ensures that each type name is defined only once in the schema.
+ */
+export class DeduplicationVisitor extends GraphVisitor {
+    private seenTypeNames: Set<string> = new Set();
+    private duplicateNodes: Set<string> = new Set(); // Node IDs that are duplicates
+
+    visitTypeNode(node: TypeNode): void {
+        if (this.seenTypeNames.has(node.name)) {
+            this.duplicateNodes.add(node.id);
+        } else {
+            this.seenTypeNames.add(node.name);
+        }
+    }
+
+    visitOperationNode(node: OperationNode): void {
+        // Operations don't define new types, so no deduplication needed
+    }
+
+    visitFieldNode(node: FieldNode): void {
+        // Fields don't define new types
+    }
+
+    visitInputNode(node: InputNode): void {
+        if (this.seenTypeNames.has(node.name)) {
+            this.duplicateNodes.add(node.id);
+        } else {
+            this.seenTypeNames.add(node.name);
+        }
+    }
+
+    visitScalarNode(node: ScalarNode): void {
+        if (this.seenTypeNames.has(node.name)) {
+            this.duplicateNodes.add(node.id);
+        } else {
+            this.seenTypeNames.add(node.name);
+        }
+    }
+
+    getResults(): {
+        duplicateNodeIds: Set<string>;
+        uniqueTypeNames: Set<string>;
+    } {
+        return {
+            duplicateNodeIds: new Set(this.duplicateNodes),
+            uniqueTypeNames: new Set(this.seenTypeNames)
+        };
+    }
+
+    /**
+     * Check if a node ID is a duplicate
+     */
+    isDuplicate(nodeId: string): boolean {
+        return this.duplicateNodes.has(nodeId);
+    }
+
+    /**
+     * Get all duplicate node IDs
+     */
+    getDuplicateNodeIds(): string[] {
+        return Array.from(this.duplicateNodes);
+    }
+
+    /**
+     * Get all unique type names seen
+     */
+    getUniqueTypeNames(): string[] {
+        return Array.from(this.seenTypeNames);
+    }
+
+    /**
+     * Clear all tracking data
+     */
+    clear(): void {
+        this.seenTypeNames.clear();
+        this.duplicateNodes.clear();
+    }
+}

package/gql/visitors/GraphVisitor.ts

@@ -0,0 +1,78 @@
+import { GraphNode, TypeNode, OperationNode, FieldNode, InputNode, ScalarNode } from "../graph/GraphNode";
+
+/**
+ * Base visitor class for traversing GraphQL schema graphs.
+ * Implements the Visitor pattern to separate algorithms from data structures.
+ *
+ * Each concrete visitor implements specific behavior for different node types.
+ */
+export abstract class GraphVisitor {
+    /**
+     * Visit a generic graph node
+     */
+    visit(node: GraphNode): void {
+        switch (node.nodeType) {
+            case 'TYPE':
+                this.visitTypeNode(node as TypeNode);
+                break;
+            case 'OPERATION':
+                this.visitOperationNode(node as OperationNode);
+                break;
+            case 'FIELD':
+                this.visitFieldNode(node as FieldNode);
+                break;
+            case 'INPUT':
+                this.visitInputNode(node as InputNode);
+                break;
+            case 'SCALAR':
+                this.visitScalarNode(node as ScalarNode);
+                break;
+            default:
+                throw new Error(`Unknown node type: ${(node as any).nodeType}`);
+        }
+    }
+
+    /**
+     * Visit a TypeNode
+     */
+    abstract visitTypeNode(node: TypeNode): void;
+
+    /**
+     * Visit an OperationNode
+     */
+    abstract visitOperationNode(node: OperationNode): void;
+
+    /**
+     * Visit a FieldNode
+     */
+    abstract visitFieldNode(node: FieldNode): void;
+
+    /**
+     * Visit an InputNode
+     */
+    abstract visitInputNode(node: InputNode): void;
+
+    /**
+     * Visit a ScalarNode
+     */
+    abstract visitScalarNode(node: ScalarNode): void;
+
+    /**
+     * Called before visiting a graph to perform setup
+     */
+    beforeVisit(): void {
+        // Default: no-op
+    }
+
+    /**
+     * Called after visiting a graph to perform cleanup or finalization
+     */
+    afterVisit(): void {
+        // Default: no-op
+    }
+
+    /**
+     * Get the results of the visitation
+     */
+    abstract getResults(): any;
+}

package/gql/visitors/ResolverGeneratorVisitor.ts

@@ -0,0 +1,122 @@
+import { GraphVisitor } from "./GraphVisitor";
+import { TypeNode, OperationNode, FieldNode, InputNode, ScalarNode } from "../graph/GraphNode";
+import { ResolverBuilder } from "../builders/ResolverBuilder";
+import { logger } from "../../core/Logger";
+
+/**
+ * Visitor that generates the GraphQL resolvers object.
+ * Uses the ResolverBuilder from Phase 4 to construct resolver functions.
+ */
+export class ResolverGeneratorVisitor extends GraphVisitor {
+    private resolverBuilder: ResolverBuilder;
+    private services: any[];
+
+    constructor(services: any[]) {
+        super();
+        this.services = services;
+        this.resolverBuilder = new ResolverBuilder();
+        
+        // Add Date scalar resolver
+        this.resolverBuilder.addScalarResolver('Date', {
+            serialize: (value: any) => {
+                if (value instanceof Date) {
+                    return value.toISOString();
+                }
+                return value;
+            },
+            parseValue: (value: any) => {
+                if (typeof value === 'string') {
+                    return new Date(value);
+                }
+                return value;
+            },
+            parseLiteral: (ast: any) => {
+                if (ast.kind === 'StringValue') {
+                    return new Date(ast.value);
+                }
+                return null;
+            }
+        });
+    }
+
+    visitTypeNode(node: TypeNode): void {
+        // TypeNodes don't directly create resolvers
+        // Resolvers for object types are typically handled by archetypes
+    }
+
+    visitOperationNode(node: OperationNode): void {
+        // Find the service instance that matches the service name
+        const service = this.services.find(s => s.constructor.name === node.metadata.serviceName);
+        if (!service) {
+            logger.warn(`Service ${node.metadata.serviceName} not found for operation ${node.name}`);
+            return;
+        }
+
+        const type = node.operationType.charAt(0).toUpperCase() + node.operationType.slice(1).toLowerCase() as "Query" | "Mutation" | "Subscription";
+
+        // Extract Zod schema from input if it's a Zod type (check for '_def' property)
+        const input = node.metadata.input;
+        const zodSchema = (input && typeof input === 'object' && '_def' in input) ? input as any : null;
+
+        // Create resolver definitions for operations
+        const resolverDef = {
+            name: node.name,
+            type: type,
+            service: service, // Service instance
+            propertyKey: node.metadata.propertyKey, // Method name from metadata
+            zodSchema: zodSchema, // Zod schema if available
+            hasInput: !!node.inputNodeId || !!zodSchema || !!input // Whether this operation has input (InputNode, Zod schema, or raw GraphQL input definition)
+        };
+
+        this.resolverBuilder.addResolver(resolverDef);
+    }
+
+    visitFieldNode(node: FieldNode): void {
+        // FieldNodes represent individual field resolvers
+        // These would typically be added to the resolvers for their parent type
+        // For now, we'll skip these as they're handled by archetypes
+    }
+
+    visitInputNode(node: InputNode): void {
+        // InputNodes don't create resolvers
+    }
+
+    visitScalarNode(node: ScalarNode): void {
+        // ScalarNodes don't create resolvers
+    }
+
+    getResults(): Record<string, Record<string, Function>> {
+        const resolvers = this.resolverBuilder.getResolvers();
+
+        // Ensure there's always at least one Query resolver for GraphQL schema validity
+        if (!resolvers.Query) {
+            resolvers.Query = {};
+        }
+        if (Object.keys(resolvers.Query).length === 0) {
+            resolvers.Query._empty = () => null;
+        }
+
+        return resolvers;
+    }
+
+    /**
+     * Get resolvers for a specific operation type
+     */
+    getResolversForType(type: "Query" | "Mutation" | "Subscription"): Record<string, Function> {
+        return this.resolverBuilder.getResolversForType(type);
+    }
+
+    /**
+     * Get statistics about generated resolvers
+     */
+    getStats(): { queries: number; mutations: number; subscriptions: number } {
+        return this.resolverBuilder.getStats();
+    }
+
+    /**
+     * Clear all resolver data
+     */
+    clear(): void {
+        this.resolverBuilder.clear();
+    }
+}