bunsane 0.1.4 → 0.2.0

package/gql/builders/ResolverBuilder.ts

@@ -0,0 +1,234 @@
+import { GraphQLError } from "graphql";
+import { logger } from "../../core/Logger";
+import { type ZodType } from "zod";
+import * as z from "zod";
+
+/** Check if error is a GraphQLError (handles cross-package version mismatches) */
+function isGraphQLError(error: unknown): error is GraphQLError {
+  return error instanceof GraphQLError ||
+    (error !== null && typeof error === 'object' && 'extensions' in error &&
+     'message' in error && typeof (error as any).message === 'string');
+}
+
+export interface ResolverDefinition {
+  name: string;
+  type: "Query" | "Mutation" | "Subscription";
+  service: any;
+  propertyKey: string;
+  zodSchema?: ZodType;
+  hasInput?: boolean;
+}
+
+export class ResolverBuilder {
+  private resolvers: Record<string, Record<string, Function>> = {
+    Query: {},
+    Mutation: {},
+    Subscription: {}
+  };
+
+  /**
+   * Add a resolver definition
+   */
+  addResolver(definition: ResolverDefinition): void {
+    const { name, type, service, propertyKey, zodSchema, hasInput } = definition;
+
+    let resolver: any;
+
+    if (type === "Subscription") {
+      // Subscriptions need special handling with subscribe/resolve pattern
+      resolver = hasInput
+        ? this.createSubscriptionResolverWithInput(service, propertyKey, zodSchema)
+        : this.createSubscriptionResolverWithoutInput(service, propertyKey);
+    } else {
+      // Queries and Mutations use regular resolver pattern
+      resolver = hasInput
+        ? this.createResolverWithInput(service, propertyKey, zodSchema)
+        : this.createResolverWithoutInput(service, propertyKey);
+    }
+
+    // Ensure the resolver category exists (should always exist due to initialization)
+    if (!this.resolvers[type]) {
+      this.resolvers[type] = {};
+    }
+    this.resolvers[type][name] = resolver;
+    logger.trace(`Added ${type} resolver: ${name}`);
+  }
+
+  /**
+   * Create a resolver that expects input arguments
+   */
+  private createResolverWithInput(service: any, propertyKey: string, zodSchema?: ZodType): Function {
+    return async (_: any, args: any, context: any, info: any) => {
+      try {
+        const inputArgs = args.input || args;
+
+        // Automatically validate with Zod schema if provided
+        if (zodSchema) {
+          try {
+            const validated = zodSchema.parse(inputArgs);
+            return await service[propertyKey](validated, context, info);
+          } catch (error) {
+            if (error instanceof z.ZodError) {
+              // Let handleGraphQLError convert Zod errors to user-friendly messages
+              const { handleGraphQLError } = await import("../../core/ErrorHandler");
+              handleGraphQLError(error);
+            }
+            throw error;
+          }
+        } else {
+          return await service[propertyKey](inputArgs, context, info);
+        }
+      } catch (error) {
+        logger.error(`Error in resolver with input:`);
+        logger.error(error);
+        if (isGraphQLError(error)) {
+          throw error;
+        }
+        throw new GraphQLError(`Internal error`, {
+          extensions: {
+            code: "INTERNAL_ERROR",
+            originalError: process.env.NODE_ENV === 'development' ? error : undefined
+          }
+        });
+      }
+    };
+  }
+
+  /**
+   * Create a resolver that doesn't expect input arguments
+   */
+  private createResolverWithoutInput(service: any, propertyKey: string): Function {
+    return async (_: any, args: any, context: any, info: any) => {
+      try {
+        const result = await service[propertyKey]({}, context, info);
+        return result;
+      } catch (error) {
+        logger.error(`Error in resolver without input:`);
+        logger.error(error);
+        if (isGraphQLError(error)) {
+          throw error;
+        }
+        throw new GraphQLError(`Internal error`, {
+          extensions: {
+            code: "INTERNAL_ERROR",
+            originalError: process.env.NODE_ENV === 'development' ? error : undefined
+          }
+        });
+      }
+    };
+  }
+
+  /**
+   * Create a subscription resolver with input (returns { subscribe, resolve })
+   */
+  private createSubscriptionResolverWithInput(service: any, propertyKey: string, zodSchema?: ZodType): any {
+    return {
+      subscribe: async (_: any, args: any, context: any, info: any) => {
+        try {
+          const inputArgs = args.input || args;
+
+          // Automatically validate with Zod schema if provided
+          if (zodSchema) {
+            try {
+              const validated = zodSchema.parse(inputArgs);
+              return await service[propertyKey](validated, context, info);
+            } catch (error) {
+              if (error instanceof z.ZodError) {
+                const { handleGraphQLError } = await import("../../core/ErrorHandler");
+                handleGraphQLError(error);
+              }
+              throw error;
+            }
+          } else {
+            return await service[propertyKey](inputArgs, context, info);
+          }
+        } catch (error) {
+          logger.error(`Error in subscription with input:`);
+          logger.error(error);
+          if (isGraphQLError(error)) {
+            throw error;
+          }
+          throw new GraphQLError(`Internal error in subscription`, {
+            extensions: {
+              code: "INTERNAL_ERROR",
+              originalError: process.env.NODE_ENV === 'development' ? error : undefined
+            }
+          });
+        }
+      },
+      resolve: (payload: any) => payload
+    };
+  }
+
+  /**
+   * Create a subscription resolver without input (returns { subscribe, resolve })
+   */
+  private createSubscriptionResolverWithoutInput(service: any, propertyKey: string): any {
+    return {
+      subscribe: async (_: any, args: any, context: any, info: any) => {
+        try {
+          return await service[propertyKey]({}, context, info);
+        } catch (error) {
+          logger.error(`Error in subscription without input:`);
+          logger.error(error);
+          if (isGraphQLError(error)) {
+            throw error;
+          }
+          throw new GraphQLError(`Internal error in subscription`, {
+            extensions: {
+              code: "INTERNAL_ERROR",
+              originalError: process.env.NODE_ENV === 'development' ? error : undefined
+            }
+          });
+        }
+      },
+      resolve: (payload: any) => payload
+    };
+  }
+
+  /**
+   * Get all built resolvers
+   */
+  getResolvers(): Record<string, Record<string, Function>> {
+    return { ...this.resolvers };
+  }
+
+  /**
+   * Get resolvers for a specific type
+   */
+  getResolversForType(type: "Query" | "Mutation" | "Subscription"): Record<string, Function> {
+    return { ...this.resolvers[type] };
+  }
+
+  /**
+   * Clear all resolvers (for reuse)
+   */
+  clear(): void {
+    this.resolvers = {
+      Query: {},
+      Mutation: {},
+      Subscription: {}
+    };
+  }
+
+  /**
+   * Add a scalar resolver
+   */
+  addScalarResolver(name: string, resolver: any): void {
+    if (!this.resolvers[name]) {
+      this.resolvers[name] = resolver;
+      logger.trace(`Added scalar resolver: ${name}`);
+    }
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): { queries: number; mutations: number; subscriptions: number } {
+    return {
+      queries: Object.keys(this.resolvers.Query ?? {}).length,
+      mutations: Object.keys(this.resolvers.Mutation ?? {}).length,
+      subscriptions: Object.keys(this.resolvers.Subscription ?? {}).length
+    };
+  }
+}

