bunsane 0.1.4 → 0.2.0

package/gql/Generator.ts

@@ -1,18 +1,11 @@
-import { GraphQLSchema, GraphQLError, printSchema } from "graphql";
-import { createSchema } from "graphql-yoga";
-import { logger as MainLogger } from "core/Logger";
+import { logger as MainLogger } from "../core/Logger";
 import type { GraphQLType } from "./helpers";
-import { generateArchetypeOperations } from "./ArchetypeOperations";
-import { getArchetypeSchema } from "../core/ArcheType";
+import type { SchemaType } from "./schema";
 import BaseArcheType from "../core/ArcheType";
-import { getMetadataStorage } from "../core/metadata";
-import type { BaseService } from "service";
-import { type ZodType } from "zod";
-import { ZodWeaver } from "@gqloom/zod";
-import { weave } from "@gqloom/core";
-import * as z from "zod";
+import type { BaseService } from "../service";
 
 const logger = MainLogger.child({ scope: "GraphQLGenerator" });
+
 export interface GraphQLObjectTypeMeta {
     name: string;
     fields: Record<string, GraphQLType>;
@@ -22,7 +15,14 @@ export interface GraphQLOperationMeta<T extends BaseArcheType | BaseArcheType[]
     type: "Query" | "Mutation";
     propertyKey?: string;
     name?: string;
-    input?: Record<string, GraphQLType> | any;
+    input?: Record<string, SchemaType> | Record<string, GraphQLType> | any;
+    output: GraphQLType | Record<string, GraphQLType> | T;
+}
+
+export interface GraphQLSubscriptionMeta<T extends BaseArcheType | BaseArcheType[] | string = string> {
+    propertyKey?: string;
+    name?: string;
+    input?: Record<string, SchemaType> | Record<string, GraphQLType> | any;
     output: GraphQLType | Record<string, GraphQLType> | T;
 }
 
@@ -58,6 +58,11 @@ export function GraphQLOperation<T extends BaseArcheType | BaseArcheType[] | str
     };
 }
 
+/**
+ * @deprecated Use ArcheTypeFunction instead
+ * @param meta 
+ * @returns 
+ */
 export function GraphQLField(meta: GraphQLFieldMeta) {
     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
         if (!target.__graphqlFields) target.__graphqlFields = [];
@@ -65,308 +70,15 @@ export function GraphQLField(meta: GraphQLFieldMeta) {
     };
 }
 
