bunsane 0.1.2 → 0.1.3

package/gql/Generator.ts

@@ -1,18 +1,29 @@
-import { GraphQLSchema, GraphQLError } from "graphql";
+import { GraphQLSchema, GraphQLError, printSchema } from "graphql";
 import { createSchema } from "graphql-yoga";
 import { logger as MainLogger } from "core/Logger";
 import type { GraphQLType } from "./helpers";
+import { generateArchetypeOperations } from "./ArchetypeOperations";
+import { getArchetypeSchema } from "../core/ArcheType";
+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";
+
 const logger = MainLogger.child({ scope: "GraphQLGenerator" });
 export interface GraphQLObjectTypeMeta {
     name: string;
     fields: Record<string, GraphQLType>;
 }
 
-export interface GraphQLOperationMeta {
+export interface GraphQLOperationMeta<T extends BaseArcheType | BaseArcheType[] | string = string> {
     type: "Query" | "Mutation";
+    propertyKey?: string;
     name?: string;
-    input?: Record<string, GraphQLType>;
-    output: GraphQLType | Record<string, GraphQLType>;
+    input?: Record<string, GraphQLType> | any;
+    output: GraphQLType | Record<string, GraphQLType> | T;
 }
 
 export interface GraphQLFieldMeta {
@@ -20,8 +31,9 @@ export interface GraphQLFieldMeta {
     field: string;
 }
 
+
 export function GraphQLObjectType(meta: GraphQLObjectTypeMeta) {
-    return (target: any) => {
+    return (target: BaseService) => {
         if (!target.__graphqlObjectType) target.__graphqlObjectType = [];
         target.__graphqlObjectType.push(meta);
     }
@@ -34,14 +46,14 @@ export function GraphQLScalarType(name: string) {
     }
 }
 
-export function GraphQLOperation(meta: GraphQLOperationMeta) {
-    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+export function GraphQLOperation<T extends BaseArcheType | BaseArcheType[] | string = string>(meta: GraphQLOperationMeta<T>) {
+    return function (target: BaseService, propertyKey: string, descriptor: PropertyDescriptor) {
         if (!target.__graphqlOperations) target.__graphqlOperations = [];
         const operationName = meta.name ?? propertyKey;
         if (!operationName) {
             throw new Error("GraphQLOperation: Operation name is required (either meta.name or propertyKey must be defined)");
         }
-        const operationMeta = { ...meta, name: operationName, propertyKey };
+        const operationMeta = { ...meta, name: operationName, propertyKey } as GraphQLOperationMeta<any>;
         target.__graphqlOperations.push(operationMeta);
     };
 }
@@ -53,7 +65,55 @@ export function GraphQLField(meta: GraphQLFieldMeta) {
     };
 }
 
-export function generateGraphQLSchema(services: any[]): { schema: GraphQLSchema | null; resolvers: any } {
+/**
+ * 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();
@@ -61,8 +121,53 @@ export function generateGraphQLSchema(services: any[]): { schema: GraphQLSchema
     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)) {
@@ -77,71 +182,152 @@ export function generateGraphQLSchema(services: any[]): { schema: GraphQLSchema
                 typeDefs += `type ${name} {\n${Object.entries(fields).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
             }
         }
-        if (service.__graphqlOperations) {
-            service.__graphqlOperations.forEach((op: any) => {
-                const { type, name, input, output, propertyKey } = op;
-                if (!resolvers[type]) resolvers[type] = {};
-                let fieldDef = `${name}`;
-                if (input) {
-                    const inputName = `${name}Input`;
-                    typeDefs += `input ${inputName} {\n${Object.entries(input).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
-                    fieldDef += `(input: ${inputName}!)`;
-                    resolvers[type][name] = async (_: any, args: any, context: any, info: any) => {
-                        try {
-                            return await service[propertyKey](args.input || args, 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 (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`;
                         }
-                    };
-                } 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;
+                        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
+                                    }
+                                });
                             }
-                            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]`;
                         }
-                    };
-                }
-                if (typeof output === 'string') {
-                    fieldDef += `: ${output}`;
-                } 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);
-                } else if (type === 'Mutation') {
-                    mutationFields.push(fieldDef);
+                    } 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 => {
-        if (service.__graphqlFields) {
-            service.__graphqlFields.forEach((fieldMeta: any) => {
+        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) => {
@@ -172,11 +358,15 @@ export function generateGraphQLSchema(services: any[]): { schema: GraphQLSchema
         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 };
 }

package/gql/helpers.ts

@@ -14,15 +14,15 @@ export function isValidGraphQLType(type: string): type is GraphQLType {
 }
 
 export type TypeFromGraphQL<T extends GraphQLType> =
-  T extends GraphQLFieldTypes.ID_REQUIRED | GraphQLFieldTypes.ID_OPTIONAL ? string :
+  T extends GraphQLFieldTypes.ID_REQUIRED | GraphQLFieldTypes.ID ? string :
   T extends GraphQLFieldTypes.STRING_REQUIRED ? string :
-  T extends GraphQLFieldTypes.STRING_OPTIONAL ? string | null :
+  T extends GraphQLFieldTypes.STRING ? string | null :
   T extends GraphQLFieldTypes.INT_REQUIRED ? number :
-  T extends GraphQLFieldTypes.INT_OPTIONAL ? number | null :
+  T extends GraphQLFieldTypes.INT ? number | null :
   T extends GraphQLFieldTypes.BOOLEAN_REQUIRED ? boolean :
-  T extends GraphQLFieldTypes.BOOLEAN_OPTIONAL ? boolean | null :
+  T extends GraphQLFieldTypes.BOOLEAN ? boolean | null :
   T extends GraphQLFieldTypes.FLOAT_REQUIRED ? number :
-  T extends GraphQLFieldTypes.FLOAT_OPTIONAL ? number | null :
+  T extends GraphQLFieldTypes.FLOAT ? number | null :
   T extends `[${string}]` | `[${string}]!` ? any[] :  
   any;  
 

package/gql/index.ts

@@ -104,26 +104,28 @@ const maskError = (error: any, message: string): GraphQLError => {
     return error instanceof GraphQLError ? error : new GraphQLError(message, { originalError: error });
 };
 
-export function createYogaInstance(schema?: GraphQLSchema, plugins: Plugin[] = []) {
+export function createYogaInstance(schema?: GraphQLSchema, plugins: Plugin[] = [], contextFactory?: (context: any) => any) {
+    const yogaConfig: any = {
+        plugins,
+        maskedErrors: {
+            maskError,
+        },
+    };
+
+    // Add context factory if provided
+    if (contextFactory) {
+        yogaConfig.context = contextFactory;
+    }
+
     if (schema) {
-        return createYoga({
-            schema,
-            plugins,
-            maskedErrors: {
-                maskError,
-            },
-        });
+        yogaConfig.schema = schema;
+        return createYoga(yogaConfig);
     } else {
-        return createYoga({
-            schema: createSchema({
-                typeDefs: staticTypeDefs,
-                resolvers: staticResolvers,
-            }),
-            plugins,
-            maskedErrors: {
-                maskError,
-            },
+        yogaConfig.schema = createSchema({
+            typeDefs: staticTypeDefs,
+            resolvers: staticResolvers,
         });
+        return createYoga(yogaConfig);
     }
 }
 

package/gql/types.ts

@@ -1,23 +1,40 @@
+
+
 export enum GraphQLScalar {
     ID = "ID",
-    String = "String",
-    Int = "Int",
-    Float = "Float",
-    Boolean = "Boolean",
-    Date = "Date",
+    INT = "Int",
+    FLOAT = "Float",
+    STRING = "String",
+    BOOLEAN = "Boolean",
+}
+
+export interface GraphQLObject {
+    name: string;
+    fields: GraphQLField[];
 }
 
+export type GraphQLType = GraphQLScalar | string;
+export interface GraphQLField {
+    name: string;
+    type: GraphQLType;
+    isList?: boolean;
+    isRequired?: boolean;
+}
+
+
+
+// TODO: Remove this when we have a better way to define GraphQL type
 export enum GraphQLFieldTypes {
+    ID = "ID",
     ID_REQUIRED = "ID!",
-    ID_OPTIONAL = "ID",
-    STRING_REQUIRED = "String!",
-    STRING_OPTIONAL = "String",
+    INT = "Int",
     INT_REQUIRED = "Int!",
-    INT_OPTIONAL = "Int",
+    FLOAT = "Float",
     FLOAT_REQUIRED = "Float!",
-    FLOAT_OPTIONAL = "Float",
+    STRING = "String",
+    STRING_REQUIRED = "String!",
+    BOOLEAN = "Boolean",
     BOOLEAN_REQUIRED = "Boolean!",
-    BOOLEAN_OPTIONAL = "Boolean",
 }
 
 export const GraphQLList = {
@@ -25,4 +42,34 @@ export const GraphQLList = {
     ofRequired: (type: string) => `[${type}]!`,
 } as const;
 
+// Utils for building GraphQL Enums
+import { GraphQLEnumType } from 'graphql';
+
+type EnumObject = {
+  [index: string]: string;
+};
+
+type EnumObjectResult = {
+  [index: string]: {
+    value: string;
+  };
+};
+export const enumBuilderValues = <T extends EnumObject>(
+  constants: T,
+): EnumObjectResult =>
+  Object.keys(constants).reduce(
+    (prev, curr) => ({
+      ...prev,
+      [curr]: {
+        value: constants[curr],
+      },
+    }),
+    {},
+  );
+
 
+export const graphqlEnumBuilder = <T extends EnumObject>(name: string, values: T) =>
+  new GraphQLEnumType({
+    name,
+    values: enumBuilderValues(values),
+  });