package/gql/builders/TypeDefBuilder.ts

@@ -0,0 +1,105 @@
+import { logger } from "../../core/Logger";
+
+export interface OperationField {
+  name: string;
+  fieldDef: string;
+}
+
+export class TypeDefBuilder {
+  private queryFields: string[] = [];
+  private mutationFields: string[] = [];
+  private subscriptionFields: string[] = [];
+
+  /**
+   * Add a query field
+   */
+  addQueryField(field: OperationField): void {
+    this.queryFields.push(field.fieldDef);
+    logger.trace(`Added query field: ${field.fieldDef}`);
+  }
+
+  /**
+   * Add a mutation field
+   */
+  addMutationField(field: OperationField): void {
+    this.mutationFields.push(field.fieldDef);
+    logger.trace(`Added mutation field: ${field.fieldDef}`);
+  }
+
+  /**
+   * Add a subscription field
+   */
+  addSubscriptionField(field: OperationField): void {
+    this.subscriptionFields.push(field.fieldDef);
+    logger.trace(`Added subscription field: ${field.fieldDef}`);
+  }
+
+  /**
+   * Build the Query type definition
+   */
+  buildQueryType(): string {
+    if (this.queryFields.length === 0) {
+      return '';
+    }
+
+    const sortedFields = this.queryFields.sort();
+    return `type Query {\n${sortedFields.map(f => `  ${f}`).join('\n')}\n}\n`;
+  }
+
+  /**
+   * Build the Mutation type definition
+   */
+  buildMutationType(): string {
+    if (this.mutationFields.length === 0) {
+      return '';
+    }
+
+    const sortedFields = this.mutationFields.sort();
+    return `type Mutation {\n${sortedFields.map(f => `  ${f}`).join('\n')}\n}\n`;
+  }
+
+  /**
+   * Build the Subscription type definition
+   */
+  buildSubscriptionType(): string {
+    if (this.subscriptionFields.length === 0) {
+      return '';
+    }
+
+    const sortedFields = this.subscriptionFields.sort();
+    return `type Subscription {\n${sortedFields.map(f => `  ${f}`).join('\n')}\n}\n`;
+  }
+
+  /**
+   * Build all operation types
+   */
+  buildAllOperationTypes(): string {
+    let typeDefs = '';
+
+    typeDefs += this.buildQueryType();
+    typeDefs += this.buildMutationType();
+    typeDefs += this.buildSubscriptionType();
+
+    return typeDefs;
+  }
+
+  /**
+   * Clear all fields (for reuse)
+   */
+  clear(): void {
+    this.queryFields = [];
+    this.mutationFields = [];
+    this.subscriptionFields = [];
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): { queries: number; mutations: number; subscriptions: number } {
+    return {
+      queries: this.queryFields.length,
+      mutations: this.mutationFields.length,
+      subscriptions: this.subscriptionFields.length
+    };
+  }
+}

