bunsane 0.1.4 → 0.2.0

package/gql/graph/SchemaGraph.ts

@@ -0,0 +1,278 @@
+import { GraphNode, NodeType } from './GraphNode';
+
+/**
+ * Directed graph data structure for managing GraphQL schema components and their dependencies.
+ * Provides topological sorting and dependency resolution for schema generation.
+ */
+export class SchemaGraph {
+    private nodes: Map<string, GraphNode> = new Map();
+    private adjacencyList: Map<string, Set<string>> = new Map(); // nodeId -> set of dependent nodeIds
+
+    /**
+     * Add a node to the graph
+     */
+    addNode(node: GraphNode): void {
+        if (this.nodes.has(node.id)) {
+            throw new Error(`Node with id '${node.id}' already exists in graph`);
+        }
+
+        this.nodes.set(node.id, node);
+        this.adjacencyList.set(node.id, new Set());
+
+        // Add reverse edges for dependencies (what depends on this node)
+        for (const depId of node.dependencies) {
+            if (!this.adjacencyList.has(depId)) {
+                this.adjacencyList.set(depId, new Set());
+            }
+            this.adjacencyList.get(depId)!.add(node.id);
+        }
+    }
+
+    /**
+     * Get a node by its ID
+     */
+    getNode(nodeId: string): GraphNode | undefined {
+        return this.nodes.get(nodeId);
+    }
+
+    /**
+     * Check if a node exists in the graph
+     */
+    hasNode(nodeId: string): boolean {
+        return this.nodes.has(nodeId);
+    }
+
+    /**
+     * Remove a node from the graph
+     */
+    removeNode(nodeId: string): boolean {
+        const node = this.nodes.get(nodeId);
+        if (!node) {
+            return false;
+        }
+
+        // Remove from nodes map
+        this.nodes.delete(nodeId);
+
+        // Remove from adjacency list
+        this.adjacencyList.delete(nodeId);
+
+        // Remove this node from other nodes' dependency lists
+        for (const [otherNodeId, dependents] of this.adjacencyList) {
+            dependents.delete(nodeId);
+        }
+
+        return true;
+    }
+
+    /**
+     * Get all nodes in the graph
+     */
+    getAllNodes(): GraphNode[] {
+        return Array.from(this.nodes.values());
+    }
+
+    /**
+     * Get nodes of a specific type
+     */
+    getNodesByType(nodeType: NodeType): GraphNode[] {
+        return this.getAllNodes().filter(node => node.nodeType === nodeType);
+    }
+
+    /**
+     * Get direct dependencies of a node (nodes this node depends on)
+     */
+    getDependencies(nodeId: string): GraphNode[] {
+        const node = this.getNode(nodeId);
+        if (!node) {
+            return [];
+        }
+
+        return node.dependencies
+            .map(depId => this.getNode(depId))
+            .filter((dep): dep is GraphNode => dep !== undefined);
+    }
+
+    /**
+     * Get nodes that depend on the given node (reverse dependencies)
+     */
+    getDependents(nodeId: string): GraphNode[] {
+        const dependents = this.adjacencyList.get(nodeId);
+        if (!dependents) {
+            return [];
+        }
+
+        return Array.from(dependents)
+            .map(depId => this.getNode(depId))
+            .filter((dep): dep is GraphNode => dep !== undefined);
+    }
+
+    /**
+     * Add a dependency edge between two nodes
+     */
+    addDependency(fromNodeId: string, toNodeId: string): void {
+        const fromNode = this.getNode(fromNodeId);
+        const toNode = this.getNode(toNodeId);
+
+        if (!fromNode) {
+            throw new Error(`Source node '${fromNodeId}' does not exist`);
+        }
+        if (!toNode) {
+            throw new Error(`Target node '${toNodeId}' does not exist`);
+        }
+
+        fromNode.addDependency(toNodeId);
+
+        // Update adjacency list for reverse lookup
+        if (!this.adjacencyList.has(toNodeId)) {
+            this.adjacencyList.set(toNodeId, new Set());
+        }
+        this.adjacencyList.get(toNodeId)!.add(fromNodeId);
+    }
+
+    /**
+     * Remove a dependency edge between two nodes
+     */
+    removeDependency(fromNodeId: string, toNodeId: string): void {
+        const fromNode = this.getNode(fromNodeId);
+        if (!fromNode) {
+            return;
+        }
+
+        fromNode.removeDependency(toNodeId);
+
+        // Update adjacency list
+        const dependents = this.adjacencyList.get(toNodeId);
+        if (dependents) {
+            dependents.delete(fromNodeId);
+        }
+    }
+
+    /**
+     * Perform topological sort of the graph
+     * Returns nodes in dependency order (dependencies first)
+     */
+    topologicalSort(): GraphNode[] {
+        const visited = new Set<string>();
+        const visiting = new Set<string>(); // For cycle detection
+        const result: GraphNode[] = [];
+
+        const visit = (nodeId: string): void => {
+            if (visited.has(nodeId)) {
+                return;
+            }
+
+            if (visiting.has(nodeId)) {
+                throw new Error(`Cycle detected in graph involving node '${nodeId}'`);
+            }
+
+            visiting.add(nodeId);
+
+            // Visit all dependencies first
+            const node = this.getNode(nodeId);
+            if (node) {
+                for (const depId of node.dependencies) {
+                    if (this.hasNode(depId)) {
+                        visit(depId);
+                    }
+                }
+            }
+
+            visiting.delete(nodeId);
+            visited.add(nodeId);
+
+            if (node) {
+                result.push(node);
+            }
+        };
+
+        // Visit all nodes
+        for (const nodeId of this.nodes.keys()) {
+            if (!visited.has(nodeId)) {
+                visit(nodeId);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Get nodes in dependency order (topologically sorted)
+     */
+    getNodesInDependencyOrder(): GraphNode[] {
+        return this.topologicalSort();
+    }
+
+    /**
+     * Clear all nodes and edges from the graph
+     */
+    clear(): void {
+        this.nodes.clear();
+        this.adjacencyList.clear();
+    }
+
+    /**
+     * Get graph statistics
+     */
+    getStats(): {
+        nodeCount: number;
+        edgeCount: number;
+        nodesByType: Record<NodeType, number>;
+    } {
+        const nodesByType = Object.values(NodeType).reduce((acc, type) => {
+            acc[type] = 0;
+            return acc;
+        }, {} as Record<NodeType, number>);
+
+        for (const node of this.nodes.values()) {
+            nodesByType[node.nodeType]++;
+        }
+
+        let edgeCount = 0;
+        for (const node of this.nodes.values()) {
+            edgeCount += node.dependencies.length;
+        }
+
+        return {
+            nodeCount: this.nodes.size,
+            edgeCount,
+            nodesByType
+        };
+    }
+
+    /**
+     * Validate the graph structure
+     * Checks for missing dependencies and other consistency issues
+     */
+    validate(): { isValid: boolean; errors: string[] } {
+        const errors: string[] = [];
+
+        for (const [nodeId, node] of this.nodes) {
+            // Check that all dependencies exist
+            for (const depId of node.dependencies) {
+                if (!this.hasNode(depId)) {
+                    errors.push(`Node '${nodeId}' depends on non-existent node '${depId}'`);
+                }
+            }
+        }
+
+        // Check for cycles (this will throw an error if cycles exist)
+        try {
+            this.topologicalSort();
+        } catch (error) {
+            errors.push(`Graph contains cycles: ${(error as Error).message}`);
+        }
+
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+
+    /**
+     * Get the number of nodes in the graph
+     */
+    size(): number {
+        return this.nodes.size;
+    }
+}

package/gql/helpers.ts

@@ -1,4 +1,5 @@
 import { GraphQLFieldTypes } from './types';
+import { z } from 'zod';
 
 export type GraphQLType =
   | GraphQLFieldTypes  // e.g., "ID!", "String"
@@ -12,7 +13,7 @@ export function isValidGraphQLType(type: string): type is GraphQLType {
   return enumValues.includes(type as GraphQLFieldTypes) ||
          /^(\w+|\[\w+\])(!)?$/.test(type);  // Simple regex for custom types/lists
 }
-
+/** @deprecated */
 export type TypeFromGraphQL<T extends GraphQLType> =
   T extends GraphQLFieldTypes.ID_REQUIRED | GraphQLFieldTypes.ID ? string :
   T extends GraphQLFieldTypes.STRING_REQUIRED ? string :
@@ -26,6 +27,11 @@ export type TypeFromGraphQL<T extends GraphQLType> =
   T extends `[${string}]` | `[${string}]!` ? any[] :  
   any;  
 
+/**
+ * 
+ * @deprecated
+ * @reason Use `ArcheType.getInputSchema()` instead.
+ */
 export type ResolverInput<T extends Record<string, GraphQLType>> = {
   [K in keyof T]: TypeFromGraphQL<T[K]>;
 };
@@ -64,4 +70,4 @@ function isPathSelected(selectionSet: any, path: string[]): boolean {
         }
     }
     return false;
-}
+}

package/gql/index.ts

@@ -1,9 +1,12 @@
 import {createSchema, createYoga, type Plugin} from 'graphql-yoga';
+import { useValidationRule } from '@envelop/core';
 import { GraphQLSchema, GraphQLError } from 'graphql';
-import { GraphQLObjectType, GraphQLField, GraphQLOperation, GraphQLScalarType } from './Generator';
+import { depthLimitRule } from './depthLimit';
+import { GraphQLObjectType, GraphQLField, GraphQLOperation, GraphQLScalarType, GraphQLSubscription } from './Generator';
 import {GraphQLFieldTypes} from "./types"
-import {logger as MainLogger} from "core/Logger"
+import {logger as MainLogger} from "../core/Logger"
 import { isFieldRequested } from './helpers';
+import * as z from "zod";
 
 const logger = MainLogger.child({scope: "GQL"});
 
@@ -19,11 +22,16 @@ export {
     GraphQLObjectType,
     GraphQLField,
     GraphQLOperation,
+    GraphQLSubscription,
     GraphQLFieldTypes,
     isValidGraphQLType,
     GraphQLScalarType,
     isFieldRequested
 }
+export { GraphQLSchemaOrchestrator } from "./orchestration";
+export { generateGraphQLSchemaV2 } from "./GeneratorV2";
+export { Middleware, composeOperationMiddleware } from "./middleware";
+export type { OperationMiddleware } from "./middleware";
 export type {
     GraphQLType,
     TypeFromGraphQL,
@@ -90,6 +98,21 @@ const maskError = (error: any, message: string): GraphQLError => {
             }
         });
     }