-/**
- * Helper function to get the registered GraphQL type name from an archetype instance.
- * This respects the custom name set via @ArcheType("CustomName") decorator.
- * Falls back to inferring from class name if not found in registry.
- */
-function getArchetypeTypeName(archetypeInstance: any): string | null {
-    if (!archetypeInstance || !(archetypeInstance instanceof BaseArcheType)) {
-        return null;
-    }
-    
-    const storage = getMetadataStorage();
-    const className = archetypeInstance.constructor.name;
-    
-    // Look up the archetype metadata by class name to get the custom name
-    const archetypeMetadata = storage.archetypes.find(a => a.target?.name === className);
-    
-    if (archetypeMetadata?.name) {
-        // Use the custom name from @ArcheType("CustomName") decorator
-        logger.trace(`Found custom archetype name: ${archetypeMetadata.name} for class ${className}`);
-        
-        // Ensure schema is generated and cached
-        try {
-            if (!getArchetypeSchema(archetypeMetadata.name)) {
-                archetypeInstance.getZodObjectSchema();
-            }
-        } catch (error) {
-            logger.warn(`Failed to generate schema for archetype ${archetypeMetadata.name}: ${error}`);
-        }
-        
-        return archetypeMetadata.name;
-    }
-    
-    // Fallback: infer from class name
-    const inferredName = className.replace(/ArcheType$/, '');
-    logger.trace(`Using inferred archetype name: ${inferredName} for class ${className}`);
-    
-    try {
-        if (!getArchetypeSchema(inferredName)) {
-            archetypeInstance.getZodObjectSchema();
-        }
-    } catch (error) {
-        logger.warn(`Failed to generate schema for archetype ${inferredName}: ${error}`);
-    }
-    
-    return inferredName;
-}
-
-export function generateGraphQLSchema(services: any[], options?: { enableArchetypeOperations?: boolean }): { schema: GraphQLSchema | null; resolvers: any } {
-    logger.trace(`generateGraphQLSchema called with ${services.length} services`);
-    let typeDefs = `
-    `;
-    const scalarTypes: Set<string> = new Set();
-    const resolvers: any = {};
-    const queryFields: string[] = [];
-    const mutationFields: string[] = [];
-
-    // PRE-GENERATE ALL ARCHETYPE SCHEMAS
-    // Scan all services for archetype instances and generate their schemas upfront
-    logger.trace(`Pre-generating archetype schemas from service operations...`);
-    services.forEach(service => {
-        const operations = service.__graphqlOperations || service.constructor.prototype.__graphqlOperations;
-        if (operations) {
-            operations.forEach((op: any) => {
-                const { output } = op;
-                // Check if output is an archetype or array of archetypes
-                if (Array.isArray(output) && output[0] instanceof BaseArcheType) {
-                    const archetypeInstance = output[0];
-                    getArchetypeTypeName(archetypeInstance); // This will cache the schema
-                } else if (output instanceof BaseArcheType) {
-                    getArchetypeTypeName(output); // This will cache the schema
-                }
-            });
-        }
-    });
-    logger.trace(`Completed pre-generation of archetype schemas`);
-
-    // Generate archetype operations if enabled
-    if (options?.enableArchetypeOperations !== false) {
-        try {
-            const archetypeOps = generateArchetypeOperations();
-            typeDefs += archetypeOps.typeDefs;
-            queryFields.push(...archetypeOps.queryFields);
-            mutationFields.push(...archetypeOps.mutationFields);
-            Object.assign(resolvers, archetypeOps.resolvers);
-            logger.trace(`Added archetype operations: ${archetypeOps.queryFields.length} queries, ${archetypeOps.mutationFields.length} mutations`);
-        } catch (error) {
-            logger.error(`Failed to generate archetype operations: ${error}`);
-        }
-    } else {
-        // Still generate type definitions even if operations are disabled
-        try {
-            const archetypeOps = generateArchetypeOperations();
-            typeDefs += archetypeOps.typeDefs;
-            logger.trace(`Added archetype type definitions (without operations)`);
-        } catch (error) {
-            logger.error(`Failed to generate archetype type definitions: ${error}`);
-        }
-    }
-
-    services.forEach(service => {
-        logger.trace(`Processing service: ${service.constructor.name}`);
-        // Check if service has graphql operations (either on instance or prototype)
-        const operations = service.__graphqlOperations || service.constructor.prototype.__graphqlOperations;
-        if(service.constructor.__graphqlScalarTypes) {
-            for (const scalarName of service.constructor.__graphqlScalarTypes) {
-                if (!scalarTypes.has(scalarName)) {
-                    scalarTypes.add(scalarName);
-                    typeDefs += `scalar ${scalarName}\n`;
-                }
-            }
-        }
-        if (service.constructor.__graphqlObjectType) {
-            for (const meta of service.constructor.__graphqlObjectType) {
-                const { name, fields } = meta;
-                typeDefs += `type ${name} {\n${Object.entries(fields).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
-            }
-        }
-        if (operations) {
-            logger.trace(`Processing ${operations.length} operations for ${service.constructor.name}`);
-            operations.forEach((op: any) => {
-                try {
-                    let { type, name, input, output, propertyKey } = op;
-                    if (!resolvers[type]) resolvers[type] = {};
-                    let fieldDef = `${name}`;
-                    if (input) {
-                        const inputName = `${name}Input`;
-                        // Check if input is a Zod schema
-                        if (input && typeof input === 'object' && '_def' in input) {
-                            // It's a Zod schema - use GQLoom's weave to generate GraphQL type
-                            try {
-                                // Add __typename to input zod object
-                                input = input.extend({ __typename: z.literal(inputName).nullish() });
-                                logger.trace(`Weaving Zod schema for ${name}`);
-                                const gqlInputSchema = weave(ZodWeaver, input as ZodType) as GraphQLSchema;
-                                const schemaString = printSchema(gqlInputSchema);
-                                logger.trace(`Schema string for ${name}: ${schemaString}`);
-                                // Extract the type definition and convert it to an input type
-                                // The schema will contain "type <TypeName> { ... }", we need to replace with "input <inputName> { ... }"
-                                const typeMatch = schemaString.match(/type\s+(\w+)\s*\{([^}]*)\}/s);
-                                if (typeMatch) {
-                                    const fields = typeMatch[2];
-                                    typeDefs += `input ${inputName} {${fields}}\n`;
-                                    logger.trace(`Successfully generated input type ${inputName}`);
-                                } else {
-                                    logger.warn(`Could not extract type from Zod schema for ${name}, schema: ${schemaString}`);
-                                    typeDefs += `input ${inputName} { _placeholder: String }\n`;
-                                }
-                            } catch (error) {
-                                logger.error(`Failed to weave Zod schema for ${name}: ${error}`);
-                                logger.error(`Error stack: ${error instanceof Error ? error.stack : 'No stack'}`);
-                                // Fallback: generate basic input type
-                                typeDefs += `input ${inputName} { _placeholder: String }\n`;
-                            }
-                        } else {
-                            // Legacy Record<string, GraphQLType> format
-                            typeDefs += `input ${inputName} {\n${Object.entries(input).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
-                        }
-                        fieldDef += `(input: ${inputName}!)`;
-                        
-                        // Store the Zod schema for validation if it's a Zod type
-                        const zodSchema = (input && typeof input === 'object' && '_def' in input) ? input as ZodType : null;
-                        
-                        resolvers[type][name] = 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 ${type}.${name}:`);
-                                logger.error(error);
-                                if (error instanceof GraphQLError) {
-                                    throw error;
-                                }
-                                throw new GraphQLError(`Internal error in ${name}`, {
-                                    extensions: {
-                                        code: "INTERNAL_ERROR",
-                                        originalError: process.env.NODE_ENV === 'development' ? error : undefined
-                                    }
-                                });
-                            }
-                        };
-                    } else {
-                        resolvers[type][name] = async (_: any, args: any, context: any, info: any) => {
-                            try {
-                                return await service[propertyKey]({}, context, info);
-                            } catch (error) {
-                                logger.error(`Error in ${type}.${name}:`);
-                                logger.error(error);
-                                if (error instanceof GraphQLError) {
-                                    throw error;
-                                }
-                                throw new GraphQLError(`Internal error in ${name}`, {
-                                    extensions: {
-                                        code: "INTERNAL_ERROR",
-                                        originalError: process.env.NODE_ENV === 'development' ? error : undefined
-                                    }
-                                });
-                            }
-                        };
-                    }
-                    if (typeof output === 'string') {
-                        fieldDef += `: ${output}`;
-                    } else if (Array.isArray(output)) {
-                        // Handle array of archetypes: [serviceAreaArcheType]
-                        const archetypeInstance = output[0];
-                        const typeName = getArchetypeTypeName(archetypeInstance);
-                        if (typeName) {
-                            fieldDef += `: [${typeName}]`;
-                        } else {
-                            logger.warn(`Invalid array output type for ${name}, expected archetype instance`);
-                            fieldDef += `: [Any]`;
-                        }
-                    } else if (output instanceof BaseArcheType) {
-                        // Handle single archetype instance: serviceAreaArcheType
-                        const typeName = getArchetypeTypeName(output);
-                        if (typeName) {
-                            fieldDef += `: ${typeName}`;
-                        } else {
-                            logger.warn(`Could not determine type name for archetype in ${name}`);
-                            fieldDef += `: Any`;
-                        }
-                    } else if (typeof output === 'object') {
-                        const outputName = `${name}Output`;
-                        typeDefs += `type ${outputName} {\n${Object.entries(output).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
-                        fieldDef += `: ${outputName}`;
-                    }
-                    if (type === 'Query') {
-                        queryFields.push(fieldDef);
-                        logger.trace(`Added query field: ${fieldDef}`);
-                    } else if (type === 'Mutation') {
-                        mutationFields.push(fieldDef);
-                        logger.trace(`Added mutation field: ${fieldDef}`);
-                    }
-                } catch (opError) {
-                    logger.error(`Failed to process operation ${op.name || 'unknown'} in ${service.constructor.name}: ${opError}`);
-                    logger.error(`Error stack: ${opError instanceof Error ? opError.stack : 'No stack'}`);
-                }
-            });
-
-            logger.trace(`Completed processing operations for ${service.constructor.name}`);
-        }
-    });
 
-    // Process field resolvers
-    services.forEach(service => {
-        const fields = service.__graphqlFields || service.constructor.prototype.__graphqlFields;
-        if (fields) {
-            fields.forEach((fieldMeta: any) => {
-                const { type, field, propertyKey } = fieldMeta;
-                if (!resolvers[type]) resolvers[type] = {};
-                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 ${type}.${field}:`);
-                        logger.error(error);
-                        if (error instanceof GraphQLError) {
-                            throw error;
-                        }
-                        throw new GraphQLError(`Internal error in ${field}`, {
-                            extensions: {
-                                code: "INTERNAL_ERROR",
-                                originalError: process.env.NODE_ENV === 'development' ? error : undefined
-                            }
-                        });
-                    }
-                };
-            });
+export function GraphQLSubscription<T extends BaseArcheType | BaseArcheType[] | string = string>(meta: GraphQLSubscriptionMeta<T>) {
+    return function (target: BaseService, propertyKey: string, descriptor: PropertyDescriptor) {
+        if (!target.__graphqlSubscriptions) target.__graphqlSubscriptions = [];
+        const subscriptionName = meta.name ?? propertyKey;
+        if (!subscriptionName) {
+            throw new Error("GraphQLSubscription: Subscription name is required (either meta.name or propertyKey must be defined)");
         }
-    });
-
-    if (queryFields.length > 0) {
-        typeDefs += `type Query {\n${queryFields.map(f => `  ${f}`).join('\n')}\n}\n`;
-    }
-    if (mutationFields.length > 0) {
-        typeDefs += `type Mutation {\n${mutationFields.map(f => `  ${f}`).join('\n')}\n}\n`;
-    }
-
-    logger.trace(`Query fields count: ${queryFields.length}, Mutation fields count: ${mutationFields.length}`);
-    logger.trace(`System Type Defs: ${typeDefs}`);
-    let schema : GraphQLSchema | null = null;
-    // Check if typeDefs contains actual schema definitions, not just whitespace
-    if(typeDefs.trim() !== "" && (queryFields.length > 0 || mutationFields.length > 0 || scalarTypes.size > 0))  {
-        logger.trace(`Creating schema with resolvers: ${Object.keys(resolvers).join(', ')}`);
-        schema = createSchema({ typeDefs, resolvers });
-    } else {
-        logger.warn(`No schema generated - queryFields: ${queryFields.length}, mutationFields: ${mutationFields.length}, scalarTypes: ${scalarTypes.size}`);
-    }
-    return { schema, resolvers };
-}
+        const subscriptionMeta = { ...meta, name: subscriptionName, propertyKey } as GraphQLSubscriptionMeta<any>;
+        target.__graphqlSubscriptions.push(subscriptionMeta);
+    };
+}

package/gql/GeneratorV2.ts

@@ -0,0 +1,37 @@
+import { GraphQLSchema } from "graphql";
+import { GraphQLSchemaOrchestrator } from "./orchestration/GraphQLSchemaOrchestrator";
+import { logger } from "../core/Logger";
+
+/**
+ * New graph-based GraphQL schema generation function.
+ * This is the V2 implementation using the GraphQLSchemaOrchestrator.
+ *
+ * @param services Array of service instances to generate schema from
+ * @param options Configuration options
+ * @returns Object containing the generated GraphQL schema and resolvers
+ */
+export function generateGraphQLSchemaV2(
+    services: any[],
+    options?: { enableArchetypeOperations?: boolean }
+): { schema: GraphQLSchema | null; resolvers: any } {
+    try {
+        logger.info("Starting GraphQL schema generation with V2 (graph-based) implementation");
+
+        // Create orchestrator instance
+        const orchestrator = new GraphQLSchemaOrchestrator();
+
+        // Generate schema using orchestrator
+        const schema = orchestrator.generateSchema(services);
+
+        // For now, return empty resolvers since the orchestrator handles everything internally
+        // TODO: Extract resolvers from orchestrator if needed for external access
+        const resolvers = {};
+
+        logger.info("GraphQL schema generation V2 completed successfully");
+        return { schema, resolvers };
+
+    } catch (error) {
+        logger.error(`Failed to generate GraphQL schema with V2 implementation: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}

package/gql/builders/InputTypeBuilder.ts

@@ -0,0 +1,99 @@
+import { logger } from "../../core/Logger";
+
+export interface InputTypeDefinition {
+  name: string;
+  fields: string[];
+}
+
+export class InputTypeBuilder {
+  private inputTypes: Map<string, string[]> = new Map();
+  private deduplicationMap: Map<string, string> = new Map();
+
+  /**
+   * Add an input type definition
+   */
+  addInputType(typeDef: InputTypeDefinition): void {
+    const existing = this.inputTypes.get(typeDef.name);
+    if (existing) {
+      // Merge fields if type already exists
+      const mergedFields = [...new Set([...existing, ...typeDef.fields])];
+      this.inputTypes.set(typeDef.name, mergedFields);
+      logger.trace(`Merged input type: ${typeDef.name} with ${mergedFields.length} fields`);
+    } else {
+      this.inputTypes.set(typeDef.name, [...typeDef.fields]);
+      logger.trace(`Added input type: ${typeDef.name} with ${typeDef.fields.length} fields`);
+    }
+  }
+
+  /**
+   * Get or create a deduplicated input type name
+   */
+  getDeduplicatedName(originalName: string): string {
+    // Check if name conflicts with existing types
+    let deduplicatedName = originalName;
+    let counter = 1;
+
+    // Keep incrementing counter until we find a name that doesn't conflict
+    // with existing input types OR previously returned deduplicated names
+    while (this.inputTypes.has(deduplicatedName) || this.deduplicationMap.has(deduplicatedName)) {
+      deduplicatedName = `${originalName}${counter}`;
+      counter++;
+    }
+
+    // Mark this name as used (store original name for reference)
+    this.deduplicationMap.set(deduplicatedName, originalName);
+    return deduplicatedName;
+  }
+
+  /**
+   * Build all input type definitions
+   */
+  buildInputTypes(): string {
+    if (this.inputTypes.size === 0) {
+      return '';
+    }
+
+    const typeDefs: string[] = [];
+
+    for (const [typeName, fields] of this.inputTypes.entries()) {
+      const sortedFields = fields.sort();
+      const typeDef = `input ${typeName} {\n${sortedFields.map(f => `  ${f}`).join('\n')}\n}\n`;
+      typeDefs.push(typeDef);
+    }
+
+    return typeDefs.join('\n');
+  }
+
+  /**
+   * Check if an input type exists
+   */
+  hasInputType(name: string): boolean {
+    return this.inputTypes.has(name);
+  }
+
+  /**
+   * Get all input type names
+   */
+  getInputTypeNames(): string[] {
+    return Array.from(this.inputTypes.keys());
+  }
+
+  /**
+   * Clear all input types (for reuse)
+   */
+  clear(): void {
+    this.inputTypes.clear();
+    this.deduplicationMap.clear();
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): { totalTypes: number; totalFields: number } {
+    const totalFields = Array.from(this.inputTypes.values()).reduce((sum, fields) => sum + fields.length, 0);
+    return {
+      totalTypes: this.inputTypes.size,
+      totalFields
+    };
+  }
+}