package/gql/builders/index.ts

@@ -0,0 +1,3 @@
+export { TypeDefBuilder, type OperationField } from "./TypeDefBuilder";
+export { InputTypeBuilder, type InputTypeDefinition } from "./InputTypeBuilder";
+export { ResolverBuilder, type ResolverDefinition } from "./ResolverBuilder";

package/gql/decorators/Upload.ts

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 import type { UploadDecoratorConfig } from "../../types/upload.types";
-import { UploadManager } from "../../core/UploadManager";
+import { UploadManager } from "../../upload";
 import { logger as MainLogger } from "../../core/Logger";
 
 const logger = MainLogger.child({ scope: "UploadDecorator" });

package/gql/depthLimit.ts

@@ -0,0 +1,85 @@
+import {
+    type ASTVisitor,
+    type DocumentNode,
+    type FragmentDefinitionNode,
+    type ValidationContext,
+    GraphQLError,
+    Kind,
+} from "graphql";
+
+export function depthLimitRule(maxDepth: number) {
+    return function DepthLimitValidationRule(
+        context: ValidationContext,
+    ): ASTVisitor {
+        const document: DocumentNode = context.getDocument();
+
+        // Build fragment map
+        const fragments = new Map<string, FragmentDefinitionNode>();
+        for (const def of document.definitions) {
+            if (def.kind === Kind.FRAGMENT_DEFINITION) {
+                fragments.set(def.name.value, def);
+            }
+        }
+
+        function measureDepth(
+            node: { selectionSet?: { selections: readonly any[] } },
+            depth: number,
+            visited: Set<string>,
+        ): number {
+            if (!node.selectionSet) return depth;
+
+            let max = depth;
+            for (const selection of node.selectionSet.selections) {
+                if (selection.kind === Kind.FIELD) {
+                    const fieldDepth = measureDepth(
+                        selection,
+                        depth + 1,
+                        visited,
+                    );
+                    if (fieldDepth > max) max = fieldDepth;
+                } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+                    const fragDepth = measureDepth(selection, depth, visited);
+                    if (fragDepth > max) max = fragDepth;
+                } else if (selection.kind === Kind.FRAGMENT_SPREAD) {
+                    const name = selection.name.value;
+                    if (visited.has(name)) continue;
+                    visited.add(name);
+                    const fragment = fragments.get(name);
+                    if (fragment) {
+                        const fragDepth = measureDepth(
+                            fragment,
+                            depth,
+                            visited,
+                        );
+                        if (fragDepth > max) max = fragDepth;
+                    }
+                }
+            }
+            return max;
+        }
+
+        return {
+            OperationDefinition(node) {
+                // Skip introspection queries — they are inherently deep (13+ levels)
+                // and must be allowed for tooling (codegen, IDE autocomplete, etc.)
+                if (node.selectionSet) {
+                    const isIntrospection = node.selectionSet.selections.every(
+                        (sel) =>
+                            sel.kind === Kind.FIELD &&
+                            sel.name.value.startsWith("__"),
+                    );
+                    if (isIntrospection) return;
+                }
+
+                const depth = measureDepth(node, 0, new Set());
+                if (depth > maxDepth) {
+                    context.reportError(
+                        new GraphQLError(
+                            `Query depth ${depth} exceeds maximum allowed depth of ${maxDepth}`,
+                        ),
+                    );
+                }
+            },
+        };
+    };
+}