+
+    // Handle GraphQL validation errors for missing required fields
+    if (error.message.includes('was not provided')) {
+        const match = error.message.match(/Field "([^"]+)" of required type "([^"]+)" was not provided/);
+        if (match) {
+            const fieldName = match[1];
+            return new GraphQLError(`Missing required field: ${fieldName}`, {
+                extensions: {
+                    code: 'VALIDATION_ERROR',
+                    field: fieldName,
+                    originalMessage: error.message
+                }
+            });
+        }
+    }
     
     if (process.env.NODE_ENV === 'production') {
         logger.error("GraphQL Error:", error);
@@ -104,14 +127,41 @@ const maskError = (error: any, message: string): GraphQLError => {
     return error instanceof GraphQLError ? error : new GraphQLError(message, { originalError: error });
 };
 
-export function createYogaInstance(schema?: GraphQLSchema, plugins: Plugin[] = [], contextFactory?: (context: any) => any) {
+export interface YogaInstanceOptions {
+    cors?: {
+        origin?: string | string[] | ((origin: string) => boolean);
+        credentials?: boolean;
+        allowedHeaders?: string[];
+        methods?: string[];
+    };
+    maxDepth?: number;
+}
+
+export function createYogaInstance(
+    schema?: GraphQLSchema,
+    plugins: Plugin[] = [],
+    contextFactory?: (context: any) => any,
+    options?: YogaInstanceOptions
+) {
+    // Prepend depth limit plugin if configured
+    const allPlugins: Plugin[] = [];
+    if (options?.maxDepth) {
+        allPlugins.push(useValidationRule(depthLimitRule(options.maxDepth)) as Plugin);
+    }
+    allPlugins.push(...plugins);
+
     const yogaConfig: any = {
-        plugins,
+        plugins: allPlugins,
         maskedErrors: {
             maskError,
         },
     };
 
+    // Add CORS if provided
+    if (options?.cors) {
+        yogaConfig.cors = options.cors;
+    }
+
     // Add context factory if provided
     if (contextFactory) {
         yogaConfig.context = contextFactory;
@@ -129,4 +179,6 @@ export function createYogaInstance(schema?: GraphQLSchema, plugins: Plugin[] = [
     }
 }
 
+export const Upload = z.union([z.literal("Upload"), z.any()]);
+
 export const yoga = createYogaInstance();

package/gql/middleware.ts

@@ -0,0 +1,79 @@
+import { GraphQLError } from "graphql";
+
+/**
+ * Middleware function for GraphQL operations (onion model).
+ *
+ * Call `next()` to continue to the next middleware or the resolver.
+ * Throw a `GraphQLError` to short-circuit the chain.
+ * Return the result of `next()` (or transform it).
+ */
+export type OperationMiddleware = (
+    args: any,
+    context: any,
+    info: any,
+    next: () => Promise<any>,
+) => Promise<any>;
+
+/**
+ * Compose an array of OperationMiddleware into a single chain.
+ * The final `handler` is the original service method.
+ */
+export function composeOperationMiddleware(
+    middlewares: OperationMiddleware[],
+    handler: (...args: any[]) => Promise<any>,
+    thisArg: any,
+): (args: any, context: any, info: any) => Promise<any> {
+    return (args: any, context: any, info: any) => {
+        let index = 0;
+        const dispatch = (): Promise<any> => {
+            if (index >= middlewares.length) {
+                return handler.call(thisArg, args, context, info);
+            }
+            const mw = middlewares[index++]!;
+            return mw(args, context, info, dispatch);
+        };
+        return dispatch();
+    };
+}
+
+/**
+ * Decorator that attaches an ordered chain of middleware to a GraphQL operation.
+ *
+ * Middleware execute in array order (left-to-right), wrapping the resolver
+ * in an onion model identical to HTTP middleware.
+ *
+ * @example
+ * ```ts
+ * const Authenticate: OperationMiddleware = async (args, ctx, info, next) => {
+ *     if (!ctx.user) throw new GraphQLError("Unauthenticated", {
+ *         extensions: { code: "UNAUTHENTICATED", http: { status: 401 } }
+ *     });
+ *     return next();
+ * };
+ *
+ * function Authorize(...permissions: string[]): OperationMiddleware {
+ *     return async (args, ctx, info, next) => {
+ *         if (!permissions.every(p => ctx.user.permissions?.includes(p)))
+ *             throw new GraphQLError("Forbidden", {
+ *                 extensions: { code: "FORBIDDEN", http: { status: 403 } }
+ *             });
+ *         return next();
+ *     };
+ * }
+ *
+ * class UserService extends BaseService {
+ *     @Middleware([Authenticate, Authorize("users.read")])
+ *     @GraphQLOperation({ type: "Query", output: "User", input: { id: "ID!" } })
+ *     async getUser(args, context, info) { ... }
+ * }
+ * ```
+ */
+export function Middleware(middlewares: OperationMiddleware[]) {
+    return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+        const original = descriptor.value;
+        descriptor.value = function (this: any, args: any, context: any, info: any) {
+            const chain = composeOperationMiddleware(middlewares, original, this);
+            return chain(args, context, info);
+        };
+    };
+}