package/gql/graph/GraphNode.ts

@@ -0,0 +1,224 @@
+/**
+ * Core graph data structures for GraphQL schema generation.
+ * Following Gall's Law: Start with a simple system that works.
+ */
+
+export enum NodeType {
+    TYPE = 'TYPE',
+    OPERATION = 'OPERATION',
+    FIELD = 'FIELD',
+    INPUT = 'INPUT',
+    SCALAR = 'SCALAR'
+}
+
+export enum GraphQLTypeKind {
+    SCALAR = 'SCALAR',
+    OBJECT = 'OBJECT',
+    INTERFACE = 'INTERFACE',
+    UNION = 'UNION',
+    ENUM = 'ENUM',
+    INPUT_OBJECT = 'INPUT_OBJECT'
+}
+
+export enum OperationType {
+    QUERY = 'QUERY',
+    MUTATION = 'MUTATION',
+    SUBSCRIPTION = 'SUBSCRIPTION'
+}
+
+/**
+ * Base class for all graph nodes in the GraphQL schema generation system.
+ * Each node represents a component of the GraphQL schema with its dependencies.
+ */
+export abstract class GraphNode {
+    public readonly id: string;
+    public readonly nodeType: NodeType;
+    public readonly metadata: Record<string, any>;
+    public readonly dependencies: string[]; // Array of node IDs this node depends on
+
+    constructor(
+        id: string,
+        nodeType: NodeType,
+        metadata: Record<string, any> = {},
+        dependencies: string[] = []
+    ) {
+        this.id = id;
+        this.nodeType = nodeType;
+        this.metadata = { ...metadata };
+        this.dependencies = [...dependencies];
+    }
+
+    /**
+     * Get a human-readable description of this node
+     */
+    abstract getDescription(): string;
+
+    /**
+     * Check if this node depends on another node
+     */
+    dependsOn(nodeId: string): boolean {
+        return this.dependencies.includes(nodeId);
+    }
+
+    /**
+     * Add a dependency to this node
+     */
+    addDependency(nodeId: string): void {
+        if (!this.dependencies.includes(nodeId)) {
+            this.dependencies.push(nodeId);
+        }
+    }
+
+    /**
+     * Remove a dependency from this node
+     */
+    removeDependency(nodeId: string): void {
+        const index = this.dependencies.indexOf(nodeId);
+        if (index > -1) {
+            this.dependencies.splice(index, 1);
+        }
+    }
+}
+
+/**
+ * Represents a GraphQL type definition (scalar, object, interface, union, enum)
+ */
+export class TypeNode extends GraphNode {
+    public readonly kind: GraphQLTypeKind;
+    public readonly name: string;
+    public readonly typeDef: string; // GraphQL type definition string
+
+    constructor(
+        id: string,
+        name: string,
+        kind: GraphQLTypeKind,
+        typeDef: string,
+        metadata: Record<string, any> = {},
+        dependencies: string[] = []
+    ) {
+        super(id, NodeType.TYPE, metadata, dependencies);
+        this.name = name;
+        this.kind = kind;
+        this.typeDef = typeDef;
+    }
+
+    getDescription(): string {
+        return `Type ${this.name} (${this.kind})`;
+    }
+}
+
+/**
+ * Represents a GraphQL operation (Query, Mutation, Subscription)
+ */
+export class OperationNode extends GraphNode {
+    public readonly operationType: OperationType;
+    public readonly name: string;
+    public readonly fieldDef: string; // GraphQL field definition string
+    public readonly inputNodeId?: string; // ID of input node if any
+    public readonly outputNodeId?: string; // ID of output node if any
+
+    constructor(
+        id: string,
+        name: string,
+        operationType: OperationType,
+        fieldDef: string,
+        inputNodeId?: string,
+        outputNodeId?: string,
+        metadata: Record<string, any> = {},
+        dependencies: string[] = []
+    ) {
+        super(id, NodeType.OPERATION, metadata, dependencies);
+        this.name = name;
+        this.operationType = operationType;
+        this.fieldDef = fieldDef;
+        this.inputNodeId = inputNodeId;
+        this.outputNodeId = outputNodeId;
+
+        // Auto-add dependencies based on input/output nodes
+        if (inputNodeId && !dependencies.includes(inputNodeId)) {
+            this.addDependency(inputNodeId);
+        }
+        if (outputNodeId && !dependencies.includes(outputNodeId)) {
+            this.addDependency(outputNodeId);
+        }
+    }
+
+    getDescription(): string {
+        return `${this.operationType} operation ${this.name}`;
+    }
+}
+
+/**
+ * Represents a GraphQL field resolver
+ */
+export class FieldNode extends GraphNode {
+    public readonly typeName: string; // The type this field belongs to
+    public readonly fieldName: string;
+    public readonly fieldDef: string; // GraphQL field definition string
+
+    constructor(
+        id: string,
+        typeName: string,
+        fieldName: string,
+        fieldDef: string,
+        metadata: Record<string, any> = {},
+        dependencies: string[] = []
+    ) {
+        super(id, NodeType.FIELD, metadata, dependencies);
+        this.typeName = typeName;
+        this.fieldName = fieldName;
+        this.fieldDef = fieldDef;
+    }
+
+    getDescription(): string {
+        return `Field ${this.fieldName} on type ${this.typeName}`;
+    }
+}
+
+/**
+ * Represents a GraphQL input type definition
+ */
+export class InputNode extends GraphNode {
+    public readonly name: string;
+    public readonly typeDef: string; // GraphQL input type definition string
+    public readonly isOptional: boolean; // Whether this input is optional
+
+    constructor(
+        id: string,
+        name: string,
+        typeDef: string,
+        isOptional: boolean = false,
+        metadata: Record<string, any> = {},
+        dependencies: string[] = []
+    ) {
+        super(id, NodeType.INPUT, metadata, dependencies);
+        this.name = name;
+        this.typeDef = typeDef;
+        this.isOptional = isOptional;
+    }
+
+    getDescription(): string {
+        return `Input type ${this.name}${this.isOptional ? ' (optional)' : ''}`;
+    }
+}
+
+/**
+ * Represents a GraphQL scalar type
+ */
+export class ScalarNode extends GraphNode {
+    public readonly name: string;
+
+    constructor(
+        id: string,
+        name: string,
+        metadata: Record<string, any> = {},
+        dependencies: string[] = []
+    ) {
+        super(id, NodeType.SCALAR, metadata, dependencies);
+        this.name = name;
+    }
+
+    getDescription(): string {
+        return `Scalar type ${this.name}`;
+    }
+}