bunsane 0.3.1 → 0.3.2

package/core/ArcheType.ts

@@ -10,547 +10,47 @@ import { ZodWeaver, asEnumType, asUnionType, asObjectType } from "@gqloom/zod";
 import { printSchema } from "graphql";
 import "reflect-metadata";
 import { Query, type FilterSchema } from "../query";
-
-export {asEnumType, asUnionType, asObjectType};
-
-const primitiveTypes = [String, Number, Boolean, Date];
-
-const archetypeFunctionsSymbol = Symbol.for("bunsane:archetypeFunctions");
-
-export function ArcheTypeFunction(options?: { 
-    returnType?: string;
-    args?: Array<{ 
-        name: string; 
-        type: any; 
-        nullable?: boolean;
-    }>;
-}) {
-    return function (target: any, propertyKey: string) {
-        if (!target[archetypeFunctionsSymbol]) {
-            target[archetypeFunctionsSymbol] = [];
-        }
-        target[archetypeFunctionsSymbol].push({ propertyKey, options });
-    };
-}
-
-const InputFilterSchema = z.object({
-    field: z.string(),
-    op: z.string().default("eq"),
-    value: z.string(),
-}).register(asObjectType, { name: "InputFilter" });
-
-const customTypeRegistry = new Map<any, any>();
-const customTypeNameRegistry = new Map<any, string>();
-const registeredCustomTypes = new Map<string, any>();
-const customTypeSilks = new Map<string, any>(); // Store silk types for unified weaving
-const customTypeResolvers: any[] = []; // Store resolvers for custom types
-const inputTypeRegistry = new Map<any, string>(); // Map from type to input type name (e.g., ST_Point -> ST_PointInput)
-
-// Structural signature registry for input type deduplication
-// Maps structural signature -> registered input type name
-const structuralSignatureRegistry = new Map<string, string>();
-
-// Import will be done lazily to avoid circular dependencies
-let _generateZodStructuralSignature: ((schema: any) => string) | null = null;
-
-function getSignatureGenerator(): (schema: any) => string {
-    if (!_generateZodStructuralSignature) {
-        const { generateZodStructuralSignature } = require('../gql/utils/TypeSignature');
-        _generateZodStructuralSignature = generateZodStructuralSignature;
-    }
-    return _generateZodStructuralSignature!;
-}
-
-// Component-level schema cache
-const componentSchemaCache = new Map<string, ZodObject<any>>(); // componentId -> Zod schema
-
-// Enum schema cache to prevent duplicate registrations
-const enumSchemaCache = new Map<string, any>(); // enumTypeName -> Zod enum schema
-
-const archetypeSchemaCache = new Map<
-    string,
-    { zodSchema: ZodObject<any>; graphqlSchema: string }
->();
-const allArchetypeZodObjects = new Map<string, ZodObject<any>>();
-
-export function registerCustomZodType(
-    type: any,
-    schema: any,
-    typeName?: string,
-    inputTypeName?: string
-) {
-    // If a type name is provided and it's a ZodObject, add __typename to control GraphQL naming
-    if (typeName && schema instanceof ZodObject) {
-        // Extend the schema with __typename literal to control the GraphQL type name
-        const shape = schema.shape;
-        const namedSchema = z.object({
-            __typename: z.literal(typeName).nullish(),
-            ...shape,
-        });
-        customTypeRegistry.set(type, namedSchema);
-        if (typeName) {
-            customTypeNameRegistry.set(type, typeName);
-            registeredCustomTypes.set(typeName, namedSchema);
-        }
-        
-        // Register input type if provided (for use in GraphQL arguments)
-        if (inputTypeName) {
-            // Create input type schema (without __typename, as input types don't have it)
-            const inputSchema = z.object(shape).register(asObjectType, { name: inputTypeName });
-            registeredCustomTypes.set(inputTypeName, inputSchema);
-            inputTypeRegistry.set(type, inputTypeName);
-            
-            // Register structural signature for input type deduplication
-            try {
-                const generateSignature = getSignatureGenerator();
-                const signature = generateSignature(z.object(shape));
-                structuralSignatureRegistry.set(signature, inputTypeName);
-            } catch (e) {
-                // Signature registration is optional, don't fail if it errors
-            }
-        }
-    } else {
-        customTypeRegistry.set(type, schema);
-        if (typeName) {
-            customTypeNameRegistry.set(type, typeName);
-            registeredCustomTypes.set(typeName, schema);
-        }
-        
-        // Register input type if provided
-        if (inputTypeName && schema instanceof ZodObject) {
-            const inputSchema = schema.register(asObjectType, { name: inputTypeName });
-            registeredCustomTypes.set(inputTypeName, inputSchema);
-            inputTypeRegistry.set(type, inputTypeName);
-            
-            // Register structural signature for input type deduplication
-            try {
-                const generateSignature = getSignatureGenerator();
-                const signature = generateSignature(schema);
-                structuralSignatureRegistry.set(signature, inputTypeName);
-            } catch (e) {
-                // Signature registration is optional, don't fail if it errors
-            }
-        }
-    }
-}
-
-export function getArchetypeSchema(archetypeName: string, excludeRelations = false, excludeFunctions = false) {
-    const cacheKey = `${archetypeName}_${excludeRelations}_${excludeFunctions}`;
-    return archetypeSchemaCache.get(cacheKey);
-}
-
-export function getAllArchetypeSchemas() {
-    return Array.from(archetypeSchemaCache.entries())
-        .filter(([key]) => key.endsWith('_false_false'))
-        .map(([, value]) => value);
-}
-
-export function getRegisteredCustomTypes() {
-    return registeredCustomTypes;
-}
-
-/**
- * Find a matching registered input type for a given Zod schema based on structural equivalence.
- * This enables deduplication of input types that have the same structure but were created
- * through different transformations (.omit(), .extend(), etc.)
- * 
- * @param schema - The Zod schema to find a match for
- * @returns The registered input type name if found, null otherwise
- */
-export function findMatchingInputType(schema: any): string | null {
-    if (!schema) return null;
-    
-    try {
-        const generateSignature = getSignatureGenerator();
-        const signature = generateSignature(schema);
-        return structuralSignatureRegistry.get(signature) || null;
-    } catch (e) {
-        return null;
-    }
-}
-
-/**
- * Get the structural signature registry (for debugging/testing purposes)
- */
-export function getStructuralSignatureRegistry(): Map<string, string> {
-    return structuralSignatureRegistry;
-}
-
-export function weaveAllArchetypes() {
-    // First, ensure all archetype schemas are generated
-    const storage = getMetadataStorage();
-    const archetypeNames: string[] = [];
-    
-    for (const archetypeMetadata of storage.archetypes) {
-        const archetypeName = archetypeMetadata.name;
-        archetypeNames.push(archetypeName);
-        const fullSchemaCacheKey = `${archetypeName}_false_false`;
-        if (!archetypeSchemaCache.has(fullSchemaCacheKey)) {
-            try {
-                const ArchetypeClass = archetypeMetadata.target as any;
-                const instance = new ArchetypeClass();
-                instance.getZodObjectSchema(); // Generate and cache the schema
-            } catch (error) {
-                console.warn(
-                    `Could not generate schema for archetype ${archetypeName}:`,
-                    error
-                );
-            }
-        }
-    }
-
-    if (allArchetypeZodObjects.size === 0) {
-        return null;
-    }
-    // Weave all archetype schemas together along with all component schemas
-    // This ensures that nested component types are also included in the unified schema
-    const archetypeSchemas = Array.from(allArchetypeZodObjects.values());
-    const componentSchemas = Array.from(componentSchemaCache.values());
-
-    // Combine both archetype and component schemas for weaving
-    const allSchemas = archetypeSchemas;
-
-    try {
-        const schema = weave(ZodWeaver, ...allSchemas);
-        let schemaString = printSchema(schema);
-
-        // Add Date scalar if not present
-        if (!schemaString.includes('scalar Date')) {
-            schemaString = 'scalar Date\n\n' + schemaString;
-        }
-
-        // Post-process: Replace 'id: String' with 'id: ID' for all id fields
-        schemaString = schemaString.replace(/\bid:\s*String\b/g, "id: ID");
-
-        // Post-process: Replace date fields (start_at, end_at, created_at, updated_at, etc.) with Date scalar
-        // Match common date field patterns
-        schemaString = schemaString.replace(/\b(\w*_at|\w*_date|\w*Date|date\w*):\s*String(!?)/gi, (match, fieldName, nullable) => {
-            return `${fieldName}: Date${nullable}`;
-        });
-
-        // Post-process: Replace relation String fields with proper GraphQL type references
-        // Collect all relation metadata from all archetypes
-        for (const archetypeMetadata of storage.archetypes) {
-            const archetypeName = archetypeMetadata.name;
-            try {
-                const ArchetypeClass = archetypeMetadata.target as any;
-                const instance = new ArchetypeClass();
-                
-                // Process each relation field
-                for (const [field, relatedArcheType] of Object.entries(instance.relationMap)) {
-                    const relationType = instance.relationTypes[field];
-                    const isArray = relationType === "hasMany" || relationType === "belongsToMany";
-                    
-                    let relatedTypeName: string;
-                    if (typeof relatedArcheType === "string") {
-                        relatedTypeName = relatedArcheType;
-                    } else {
-                        const relatedArchetypeId = storage.getComponentId((relatedArcheType as any).name);
-                        const relatedArchetypeMetadata = storage.archetypes.find(
-                            (a) => a.typeId === relatedArchetypeId
-                        );
-                        relatedTypeName = relatedArchetypeMetadata?.name || (relatedArcheType as any).name.replace(/ArcheType$/, "");
-                    }
-                    
-                    if (isArray) {
-                        // Step 1: Add description if it doesn't exist
-                        const hasDescription = new RegExp(`"""Reference to ${relatedTypeName} type"""[\\s\\S]{0,50}${field}:`).test(schemaString);
-                        if (!hasDescription) {
-                            const addDescPattern = new RegExp(
-                                `(type ${archetypeName} \\{[\\s\\S]*?)(\\n\\s+)(${field}:\\s*\\[String!?\\]!?)`,
-                                "g"
-                            );
-                            schemaString = schemaString.replace(
-                                addDescPattern,
-                                `$1$2"""Reference to ${relatedTypeName} type"""$2$3`
-                            );
-                        }
-                        
-                        // Step 2: Replace [String!] with [TypeName!]
-                        const shouldBeRequired = instance.relationOptions[field]?.nullable === false;
-                        const suffix = shouldBeRequired ? "!" : "";
-                        const replacePattern = new RegExp(
-                            `(type ${archetypeName} \\{[\\s\\S]*?${field}:\\s*)\\[String!?\\](!?)`,
-                            "g"
-                        );
-                        schemaString = schemaString.replace(
-                            replacePattern,
-                            `$1[${relatedTypeName}!]${suffix}`
-                        );
-                    } else {
-                        // Singular relations already have descriptions from Zod, just replace type
-                        const pattern = new RegExp(
-                            `(type ${archetypeName} \\{[\\s\\S]*?${field}:\\s*)String(!?)`,
-                            "g"
-                        );
-                        const isNullable = instance.relationOptions[field]?.nullable;
-                        const suffix = isNullable ? "" : "!";
-                        schemaString = schemaString.replace(
-                            pattern,
-                            `$1${relatedTypeName}${suffix}`
-                        );
-                    }
-                }
-            } catch (error) {
-                console.warn(`Could not process relations for archetype ${archetypeMetadata.name}:`, error);
-            }
-
-            // Process each function field
-            if (archetypeMetadata.functions) {
-                for (const { propertyKey, options } of archetypeMetadata.functions) {
-                    
-                    // Add arguments if present
-                    if (options?.args && options.args.length > 0) {
-                        const argDefs: string[] = [];
-                        for (const arg of options.args) {
-                            let argTypeName: string;
-                            
-                            const inputTypeName = inputTypeRegistry.get(arg.type);
-                            if (inputTypeName) {
-                                argTypeName = inputTypeName;
-                            } else {
-                                const registeredTypeName = customTypeNameRegistry.get(arg.type);
-                                if (registeredTypeName) {
-                                    argTypeName = registeredTypeName;
-                                } else if (arg.type === String) {
-                                    argTypeName = 'String';
-                                } else if (arg.type === Number) {
-                                    argTypeName = 'Float';
-                                } else if (arg.type === Boolean) {
-                                    argTypeName = 'Boolean';
-                                } else if (arg.type === Date) {
-                                    argTypeName = 'Date';
-                                } else if (arg.type?.name) {
-                                    argTypeName = arg.type.name;
-                                } else {
-                                    argTypeName = 'String';
-                                }
-                            }
-                            
-                            const nullable = arg.nullable ? '' : '!';
-                            argDefs.push(`${arg.name}: ${argTypeName}${nullable}`);
-                        }
-                        
-                        const argsString = argDefs.join(', ');
-                        const escapedKey = propertyKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                        
-                        // Pattern to add arguments: fieldName: Type -> fieldName(args): Type
-                        // Capture leading whitespace separately to preserve it
-                        const argPattern = new RegExp(
-                            `(\\s+)(${escapedKey}\\??\\s*:\\s*)([^\\n]+)`,
-                            'g'
-                        );
-                        
-                        schemaString = schemaString.replace(
-                            argPattern,
-                            (match, leadingSpace, fieldDef, returnType) => {
-                                return `${leadingSpace}${fieldDef.trim().replace(':', '')}(${argsString}): ${returnType.trim()}`;
-                            }
-                        );
-                    }
-                    
-                    if (options?.returnType && !['string', 'number', 'boolean'].includes(options.returnType)) {
-                        // Find the archetype type definition first
-                        const typePattern = new RegExp(`type ${archetypeName}\\s*\\{([\\s\\S]*?)\\n\\}`, 'g');
-                        const typeMatch = typePattern.exec(schemaString);
-                        
-                        if (typeMatch) {
-                            const typeBody = typeMatch[1]!;
-                            
-                            // Find the field line in the type body
-                            const fieldIndex = typeBody.indexOf(`  ${propertyKey}`);
-                            if (fieldIndex !== -1) {
-                                const lineStart = fieldIndex;
-                                const lineEnd = typeBody.indexOf('\n', fieldIndex);
-                                const fieldLine = typeBody.substring(lineStart, lineEnd !== -1 ? lineEnd : typeBody.length);
-                                
-                                // Replace String with the actual return type in this line
-                                const updatedLine = fieldLine.replace(/:\s*String(\??)(\s*)$/, `: ${options.returnType}$1$2`);
-                                
-                                if (updatedLine !== fieldLine) {
-                                    // Replace in the full schema
-                                    const fullFieldIndex = schemaString.indexOf(typeMatch[0]) + typeMatch[0].indexOf(fieldLine);
-                                    schemaString = schemaString.substring(0, fullFieldIndex) + 
-                                                 updatedLine + 
-                                                 schemaString.substring(fullFieldIndex + fieldLine.length);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        return schemaString;
-    } catch (error) {
-        console.warn(
-            `Failed to weave all archetypes due to duplicate types.\n` +
-            `Archetypes being processed: ${archetypeNames.join(', ')}\n` +
-            `Error: ${error}`
-        );
-        return null;
-    }
-}
-
-// Generate Zod schema for a component and cache it
-function getOrCreateComponentSchema(
-    componentCtor: new (...args: any[]) => BaseComponent,
-    componentId: string,
-    fieldOptions?: ArcheTypeFieldOptions
-): any | null {
-    // Check cache first
-    if (componentSchemaCache.has(componentId)) {
-        return componentSchemaCache.get(componentId)!;
-    }
-
-    const storage = getMetadataStorage();
-    const props = storage.getComponentProperties(componentId);
-
-    // Return null if no properties - caller should skip this component
-    if (props.length === 0) {
-        return null;
-    }
-
-    const zodFields: Record<string, any> = {
-        __typename: z
-            .literal(compNameToFieldName(componentCtor.name))
-            .nullish(),
-    };
-
-    for (const prop of props) {
-        if (prop.isPrimitive) {
-            switch (prop.propertyType) {
-                case String:
-                    zodFields[prop.propertyKey] = z.string();
-                    break;
-                case Number:
-                    zodFields[prop.propertyKey] = z.number();
-                    break;
-                case Boolean:
-                    zodFields[prop.propertyKey] = z.boolean();
-                    break;
-                case Date:
-                    zodFields[prop.propertyKey] = z.date();
-                    break;
-                default:
-                    console.warn(`[ArcheType] Unknown primitive type for ${componentCtor.name}.${prop.propertyKey}: ${prop.propertyType?.name}. Falling back to z.string()`);
-                    zodFields[prop.propertyKey] = z.string();
-            }
-            if (prop.isOptional) {
-                zodFields[prop.propertyKey] =
-                    zodFields[prop.propertyKey].optional();
-            }
-        } else if (prop.isEnum && prop.enumValues && prop.enumKeys) {
-            const enumTypeName =
-                prop.propertyType?.name ||
-                `${componentCtor.name}_${prop.propertyKey}_Enum`;
-            
-            // Check if this enum has already been registered
-            let enumSchema = enumSchemaCache.get(enumTypeName);
-            
-            if (!enumSchema) {
-                // Register the enum for the first time
-                enumSchema = z
-                    .enum(prop.enumValues as any)
-                    .register(asEnumType, {
-                        name: enumTypeName,
-                        valuesConfig: prop.enumKeys.reduce(
-                            (
-                                acc: Record<string, { description: string }>,
-                                key,
-                                idx
-                            ) => {
-                                acc[key] = { description: prop.enumValues![idx]! };
-                                return acc;
-                            },
-                            {}
-                        ),
-                    });
-                // Cache it for reuse
-                enumSchemaCache.set(enumTypeName, enumSchema);
-            }
-            
-            zodFields[prop.propertyKey] = enumSchema;
-            if (prop.isOptional) {
-                zodFields[prop.propertyKey] =
-                    zodFields[prop.propertyKey].optional();
-            }
-        } else if (customTypeRegistry.has(prop.propertyType)) {
-            zodFields[prop.propertyKey] = customTypeRegistry.get(
-                prop.propertyType
-            )!;
-            if (prop.isOptional) {
-                zodFields[prop.propertyKey] =
-                    zodFields[prop.propertyKey].optional();
-            }
-        } else if (prop.arrayOf) {
-            if (customTypeRegistry.has(prop.arrayOf)) {
-                zodFields[prop.propertyKey] = z.array(customTypeRegistry.get(prop.arrayOf)!);
-            } else if (primitiveTypes.includes(prop.arrayOf)) {
-                if (prop.arrayOf === String) {
-                    zodFields[prop.propertyKey] = z.array(z.string());
-                } else if (prop.arrayOf === Number) {
-                    zodFields[prop.propertyKey] = z.array(z.number());
-                } else if (prop.arrayOf === Boolean) {
-                    zodFields[prop.propertyKey] = z.array(z.boolean());
-                } else if (prop.arrayOf === Date) {
-                    zodFields[prop.propertyKey] = z.array(z.date());
-                }
-            } else {
-                console.warn(`[ArcheType] Unknown array element type for ${componentCtor.name}.${prop.propertyKey}: ${prop.arrayOf?.name}. Falling back to z.array(z.string())`);
-                zodFields[prop.propertyKey] = z.array(z.string());
-            }
-            if (prop.isOptional) {
-                zodFields[prop.propertyKey] = zodFields[prop.propertyKey].optional();
-            }
-        } else {
-            console.warn(`[ArcheType] Unknown type for ${componentCtor.name}.${prop.propertyKey}: ${prop.propertyType?.name}. Falling back to z.string()`);
-            zodFields[prop.propertyKey] = z.string();
-            if (prop.isOptional) {
-                zodFields[prop.propertyKey] =
-                    zodFields[prop.propertyKey].optional();
-            }
-        }
-
-        if (fieldOptions?.nullable) {
-            zodFields[prop.propertyKey] = zodFields[prop.propertyKey].nullish();
-        }
-    }
-
-    const componentSchema = z.object(zodFields);
-
-    // Cache the component schema for reuse
-    componentSchemaCache.set(componentId, componentSchema);
-
-    return componentSchema;
-}
-
-function compNameToFieldName(compName: string): string {
-    return (
-        compName.charAt(0).toLowerCase() +
-        compName.slice(1).replace(/Component$/, "Component")
-    );
-}
-
-/**
- * Helper to determine if a component should be unwrapped to a scalar value.
- * Returns true if the component has a single 'value' property and the field type is primitive.
- */
-function shouldUnwrapComponent(
-    componentProps: ComponentPropertyMetadata[],
-    fieldType: any
-): boolean {
-    // If field type is a primitive, unwrap the component to that primitive
-    if (
-        fieldType === String ||
-        fieldType === Number ||
-        fieldType === Boolean ||
-        fieldType === Date
-    ) {
-        return true;
-    }
-    return false;
-}
+import { compNameToFieldName, shouldUnwrapComponent, primitiveTypes } from "./archetype/helpers";
+import {
+    customTypeRegistry,
+    customTypeNameRegistry,
+    registeredCustomTypes,
+    customTypeSilks,
+    customTypeResolvers,
+    inputTypeRegistry,
+    structuralSignatureRegistry,
+    registerCustomZodType,
+    findMatchingInputType,
+    getRegisteredCustomTypes,
+    getStructuralSignatureRegistry,
+} from "./archetype/customTypes";
+import {
+    componentSchemaCache,
+    enumSchemaCache,
+    getOrCreateComponentSchema,
+} from "./archetype/schemaBuilder";
+import {
+    archetypeSchemaCache,
+    allArchetypeZodObjects,
+    getArchetypeSchema,
+    getAllArchetypeSchemas,
+    weaveAllArchetypes,
+} from "./archetype/weaver";
+import {
+    archetypeFunctionsSymbol,
+    archetypeFieldsSymbol,
+    archetypeUnionFieldsSymbol,
+    archetypeRelationsSymbol,
+    ArcheTypeFunction,
+    ArcheType,
+    ArcheTypeField,
+    ArcheTypeUnionField,
+    HasMany,
+    BelongsTo,
+    HasOne,
+    BelongsToMany,
+    ArcheTypeRelation,
+} from "./archetype/decorators";
 
 export type ArcheTypeOptions = {
     name?: string;
@@ -563,6 +63,37 @@ export interface RelationOptions {
     cascade?: boolean;
 }
 
+const InputFilterSchema = z.object({
+    field: z.string(),
+    op: z.string().default("eq"),
+    value: z.string(),
+}).register(asObjectType, { name: "InputFilter" });
+
+export {asEnumType, asUnionType, asObjectType};
+export {
+    ArcheTypeFunction,
+    ArcheType,
+    ArcheTypeField,
+    ArcheTypeUnionField,
+    HasMany,
+    BelongsTo,
+    HasOne,
+    BelongsToMany,
+    ArcheTypeRelation,
+} from "./archetype/decorators";
+export { compNameToFieldName, shouldUnwrapComponent } from "./archetype/helpers";
+export {
+    registerCustomZodType,
+    findMatchingInputType,
+    getRegisteredCustomTypes,
+    getStructuralSignatureRegistry,
+} from "./archetype/customTypes";
+export {
+    getArchetypeSchema,
+    getAllArchetypeSchemas,
+    weaveAllArchetypes,
+} from "./archetype/weaver";
+
 export interface HasManyOptions extends RelationOptions {
     // Additional HasMany specific options
 }
@@ -579,156 +110,6 @@ export interface BelongsToManyOptions extends RelationOptions {
     through: string; // Required for many-to-many
 }
 
-export function ArcheType<T extends new () => BaseArcheType>(
-    nameOrOptions?: string | ArcheTypeOptions
-) {
-    return function (target: T): T {
-        const storage = getMetadataStorage();
-        const typeId = storage.getComponentId(target.name);
-
-        let archetype_name = target.name;
-
-        if (typeof nameOrOptions === "string") {
-            archetype_name = nameOrOptions;
-        } else if (nameOrOptions) {
-            archetype_name = nameOrOptions.name || target.name;
-        }
-
-        storage.collectArcheTypeMetadata({
-            name: archetype_name,
-            typeId: typeId,
-            target: target,
-        });
-
-        const prototype = target.prototype;
-        const fields = prototype[archetypeFieldsSymbol];
-        if (fields) {
-            for (const { propertyKey, component, options } of fields) {
-                const type = Reflect.getMetadata(
-                    "design:type",
-                    target.prototype,
-                    propertyKey
-                );
-                storage.collectArchetypeField(
-                    archetype_name,
-                    propertyKey,
-                    component,
-                    options,
-                    type
-                );
-            }
-        }
-
-        const unions = prototype[archetypeUnionFieldsSymbol];
-        if (unions) {
-            for (const { propertyKey, components, options } of unions) {
-                storage.collectArchetypeUnion(
-                    archetype_name,
-                    propertyKey,
-                    components,
-                    options,
-                    "union"
-                );
-            }
-        }
-
-        // Process relations
-        const relations = prototype[archetypeRelationsSymbol];
-        if (relations) {
-            for (const {
-                propertyKey,
-                relatedArcheType,
-                relationType,
-                options,
-            } of relations) {
-                const type = Reflect.getMetadata(
-                    "design:type",
-                    target.prototype,
-                    propertyKey
-                );
-                storage.collectArchetypeRelation(
-                    archetype_name,
-                    propertyKey,
-                    relatedArcheType,
-                    relationType,
-                    options,
-                    type
-                );
-            }
-        }
-
-        // Process functions
-        const functions = prototype[archetypeFunctionsSymbol];
-        if (functions) {
-            storage.collectArcheTypeMetadata({
-                name: archetype_name,
-                typeId: typeId,
-                target: target,
-                functions: functions,
-            });
-        }
-
-        return target;
-    };
-}
-
-const archetypeFieldsSymbol = Symbol.for("bunsane:archetypeFields");
-export function ArcheTypeField<T extends BaseComponent>(
-    component: new (...args: any[]) => T,
-    options?: ArcheTypeFieldOptions
-) {
-    return function (target: any, propertyKey: string) {
-        if (!target[archetypeFieldsSymbol]) {
-            target[archetypeFieldsSymbol] = [];
-        }
-        target[archetypeFieldsSymbol].push({ propertyKey, component, options });
-    };
-}
-
-const archetypeUnionFieldsSymbol = Symbol.for("bunsane:archetypeUnionFields");
-export function ArcheTypeUnionField(
-    components: (new (...args: any[]) => any)[],
-    options?: ArcheTypeFieldOptions
-) {
-    return function (target: any, propertyKey: string) {
-        if (!target[archetypeUnionFieldsSymbol]) {
-            target[archetypeUnionFieldsSymbol] = [];
-        }
-        target[archetypeUnionFieldsSymbol].push({
-            propertyKey,
-            components,
-            options,
-        });
-    };
-}
-
-const archetypeRelationsSymbol = Symbol.for("bunsane:archetypeRelations");
-
-function createRelationDecorator(
-    relationType: "hasMany" | "belongsTo" | "hasOne" | "belongsToMany"
-) {
-    return function (relatedArcheType: string, options?: RelationOptions) {
-        return function (target: any, propertyKey: string) {
-            if (!target[archetypeRelationsSymbol]) {
-                target[archetypeRelationsSymbol] = [];
-            }
-            target[archetypeRelationsSymbol].push({
-                propertyKey,
-                relatedArcheType,
-                relationType,
-                options,
-            });
-        };
-    };
-}
-
-export const HasMany = createRelationDecorator("hasMany");
-export const BelongsTo = createRelationDecorator("belongsTo");
-export const HasOne = createRelationDecorator("hasOne");
-export const BelongsToMany = createRelationDecorator("belongsToMany");
-
-// Keep ArcheTypeRelation as alias for backwards compatibility
-export const ArcheTypeRelation = HasMany;
 
 export type ArcheTypeResolver = {
     resolver?: string;
@@ -1299,127 +680,8 @@ export class BaseArcheType {
      * @param entity The entity to populate relations for
      */
     private async populateRelations(entity: Entity): Promise<void> {
-        const { Query } = await import("../query");
-        const storage = getMetadataStorage();
-
-        for (const [fieldName, relatedArchetype] of Object.entries(this.relationMap)) {
-            const relationType = this.relationTypes[fieldName];
-            const relationOptions = this.relationOptions[fieldName];
-
-            if (relationType === "belongsTo") {
-                // For belongsTo, load the related entity using foreign key
-                const foreignKey = relationOptions?.foreignKey;
-                if (foreignKey) {
-                    let foreignId: string | undefined;
-
-                    // Get foreign key value from entity's components
-                    if (foreignKey.includes('.')) {
-                        const [fieldName, propName] = foreignKey.split('.');
-                        const compCtor = this.componentMap[fieldName!];
-                        if (compCtor) {
-                            const componentInstance = await entity.get(compCtor as any);
-                            if (componentInstance && (componentInstance as any)[propName!] !== undefined) {
-                                foreignId = (componentInstance as any)[propName!];
-                            }
-                        }
-                    } else {
-                        // OPTIMIZED: Find candidate components first, then load in parallel
-                        const candidateComponents: Array<{ compCtor: any }> = [];
-                        for (const compCtor of Object.values(this.componentMap)) {
-                            const typeId = storage.getComponentId(compCtor.name);
-                            const componentProps = storage.getComponentProperties(typeId);
-                            const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
-                            if (hasForeignKey) {
-                                candidateComponents.push({ compCtor });
-                            }
-                        }
-
-                        if (candidateComponents.length > 0) {
-                            // Load all candidate components in parallel
-                            const componentInstances = await Promise.all(
-                                candidateComponents.map(({ compCtor }) => entity.get(compCtor as any))
-                            );
-
-                            // Find the first one with the foreign key value
-                            for (const componentInstance of componentInstances) {
-                                if (componentInstance && (componentInstance as any)[foreignKey] !== undefined) {
-                                    foreignId = (componentInstance as any)[foreignKey];
-                                    break;
-                                }
-                            }
-                        }
-                    }
-
-                    if (!foreignId && foreignKey === 'id') {
-                        foreignId = entity.id;
-                    }
-
-                    if (foreignId) {
-                        // Load related entity
-                        let relatedArchetypeInstance: BaseArcheType;
-                        if (typeof relatedArchetype === "function") {
-                            relatedArchetypeInstance = new (relatedArchetype as any)();
-                        } else {
-                            // Find archetype by name
-                            const relatedArchetypeMetadata = storage.archetypes.find((a) => a.name === relatedArchetype);
-                            if (relatedArchetypeMetadata) {
-                                relatedArchetypeInstance = new (relatedArchetypeMetadata.target as any)();
-                            } else {
-                                continue;
-                            }
-                        }
-
-                        const relatedEntity = await relatedArchetypeInstance.getEntityWithID(foreignId);
-                        if (relatedEntity) {
-                            // Attach as computed property (non-persisted)
-                            (entity as any)[fieldName] = relatedEntity;
-                        }
-                    }
-                }
-            } else if (relationType === "hasMany") {
-                // For hasMany, query related entities that reference this entity
-                const foreignKey = relationOptions?.foreignKey;
-                if (foreignKey) {
-                    let relatedArchetypeInstance: BaseArcheType;
-                    if (typeof relatedArchetype === "function") {
-                        relatedArchetypeInstance = new (relatedArchetype as any)();
-                    } else {
-                        const relatedArchetypeMetadata = storage.archetypes.find((a) => a.name === relatedArchetype);
-                        if (relatedArchetypeMetadata) {
-                            relatedArchetypeInstance = new (relatedArchetypeMetadata.target as any)();
-                        } else {
-                            continue;
-                        }
-                    }
-
-                    // Find the component in related archetype that has the foreign key
-                    let foreignKeyComponent: any = null;
-                    for (const compCtor of Object.values(relatedArchetypeInstance.componentMap)) {
-                        const typeId = storage.getComponentId(compCtor.name);
-                        const componentProps = storage.getComponentProperties(typeId);
-                        const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
-                        if (hasForeignKey) {
-                            foreignKeyComponent = compCtor;
-                            break;
-                        }
-                    }
-
-                    if (foreignKeyComponent) {
-                        // OPTIMIZED: Use Query with filter instead of fetching all + filtering in JS
-                        // This pushes the filtering to the database, avoiding N+1 queries
-                        const matchingEntities = await new Query()
-                            .with(foreignKeyComponent, {
-                                filters: [{ field: foreignKey, operator: '=', value: entity.id }]
-                            })
-                            .exec();
-
-                        // Attach as computed property
-                        (entity as any)[fieldName] = matchingEntities;
-                    }
-                }
-            }
-            // Note: hasOne and belongsToMany not implemented yet
-        }
+        const { populateRelations: doPopulateRelations } = require("./archetype/relationLoader");
+        return doPopulateRelations(this, entity);
     }
 
     /**
@@ -1588,713 +850,8 @@ export class BaseArcheType {
         fieldName: string;
         resolver: (parent: any, args: any, context: any) => any;
     }> {
-        const storage = getMetadataStorage();
-        const resolvers: Array<any> = [];
-        const archetypeId = storage.getComponentId(this.constructor.name);
-        const archetypeName =
-            storage.archetypes.find((a) => a.typeId === archetypeId)?.name ||
-            this.constructor.name;
-
-        // Generate ID resolver for the main archetype type
-        resolvers.push({
-            typeName: archetypeName,
-            fieldName: "id",
-            resolver: (parent: any) => {
-                return parent.id;
-            },
-        });
-
-        // Generate resolvers for each component field
-        for (const [field, ctor] of Object.entries(this.componentMap)) {
-            const typeId = storage.getComponentId(ctor.name);
-            const typeIdHex = typeId;
-            const componentName = ctor.name;
-            const fieldType = this.fieldTypes[field];
-
-            // Skip components with no properties (like tag components)
-            const componentProps = storage.getComponentProperties(typeId);
-            if (componentProps.length === 0) {
-                continue;
-            }
-
-            // Check if this component should be unwrapped to a scalar
-            const isUnwrapped = shouldUnwrapComponent(
-                componentProps,
-                fieldType
-            );
-
-            if (isUnwrapped) {
-                // For unwrapped components, resolve directly to the 'value' property
-                resolvers.push({
-                    typeName: archetypeName,
-                    fieldName: field,
-                    resolver: async (
-                        parent: any,
-                        args: any,
-                        context: any
-                    ) => {
-                        const entityId = parent?.id;
-                        if (!entityId) return (parent as any)[field];
-
-                        // Check if parent is an Entity with component state
-                        if (parent instanceof Entity) {
-                            // If component was explicitly removed, return null immediately
-                            if (parent.wasRemoved(ctor)) {
-                                return null;
-                            }
-                            const inMemoryComp = parent.getInMemory(ctor);
-                            if (inMemoryComp) {
-                                return (inMemoryComp as any)?.value;
-                            }
-                        }
-
-                        // Use DataLoader if available
-                        if (context?.loaders?.componentsByEntityType) {
-                            const componentData =
-                                await context.loaders.componentsByEntityType.load(
-                                    {
-                                        entityId: entityId,
-                                        typeId: typeIdHex,
-                                    }
-                                );
-                            if (componentData?.data?.value !== undefined) {
-                                return componentData.data.value;
-                            }
-                        }
-
-                        // Fallback: ensure we have an Entity and query directly
-                        const entity = await BaseArcheType.ensureEntity(parent, context);
-                        const comp = await entity.get(ctor);
-                        return (comp as any)?.value;
-                    },
-                });
-            } else {
-                // For complex components, return the full component object
-                resolvers.push({
-                    typeName: archetypeName,
-                    fieldName: field,
-                    resolver: async (
-                        parent: any,
-                        args: any,
-                        context: any
-                    ) => {
-                        const entityId = parent?.id;
-                        if (!entityId) return (parent as any)[field];
-
-                        // Check if parent is an Entity with the component already loaded in memory
-                        // This avoids cache/DataLoader issues for freshly created entities
-                        // Use synchronous getInMemory() to avoid triggering unnecessary DB queries
-                        if (parent instanceof Entity) {
-                            // If component was explicitly removed, return null immediately
-                            // This prevents stale DataLoader cache from returning old data
-                            if (parent.wasRemoved(ctor)) {
-                                return null;
-                            }
-                            const inMemoryComp = parent.getInMemory(ctor);
-                            if (inMemoryComp) {
-                                return inMemoryComp;
-                            }
-                        }
-
-                        // Use DataLoader if available
-                        if (context?.loaders?.componentsByEntityType) {
-                            const componentData =
-                                await context.loaders.componentsByEntityType.load(
-                                    {
-                                        entityId: entityId,
-                                        typeId: typeIdHex,
-                                    }
-                                );
-                            if (componentData?.data) {
-                                return componentData.data;
-                            }
-                        }
-
-                        // Fallback: ensure we have an Entity and query directly
-                        const entity = await BaseArcheType.ensureEntity(parent, context);
-                        const comp = await entity.get(ctor);
-                        return comp;
-                    },
-                });
-
-                // Generate nested field resolvers for component properties
-                const componentTypeName = compNameToFieldName(componentName);
-
-                for (const prop of componentProps) {
-                    resolvers.push({
-                        typeName: componentTypeName, // Use lowercase component name
-                        fieldName: prop.propertyKey,
-                        resolver: (parent: any) => parent[prop.propertyKey],
-                    });
-                }
-            }
-        }
-
-        // Generate resolvers for union fields
-        for (const [field, components] of Object.entries(this.unionMap)) {
-            resolvers.push({
-                typeName: archetypeName,
-                fieldName: field,
-                resolver: async (parent: any, args: any, context: any) => {
-                    const entityId = parent?.id;
-                    if (!entityId) return null;
-
-                    // Try to find which component in the union is present on the entity
-                    for (const component of components) {
-                        const typeId = storage.getComponentId(component.name);
-
-                        // Check if parent is an Entity with component state
-                        if (parent instanceof Entity) {
-                            // If component was explicitly removed, skip it
-                            if (parent.wasRemoved(component)) {
-                                continue;
-                            }
-                            const inMemoryComp = parent.getInMemory(component);
-                            if (inMemoryComp) {
-                                return {
-                                    __typename: compNameToFieldName(component.name),
-                                    ...(inMemoryComp as any).data?.() ?? inMemoryComp,
-                                };
-                            }
-                        }
-
-                        if (context?.loaders?.componentsByEntityType) {
-                            const componentData =
-                                await context.loaders.componentsByEntityType.load(
-                                    {
-                                        entityId: entityId,
-                                        typeId: typeId,
-                                    }
-                                );
-                            if (componentData?.data) {
-                                // Add __typename for GraphQL union resolution
-                                return {
-                                    __typename: compNameToFieldName(
-                                        component.name
-                                    ),
-                                    ...componentData.data,
-                                };
-                            }
-                        } else {
-                            // Fallback: ensure we have an Entity and query directly
-                            const entity = await BaseArcheType.ensureEntity(parent, context);
-                            const comp = await entity.get(component);
-                            if (comp) {
-                                return {
-                                    __typename: compNameToFieldName(component.name),
-                                    ...(comp as any),
-                                };
-                            }
-                        }
-                    }
-
-                    return null;
-                },
-            });
-        }
-
-        // Generate resolvers for relation fields
-        for (const [field, relatedArcheType] of Object.entries(
-            this.relationMap
-        )) {
-            const relationType = this.relationTypes[field];
-            const relationOptions = this.relationOptions[field];
-            const isArray =
-                relationType === "hasMany" || relationType === "belongsToMany";
-
-            // Get the related archetype name
-            let relatedTypeName: string;
-            if (typeof relatedArcheType === "string") {
-                relatedTypeName = relatedArcheType;
-            } else {
-                const relatedArchetypeId = storage.getComponentId(
-                    relatedArcheType.name
-                );
-                const relatedArchetypeMetadata = storage.archetypes.find(
-                    (a) => a.typeId === relatedArchetypeId
-                );
-                relatedTypeName =
-                    relatedArchetypeMetadata?.name ||
-                    relatedArcheType.name.replace(/ArcheType$/, "");
-            }
-
-            if (
-                !isArray &&
-                relationType === "belongsTo" &&
-                relationOptions?.foreignKey
-            ) {
-                resolvers.push({
-                    typeName: archetypeName,
-                    fieldName: field,
-                    resolver: async (
-                        parent: any,
-                        args: any,
-                        context: any
-                    ) => {
-                        const entityId = parent?.id;
-                        if (!entityId) {
-                            return null;
-                        }
-
-                        let foreignId: string | undefined;
-
-                        // Attempt to load the component that holds the foreign key via DataLoader
-                        if (context?.loaders?.componentsByEntityType) {
-                            const foreignKey = relationOptions.foreignKey;
-                            if (foreignKey && foreignKey.includes('.')) {
-                                // Handle nested foreign key like "field.property"
-                                const [fieldName, propName] = foreignKey.split('.');
-                                const compCtor = this.componentMap[fieldName!];
-                                if (compCtor) {
-                                    const typeIdForComponent = storage.getComponentId(compCtor.name);
-                                    const componentData = await context.loaders.componentsByEntityType.load({
-                                        entityId: entityId,
-                                        typeId: typeIdForComponent,
-                                    });
-                                    if (componentData?.data && componentData.data[propName!] !== undefined) {
-                                        foreignId = componentData.data[propName!];
-                                    }
-                                }
-                            } else {
-                                // Original logic for flat foreign key
-                                for (const [componentField, compCtor] of Object.entries(this.componentMap)) {
-                                    const typeIdForComponent = storage.getComponentId(compCtor.name);
-                                    const componentProps = storage.getComponentProperties(typeIdForComponent);
-                                    const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
-                                    if (!hasForeignKey || !foreignKey) continue;
-
-                                    const componentData = await context.loaders.componentsByEntityType.load({
-                                        entityId: entityId,
-                                        typeId: typeIdForComponent,
-                                    });
-
-                                    if (componentData?.data && componentData.data[foreignKey] !== undefined) {
-                                        foreignId = componentData.data[foreignKey];
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-
-                        // Fallback: pull the component from the entity directly when DataLoader misses
-                        if (!foreignId) {
-                            const entity = await BaseArcheType.ensureEntity(parent, context);
-                            const foreignKey = relationOptions.foreignKey;
-                            if (foreignKey && foreignKey.includes('.')) {
-                                // Handle nested foreign key like "field.property"
-                                const [fieldName, propName] = foreignKey.split('.');
-                                const compCtor = this.componentMap[fieldName!];
-                                if (compCtor) {
-                                    const componentInstance = await entity.get(compCtor as any);
-                                    if (componentInstance && (componentInstance as any)[propName!] !== undefined) {
-                                        foreignId = (componentInstance as any)[propName!];
-                                    }
-                                }
-                            } else {
-                                // Original logic for flat foreign key
-                                for (const compCtor of Object.values(this.componentMap)) {
-                                    const typeIdForComponent = storage.getComponentId(compCtor.name);
-                                    const componentProps = storage.getComponentProperties(typeIdForComponent);
-                                    const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
-                                    if (!hasForeignKey || !foreignKey) continue;
-                                    const componentInstance = await entity.get(compCtor as any);
-                                    if (componentInstance && (componentInstance as any)[foreignKey] !== undefined) {
-                                        foreignId = (componentInstance as any)[foreignKey];
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-
-                        if (!foreignId && relationOptions.foreignKey === 'id') {
-                            foreignId = entityId;
-                        }
-
-                        if (!foreignId) {
-                            return null;
-                        }
-
-                        // Resolve the related entity using loaders when possible, otherwise hit the database directly
-                        if (context.loaders?.entityById) {
-                            const relatedEntity =
-                                await context.loaders.entityById.load(
-                                    foreignId
-                                );
-                            if (relatedEntity) {
-                                return relatedEntity;
-                            }
-                        }
-
-                        return Entity.FindById(foreignId);
-                    },
-                });
-            } else if (isArray) {
-                // Array relation resolver
-                resolvers.push({
-                    typeName: archetypeName,
-                    fieldName: field,
-                    resolver: async (
-                        parent: any,
-                        args: any,
-                        context: any
-                    ) => {
-                        const entityId = parent?.id;
-                        if (!entityId) return [];
-
-                        // If foreignKey is specified, for hasMany, the foreign key is on the related entity
-                        if (relationOptions?.foreignKey) {
-                            // Find the component that has the foreign key (may be nested like "field.property")
-                            let componentCtor: any = null;
-                            let foreignKeyField: string = relationOptions.foreignKey;
-                            let relatedArchetypeInstance: any = null;
-                            
-                            if (typeof relatedArcheType === "function") {
-                                relatedArchetypeInstance = new (relatedArcheType as any)();
-                            } else if (typeof relatedArcheType === "string") {
-                                // Find the archetype class by name
-                                const relatedArchetypeMetadata = storage.archetypes.find((a) => a.name === relatedArcheType);
-                                if (relatedArchetypeMetadata) {
-                                    relatedArchetypeInstance = new (relatedArchetypeMetadata.target as any)();
-                                }
-                            }
-                            
-                            if (relatedArchetypeInstance) {
-                                if (relationOptions.foreignKey.includes('.')) {
-                                    const [fieldName, propName] = relationOptions.foreignKey.split('.');
-                                    componentCtor = relatedArchetypeInstance.componentMap[fieldName!];
-                                    foreignKeyField = propName!;
-                                } else {
-                                    // Flat foreign key
-                                    for (const comp of Object.values(relatedArchetypeInstance.componentMap) as any[]) {
-                                        const typeId = storage.getComponentId(comp.name);
-                                        const props = storage.getComponentProperties(typeId);
-                                        if (props.some(p => p.propertyKey === relationOptions.foreignKey)) {
-                                            componentCtor = comp;
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                            
-                            if (componentCtor) {
-                                const query = new Query();
-                                query.with(componentCtor, Query.filters(Query.filter(foreignKeyField, Query.filterOp.EQ, entityId)));
-                                return await query.exec();
-                            } else {
-                                console.warn(`No component found with foreign key ${relationOptions.foreignKey} in ${relatedTypeName}`);
-                                return [];
-                            }
-                        } else {
-                            // Use DataLoader for relation loading if available
-                            if (
-                                context?.loaders?.relationsByEntityField
-                            ) {
-                                return context.loaders.relationsByEntityField.load({
-                                    entityId: entityId,
-                                    relationField: field,
-                                    relatedType: relatedTypeName,
-                                    foreignKey: relationOptions?.foreignKey,
-                                });
-                            }
-
-                            // Fallback: return empty array or implement custom relation query
-                            // This should be implemented based on your relation storage strategy
-                            console.warn(
-                                `No relationsByEntityField loader found for array relation ${field} on ${archetypeName}`
-                            );
-                            return [];
-                        }
-                    },
-                });
-            } else {
-                // Single relation resolver
-                resolvers.push({
-                    typeName: archetypeName,
-                    fieldName: field,
-                    resolver: async (
-                        parent: any,
-                        args: any,
-                        context: any
-                    ) => {
-                        const entityId = parent?.id;
-
-                        // If foreignKey is specified, treat as belongsTo (foreign key on this entity)
-                        if (relationOptions?.foreignKey) {
-                            if (!entityId) {
-                                return null;
-                            }
-
-                            let foreignId: string | undefined;
-
-                            // Attempt to load the component that holds the foreign key via DataLoader
-                            if (context?.loaders?.componentsByEntityType) {
-                                const foreignKey = relationOptions.foreignKey;
-                                if (foreignKey && foreignKey.includes('.')) {
-                                    // Handle nested foreign key like "field.property"
-                                    const [fieldName, propName] = foreignKey.split('.');
-                                    const compCtor = this.componentMap[fieldName!];
-                                    if (compCtor) {
-                                        const typeIdForComponent = storage.getComponentId(compCtor.name);
-                                        const componentData = await context.loaders.componentsByEntityType.load({
-                                            entityId: entityId,
-                                            typeId: typeIdForComponent,
-                                        });
-                                        if (componentData?.data && componentData.data[propName!] !== undefined) {
-                                            foreignId = componentData.data[propName!];
-                                        }
-                                    }
-                                } else {
-                                    // OPTIMIZED: Load all candidate components in parallel via DataLoader
-                                    const candidateLoads: Array<{ compCtor: any; typeId: string }> = [];
-                                    for (const [componentField, compCtor] of Object.entries(this.componentMap)) {
-                                        const typeIdForComponent = storage.getComponentId(compCtor.name);
-                                        const componentProps = storage.getComponentProperties(typeIdForComponent);
-                                        const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
-                                        if (hasForeignKey && foreignKey) {
-                                            candidateLoads.push({ compCtor, typeId: typeIdForComponent });
-                                        }
-                                    }
-
-                                    if (candidateLoads.length > 0) {
-                                        // Load all candidate components in parallel
-                                        const componentDataResults = await Promise.all(
-                                            candidateLoads.map(({ typeId }) =>
-                                                context.loaders.componentsByEntityType.load({
-                                                    entityId: entityId,
-                                                    typeId: typeId,
-                                                })
-                                            )
-                                        );
-
-                                        // Find the first one with the foreign key value
-                                        for (const componentData of componentDataResults) {
-                                            if (componentData?.data && componentData.data[foreignKey] !== undefined) {
-                                                foreignId = componentData.data[foreignKey];
-                                                break;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-
-                            // Fallback: pull the component from the entity directly when DataLoader misses
-                            if (!foreignId) {
-                                const entity = await BaseArcheType.ensureEntity(parent, context);
-                                const foreignKey = relationOptions.foreignKey;
-                                if (foreignKey && foreignKey.includes('.')) {
-                                    // Handle nested foreign key like "field.property"
-                                    const [fieldName, propName] = foreignKey.split('.');
-                                    const compCtor = this.componentMap[fieldName!];
-                                    if (compCtor) {
-                                        const componentInstance = await entity.get(compCtor as any);
-                                        if (componentInstance && (componentInstance as any)[propName!] !== undefined) {
-                                            foreignId = (componentInstance as any)[propName!];
-                                        }
-                                    }
-                                } else {
-                                    // OPTIMIZED: Find candidates first, then load in parallel
-                                    const candidateComponents: Array<{ compCtor: any }> = [];
-                                    for (const compCtor of Object.values(this.componentMap)) {
-                                        const typeIdForComponent = storage.getComponentId(compCtor.name);
-                                        const componentProps = storage.getComponentProperties(typeIdForComponent);
-                                        const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
-                                        if (hasForeignKey && foreignKey) {
-                                            candidateComponents.push({ compCtor });
-                                        }
-                                    }
-
-                                    if (candidateComponents.length > 0) {
-                                        // Load all candidate components in parallel
-                                        const componentInstances = await Promise.all(
-                                            candidateComponents.map(({ compCtor }) => entity.get(compCtor as any))
-                                        );
-
-                                        // Find the first one with the foreign key value
-                                        for (const componentInstance of componentInstances) {
-                                            if (componentInstance && (componentInstance as any)[foreignKey] !== undefined) {
-                                                foreignId = (componentInstance as any)[foreignKey];
-                                                break;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-
-                            if (!foreignId) {
-                                return null;
-                            }
-
-                            // Resolve the related entity using loaders when possible, otherwise hit the database directly
-                            if (context?.loaders?.entityById) {
-                                const relatedEntity = await context.loaders.entityById.load(foreignId);
-                                if (relatedEntity) {
-                                    return relatedEntity;
-                                }
-                            }
-
-                            return Entity.FindById(foreignId);
-                        } else {
-                            // Use DataLoader for relation loading if available
-                            if (
-                                context?.loaders?.relationsByEntityField
-                            ) {
-                                const results =
-                                    await context.loaders.relationsByEntityField.load(
-                                        {
-                                            entityId: entityId,
-                                            relationField: field,
-                                            relatedType: relatedTypeName,
-                                            foreignKey: relationOptions?.foreignKey,
-                                        }
-                                    );
-                                if (results.length > 0) {
-                                    return results[0];
-                                }
-                            }
-
-                            // Fallback: return null or implement custom relation query
-                            console.warn(
-                                `No relationsByEntityField loader found for single relation ${field} on ${archetypeName}`
-                            );
-                            return null;
-                        }
-                    },
-                });
-            }
-        }
-
-        // Generate resolvers for archetype functions
-        for (const { propertyKey, options } of this.functions) {
-            resolvers.push({
-                typeName: archetypeName,
-                fieldName: propertyKey,
-                resolver: async (parent: any, args: any, context: any) => {
-                    // Ensure parent is a proper Entity instance
-                    // When coming from cache or GraphQL chain, parent might be a plain object
-                    let entity: Entity;
-                    if (parent instanceof Entity) {
-                        entity = parent;
-                    } else if (parent && parent.id) {
-                        // Parent is a plain object with an ID - load the entity
-                        if (context.loaders?.entityById) {
-                            const loadedEntity = await context.loaders.entityById.load(parent.id);
-                            if (loadedEntity) {
-                                entity = loadedEntity;
-                            } else {
-                                // Create a new Entity instance with the ID
-                                entity = new Entity(parent.id);
-                                entity.setPersisted(true);
-                            }
-                        } else {
-                            // No DataLoader available - create Entity instance directly
-                            entity = new Entity(parent.id);
-                            entity.setPersisted(true);
-                        }
-                    } else {
-                        throw new Error(`Invalid parent for ${archetypeName}.${propertyKey}: parent must have an 'id' property`);
-                    }
-
-                    // If function has arguments, extract and convert them
-                    if (options?.args && options.args.length > 0 && args) {
-                        const functionArgs: any[] = [];
-                        
-                        for (const argDef of options.args) {
-                            const argValue = args[argDef.name];
-                            
-                            if (argValue === undefined || argValue === null) {
-                                if (!argDef.nullable) {
-                                    throw new Error(`Required argument '${argDef.name}' is missing for ${archetypeName}.${propertyKey}`);
-                                }
-                                functionArgs.push(null);
-                                continue;
-                            }
-                            
-                            // Convert argument value to the expected type
-                            let convertedValue: any = argValue;
-                            
-                            // Check if it's a custom type that needs instantiation
-                            if (argDef.type && typeof argDef.type === 'function' && argDef.type !== String && argDef.type !== Number && argDef.type !== Boolean && argDef.type !== Date) {
-                                // Check if it's a registered custom type (like ST_Point)
-                                const isCustomType = customTypeRegistry.has(argDef.type) || 
-                                                    customTypeNameRegistry.has(argDef.type) ||
-                                                    (argDef.type?.name && registeredCustomTypes.has(argDef.type.name));
-                                
-                                if (isCustomType && typeof argValue === 'object' && !Array.isArray(argValue)) {
-                                    // Try to instantiate the type if it's a class constructor
-                                    try {
-                                        if (argDef.type.prototype && argDef.type.prototype.constructor) {
-                                            // It's a class, try to instantiate it
-                                            // First, try object assignment (works for most cases)
-                                            convertedValue = Object.assign(Object.create(argDef.type.prototype), argValue);
-                                            
-                                            // Verify the instance was created correctly
-                                            if (!convertedValue || !(convertedValue instanceof argDef.type)) {
-                                                // If object assignment didn't work, try constructor with common patterns
-                                                // This is a fallback for types that require constructor parameters
-                                                const constructor = argDef.type.prototype.constructor;
-                                                const paramCount = constructor.length;
-                                                
-                                                if (paramCount === 2) {
-                                                    // Try common 2-parameter patterns
-                                                    if (argValue.latitude !== undefined && argValue.longitude !== undefined) {
-                                                        convertedValue = new argDef.type(argValue.latitude, argValue.longitude);
-                                                    } else if (argValue.x !== undefined && argValue.y !== undefined) {
-                                                        convertedValue = new argDef.type(argValue.x, argValue.y);
-                                                    } else {
-                                                        // Fallback: use first two object values
-                                                        const values = Object.values(argValue);
-                                                        if (values.length >= 2) {
-                                                            convertedValue = new argDef.type(values[0], values[1]);
-                                                        }
-                                                    }
-                                                } else if (paramCount === 1) {
-                                                    // Single parameter - try first property value
-                                                    const values = Object.values(argValue);
-                                                    if (values.length >= 1) {
-                                                        convertedValue = new argDef.type(values[0]);
-                                                    }
-                                                } else if (paramCount === 0) {
-                                                    // No parameters - object assignment should work
-                                                    convertedValue = Object.assign(Object.create(argDef.type.prototype), argValue);
-                                                }
-                                                
-                                                // Final fallback
-                                                if (!convertedValue || !(convertedValue instanceof argDef.type)) {
-                                                    convertedValue = Object.assign(Object.create(argDef.type.prototype), argValue);
-                                                }
-                                            }
-                                        } else {
-                                            // Not a class, use the value as-is
-                                            convertedValue = argValue;
-                                        }
-                                    } catch (e) {
-                                        // If instantiation fails, try object assignment
-                                        try {
-                                            convertedValue = Object.assign(Object.create(argDef.type.prototype || {}), argValue);
-                                        } catch (e2) {
-                                            // Fallback to plain object
-                                            convertedValue = argValue;
-                                        }
-                                    }
-                                } else {
-                                    convertedValue = argValue;
-                                }
-                            }
-                            
-                            functionArgs.push(convertedValue);
-                        }
-                        
-                        // Call function with entity and arguments
-                        return await (this as any)[propertyKey](entity, ...functionArgs);
-                    } else {
-                        // No arguments, call with just entity
-                        return await (this as any)[propertyKey](entity);
-                    }
-                },
-            });
-        }
-
-        return resolvers;
+        const { buildFieldResolvers } = require("./archetype/fieldResolvers");
+        return buildFieldResolvers(this);
     }
 
     /**
@@ -2337,597 +894,8 @@ export class BaseArcheType {
     }
 
     public getZodObjectSchema(options?: { excludeRelations?: boolean; excludeFunctions?: boolean }): ZodObject<any> {
-        const excludeRelations = options?.excludeRelations ?? false;
-        const excludeFunctions = options?.excludeFunctions ?? false;
-        const zodShapes: Record<string, any> = {};
-        const storage = getMetadataStorage();
-        const unionSchemas: Array<{
-            fieldName: string;
-            schema: any;
-            components: any[];
-        }> = [];
-
-        for (const [field, ctor] of Object.entries(this.componentMap)) {
-            // Skip union fields - they'll be processed separately
-            if (field.startsWith("union_")) {
-                continue;
-            }
-
-            const type = this.fieldTypes[field];
-            const typeId = storage.getComponentId(ctor.name);
-            const componentProps = storage.getComponentProperties(typeId);
-
-            // Check if component should be unwrapped based on field type
-            if (shouldUnwrapComponent(componentProps, type)) {
-                // Unwrap to primitive type
-                if (type === String) {
-                    zodShapes[field] = z.string();
-                } else if (type === Number) {
-                    zodShapes[field] = z.number();
-                } else if (type === Boolean) {
-                    zodShapes[field] = z.boolean();
-                } else if (type === Date) {
-                    zodShapes[field] = z.date();
-                }
-            } else {
-                // Use component schema for complex types
-                const componentSchema = getOrCreateComponentSchema(
-                    ctor,
-                    typeId,
-                    this.fieldOptions[field]
-                );
-                if (componentSchema) {
-                    zodShapes[field] = componentSchema;
-                } else {
-                    // Skip components with no properties
-                    continue;
-                }
-            }
-
-            if (
-                this.fieldOptions[field]?.nullable &&
-                zodShapes[field] &&
-                !(zodShapes[field] instanceof ZodObject)
-            ) {
-                zodShapes[field] = zodShapes[field].nullish();
-            }
-        }
-
-        // Process union fields
-        for (const [fieldName, components] of Object.entries(this.unionMap)) {
-            // Generate schemas for each component in the union
-            const unionComponentSchemas: any[] = [];
-            const unionComponentCtors: any[] = [];
-
-            for (const component of components) {
-                const typeId = storage.getComponentId(component.name);
-                const componentSchema = getOrCreateComponentSchema(
-                    component,
-                    typeId,
-                    this.unionOptions[fieldName]
-                );
-
-                if (componentSchema) {
-                    unionComponentSchemas.push(componentSchema);
-                    unionComponentCtors.push(component);
-                }
-            }
-
-            // Create union type using Zod with GQLoom support
-            if (unionComponentSchemas.length > 0) {
-                const unionSchema = z
-                    .union(unionComponentSchemas)
-                    .register(asUnionType, {
-                        name:
-                            fieldName.charAt(0).toUpperCase() +
-                            fieldName.slice(1), // Capitalize field name for type
-                        resolveType: (it: any) => {
-                            // Determine which type this is based on __typename
-                            if (it.__typename) {
-                                return it.__typename;
-                            }
-                            // Fallback: check property presence
-                            for (
-                                let i = 0;
-                                i < unionComponentCtors.length;
-                                i++
-                            ) {
-                                const componentProps =
-                                    storage.getComponentProperties(
-                                        storage.getComponentId(
-                                            unionComponentCtors[i].name
-                                        )
-                                    );
-                                const hasUniqueProps = componentProps.some(
-                                    (prop) =>
-                                        it.hasOwnProperty(prop.propertyKey)
-                                );
-                                if (hasUniqueProps) {
-                                    return compNameToFieldName(
-                                        unionComponentCtors[i].name
-                                    );
-                                }
-                            }
-                            return compNameToFieldName(
-                                unionComponentCtors[0].name
-                            );
-                        },
-                    });
-
-                zodShapes[fieldName] = unionSchema;
-                unionSchemas.push({
-                    fieldName,
-                    schema: unionSchema,
-                    components: unionComponentSchemas,
-                });
-
-                // Apply nullable option for union fields
-                if (this.unionOptions[fieldName]?.nullable) {
-                    zodShapes[fieldName] = zodShapes[fieldName].nullish();
-                }
-            }
-        }
-
-        // Process relations for GraphQL schema generation (skip if excludeRelations is true)
-        if (!excludeRelations) {
-            for (const [field, relatedArcheType] of Object.entries(
-                this.relationMap
-            )) {
-                const relationType = this.relationTypes[field];
-                const isArray =
-                    relationType === "hasMany" || relationType === "belongsToMany";
-
-                // Get the related archetype name
-                let relatedTypeName: string;
-                if (typeof relatedArcheType === "string") {
-                    relatedTypeName = relatedArcheType;
-                } else {
-                    const relatedArchetypeId = storage.getComponentId(
-                        relatedArcheType.name
-                    );
-                    const relatedArchetypeMetadata = storage.archetypes.find(
-                        (a) => a.typeId === relatedArchetypeId
-                    );
-                    relatedTypeName =
-                        relatedArchetypeMetadata?.name ||
-                        relatedArcheType.name.replace(/ArcheType$/, "");
-                }
-
-                // For GraphQL relations, we just store the type name as a string reference
-                // The GraphQL schema will use the type name directly, and the full type definition
-                // will be generated when each archetype's getZodObjectSchema() is called
-                
-                // For singular relations, add description to the string schema
-                const relatedTypeSchema = z
-                    .string()
-                    .describe(`Reference to ${relatedTypeName} type`);
-
-                if (isArray) {
-                    // HasMany and BelongsToMany should be optional by default (nullable array)
-                    // unless explicitly marked as required via nullable: false
-                    const shouldBeRequired = this.relationOptions[field]?.nullable === false;
-                    // For array relations, the description on the inner string won't show up in GraphQL
-                    // We need to store metadata about this being a relation for post-processing
-                    zodShapes[field] = shouldBeRequired 
-                        ? z.array(relatedTypeSchema) 
-                        : z.array(relatedTypeSchema).optional();
-                } else {
-                    zodShapes[field] = relatedTypeSchema;
-                    
-                    // For singular relations, apply nullable option
-                    if (this.relationOptions[field]?.nullable) {
-                        zodShapes[field] = zodShapes[field].nullish();
-                    }
-                }
-            }
-        }
-
-        // Process archetype functions
-        // Store function input type names for post-processing
-        const functionInputTypes = new Map<string, string>();
-        
-        if (!excludeFunctions) {
-            for (const { propertyKey, options } of this.functions) {
-                let zodType;
-                if (options?.returnType === 'number') {
-                    zodType = z.number();
-                } else if (options?.returnType === 'string') {
-                    zodType = z.string();
-                } else if (options?.returnType === 'boolean') {
-                    zodType = z.boolean();
-                } else if (options?.returnType) {
-                    // Assume it's a GraphQL type name, create a string reference
-                    zodType = z.string().describe(`Reference to ${options.returnType} type`);
-                } else {
-                    const returnType = Reflect.getMetadata("design:returntype", this.constructor.prototype, propertyKey);
-                    if (returnType === String) {
-                        zodType = z.string();
-                    } else if (returnType === Number) {
-                        zodType = z.number();
-                    } else if (returnType === Boolean) {
-                        zodType = z.boolean();
-                    } else {
-                        zodType = z.any();
-                    }
-                }
-                
-                // Process function arguments if present
-                if (options?.args && options.args.length > 0) {
-                    const archetypeId = storage.getComponentId(this.constructor.name);
-                    const archetypeName =
-                        storage.archetypes.find((a) => a.typeId === archetypeId)?.name ||
-                        this.constructor.name;
-                    const inputTypeName = `${archetypeName}_${propertyKey}Args`;
-                    
-                    // Create input type schema for arguments
-                    const inputFields: Record<string, any> = {};
-                    for (const arg of options.args) {
-                        let argZodType: any;
-                        
-                        // Check if it's a registered custom type
-                        if (customTypeRegistry.has(arg.type)) {
-                            argZodType = customTypeRegistry.get(arg.type)!;
-                        } else if (arg.type === String || arg.type === String) {
-                            argZodType = z.string();
-                        } else if (arg.type === Number) {
-                            argZodType = z.number();
-                        } else if (arg.type === Boolean) {
-                            argZodType = z.boolean();
-                        } else if (arg.type === Date) {
-                            argZodType = z.date();
-                        } else if (registeredCustomTypes.has(arg.type?.name || '')) {
-                            // Check if it's registered by name
-                            argZodType = registeredCustomTypes.get(arg.type.name);
-                        } else {
-                            // Try to get from customTypeNameRegistry
-                            const typeName = customTypeNameRegistry.get(arg.type);
-                            if (typeName && registeredCustomTypes.has(typeName)) {
-                                argZodType = registeredCustomTypes.get(typeName);
-                            } else {
-                                console.warn(`[ArcheType] Unknown argument type for ${archetypeName}.${propertyKey}.${arg.name}: ${arg.type?.name || arg.type}. Falling back to z.any()`);
-                                argZodType = z.any();
-                            }
-                        }
-                        
-                        // Apply nullable if specified
-                        if (arg.nullable) {
-                            argZodType = argZodType.optional();
-                        }
-                        
-                        inputFields[arg.name] = argZodType;
-                    }
-                    
-                    // Create and register the input type
-                    const inputSchema = z.object(inputFields).register(asObjectType, { name: inputTypeName });
-                    registeredCustomTypes.set(inputTypeName, inputSchema);
-                    functionInputTypes.set(propertyKey, inputTypeName);
-                }
-                
-                zodShapes[propertyKey] = zodType.optional();
-            }
-        }
-
-        const archetypeId = storage.getComponentId(this.constructor.name);
-        const nameFromStorage =
-            storage.archetypes.find((a) => a.typeId === archetypeId)?.name ||
-            this.constructor.name;
-        const shape: Record<string, any> = {
-            __typename: z.literal(nameFromStorage).nullish(),
-            id: z.string().nullish(), // Will be converted to ID in post-processing
-        };
-        for (const [field, zodType] of Object.entries(zodShapes)) {
-            const isNullable =
-                this.fieldOptions[field]?.nullable ||
-                this.unionOptions[field]?.nullable;
-            if (isNullable) {
-                // For nullable fields, make them optional in the GraphQL schema
-                shape[field] = zodType.optional();
-            } else {
-                shape[field] = zodType;
-            }
-        }
-        const r = z.object(shape);
-
-        // Collect all component schemas used by this archetype for weaving
-        const componentSchemasToWeave: any[] = [];
-        for (const [field, zodType] of Object.entries(zodShapes)) {
-            if (zodType instanceof ZodObject) {
-                componentSchemasToWeave.push(zodType);
-            } else if (
-                Array.isArray(zodType) ||
-                (zodType &&
-                    typeof zodType === "object" &&
-                    zodType._def?.typeName === "ZodUnion")
-            ) {
-                // Handle union types
-                if (zodType._def?.typeName === "ZodUnion") {
-                    componentSchemasToWeave.push(zodType);
-                }
-            }
-        }
-
-        // Weave archetype schema along with its component schemas
-        const schemasToWeave = [r];
-        const schema = weave(ZodWeaver, ...schemasToWeave);
-        let graphqlSchemaString = printSchema(schema);
-
-        // Post-process: Replace 'id: String' with 'id: ID' for all id fields
-        graphqlSchemaString = graphqlSchemaString.replace(
-            /\bid:\s*String\b/g,
-            "id: ID"
-        );
-
-        // Post-process: Replace relation field types with proper GraphQL type references
-        for (const [field, relatedArcheType] of Object.entries(
-            this.relationMap
-        )) {
-            const relationType = this.relationTypes[field];
-            const isArray =
-                relationType === "hasMany" || relationType === "belongsToMany";
-
-            let relatedTypeName: string;
-            if (typeof relatedArcheType === "string") {
-                relatedTypeName = relatedArcheType;
-            } else {
-                const relatedArchetypeId = storage.getComponentId(
-                    relatedArcheType.name
-                );
-                const relatedArchetypeMetadata = storage.archetypes.find(
-                    (a) => a.typeId === relatedArchetypeId
-                );
-                relatedTypeName =
-                    relatedArchetypeMetadata?.name ||
-                    relatedArcheType.name.replace(/ArcheType$/, "");
-            }
-
-            // Replace the String field with proper GraphQL type reference
-            if (isArray) {
-                // For arrays: should be required only if explicitly set nullable: false
-                const shouldBeRequired = this.relationOptions[field]?.nullable === false;
-                const suffix = shouldBeRequired ? "!" : "";
-                
-                // Step 1: Add description comment if it doesn't exist
-                const descriptionPattern = new RegExp(`"""Reference to ${relatedTypeName} type"""[\\s\\S]*?${field}:`);
-                if (!descriptionPattern.test(graphqlSchemaString)) {
-                    // Add description before the field
-                    const addDescriptionPattern = new RegExp(
-                        `(\\n\\s+)(${field}:\\s*\\[String!?\\]!?)`,
-                        "g"
-                    );
-                    graphqlSchemaString = graphqlSchemaString.replace(
-                        addDescriptionPattern,
-                        `$1"""Reference to ${relatedTypeName} type"""\n$1$2`
-                    );
-                }
-                
-                // Step 2: Replace [String!] or [String] with [TypeName!]
-                const replaceTypePattern = new RegExp(
-                    `(${field}:\\s*)\\[String!?\\](!?)`,
-                    "g"
-                );
-                graphqlSchemaString = graphqlSchemaString.replace(
-                    replaceTypePattern,
-                    `$1[${relatedTypeName}!]${suffix}`
-                );
-            } else {
-                const isNullable = this.relationOptions[field]?.nullable;
-                const suffix = isNullable ? "" : "!";
-                const pattern = new RegExp(`${field}:\\s*String!?`, "g");
-                graphqlSchemaString = graphqlSchemaString.replace(
-                    pattern,
-                    `${field}: ${relatedTypeName}${suffix}`
-                );
-            }
-        }
-
-        // Post-process: Add argument definitions to function fields
-        if (!excludeFunctions) {
-            for (const { propertyKey, options } of this.functions) {
-                if (options?.args && options.args.length > 0) {
-                    // Build individual argument definitions
-                    const argDefs: string[] = [];
-                    for (const arg of options.args) {
-                        let argTypeName: string;
-                        
-                        // Determine GraphQL type name for the argument
-                        // For GraphQL arguments, we prefer input types over object types
-                        // First check if there's a registered input type for this type
-                        const inputTypeName = inputTypeRegistry.get(arg.type);
-                        if (inputTypeName) {
-                            argTypeName = inputTypeName;
-                        } else {
-                            // Fall back to the object type name
-                            const registeredTypeName = customTypeNameRegistry.get(arg.type);
-                            if (registeredTypeName) {
-                                argTypeName = registeredTypeName;
-                            } else if (customTypeRegistry.has(arg.type)) {
-                                // It's registered but without a name, try to find the name
-                                const registeredName = Array.from(registeredCustomTypes.entries())
-                                    .find(([name, schema]) => schema === customTypeRegistry.get(arg.type))?.[0];
-                                argTypeName = registeredName || 'String';
-                            } else if (arg.type === String) {
-                                argTypeName = 'String';
-                            } else if (arg.type === Number) {
-                                argTypeName = 'Float';
-                            } else if (arg.type === Boolean) {
-                                argTypeName = 'Boolean';
-                            } else if (arg.type === Date) {
-                                argTypeName = 'Date';
-                            } else if (arg.type?.name && registeredCustomTypes.has(arg.type.name)) {
-                                // Check if the type name is registered
-                                argTypeName = arg.type.name;
-                            } else if (arg.type?.name) {
-                                // Fallback to the type's name if it exists
-                                argTypeName = arg.type.name;
-                            } else {
-                                argTypeName = 'String';
-                            }
-                        }
-                        
-                        const nullable = arg.nullable ? '' : '!';
-                        argDefs.push(`${arg.name}: ${argTypeName}${nullable}`);
-                    }
-                    
-                    // Find the function field in the schema and add arguments
-                    // The schema format from printSchema is typically:
-                    //   fieldName: ReturnType
-                    // We need to replace it with: fieldName(arg1: Type1, arg2: Type2): ReturnType
-                    
-                    // Escape propertyKey for regex
-                    const escapedKey = propertyKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                    const escapedTypeName = nameFromStorage.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                    
-                    // Build the replacement string
-                    const argsString = argDefs.join(', ');
-                    
-                    // Debug: Log what we're looking for
-                    console.log(`[ArcheType] Adding arguments to ${nameFromStorage}.${propertyKey}: ${argsString}`);
-                    
-                    // Try to find and replace the field definition
-                    // Look for the field within the type definition
-                    // Make it case-insensitive to handle different casing in GraphQL schema
-                    const typeStartPattern = new RegExp(`type\\s+${escapedTypeName}\\s*\\{`, 'i');
-                    let typeStartMatch = graphqlSchemaString.match(typeStartPattern);
-                    
-                    // If exact match fails, try case-insensitive search for the type name
-                    if (!typeStartMatch) {
-                        // Try to find the type with any casing
-                        const caseInsensitivePattern = new RegExp(`type\\s+([^\\s{]+)\\s*\\{`, 'gi');
-                        const allTypes = [...graphqlSchemaString.matchAll(caseInsensitivePattern)];
-                        const matchingType = allTypes.find(match => 
-                            match[1]!.toLowerCase() === nameFromStorage.toLowerCase()
-                        );
-                        if (matchingType && matchingType.index !== undefined) {
-                            // Create a fake match object
-                            typeStartMatch = [matchingType[0], matchingType[1]] as RegExpMatchArray;
-                            typeStartMatch.index = matchingType.index;
-                        }
-                    }
-                    
-                    if (typeStartMatch) {
-                        const typeStartIndex = typeStartMatch.index! + typeStartMatch[0].length;
-                        // Find the closing brace of this type
-                        let braceCount = 1;
-                        let typeEndIndex = typeStartIndex;
-                        for (let i = typeStartIndex; i < graphqlSchemaString.length && braceCount > 0; i++) {
-                            if (graphqlSchemaString[i] === '{') braceCount++;
-                            if (graphqlSchemaString[i] === '}') braceCount--;
-                            if (braceCount === 0) {
-                                typeEndIndex = i;
-                                break;
-                            }
-                        }
-                        
-                        // Extract the type definition
-                        const typeDefinition = graphqlSchemaString.substring(typeStartIndex, typeEndIndex);
-                        
-                        // Debug: Log the type definition snippet
-                        console.log(`[ArcheType] Type definition for ${nameFromStorage}:`, typeDefinition.substring(0, 200));
-                        
-                        // Find the field within this type definition
-                        // Pattern: fieldName: ReturnType or fieldName?: ReturnType
-                        const fieldPattern = new RegExp(
-                            `(\\n\\s+)(${escapedKey}\\??\\s*:\\s*)([^\\n]+)`,
-                            'g'
-                        );
-                        
-                        const fieldMatch = fieldPattern.exec(typeDefinition);
-                        if (fieldMatch) {
-                            const returnType = fieldMatch[3]!.trim();
-                            const indent = fieldMatch[1];
-                            const replacement = `${indent}${propertyKey}(${argsString}): ${returnType}`;
-                            
-                            console.log(`[ArcheType] Found field match: "${fieldMatch[0]}" -> "${replacement}"`);
-                            
-                            // Replace in the full schema string
-                            const fullMatchStart = typeStartIndex + fieldMatch.index!;
-                            const fullMatchEnd = fullMatchStart + fieldMatch[0].length;
-                            graphqlSchemaString = 
-                                graphqlSchemaString.substring(0, fullMatchStart) +
-                                replacement +
-                                graphqlSchemaString.substring(fullMatchEnd);
-                            
-                            console.log(`[ArcheType] Replacement successful for ${nameFromStorage}.${propertyKey}`);
-                        } else {
-                            console.warn(`[ArcheType] Field pattern not found in type definition. Looking for: ${escapedKey}`);
-                            // Fallback: simple replace anywhere
-                            const simplePattern = new RegExp(
-                                `(${escapedKey}\\??\\s*:\\s*)([^\\n]+)`,
-                                'g'
-                            );
-                            const beforeReplace = graphqlSchemaString;
-                            graphqlSchemaString = graphqlSchemaString.replace(
-                                simplePattern,
-                                (match, fieldDef, returnType) => {
-                                    console.log(`[ArcheType] Fallback replacement: "${match}" -> "${propertyKey}(${argsString}): ${returnType.trim()}"`);
-                                    return `${propertyKey}(${argsString}): ${returnType.trim()}`;
-                                }
-                            );
-                            if (beforeReplace === graphqlSchemaString) {
-                                console.warn(`[ArcheType] Fallback replacement also failed for ${nameFromStorage}.${propertyKey}`);
-                            }
-                        }
-                    } else {
-                        console.warn(`[ArcheType] Type pattern not found for ${nameFromStorage}. Schema snippet:`, graphqlSchemaString.substring(0, 300));
-                        // Fallback: simple replace anywhere if type pattern not found
-                        const simplePattern = new RegExp(
-                            `(${escapedKey}\\??\\s*:\\s*)([^\\n]+)`,
-                            'g'
-                        );
-                        const beforeReplace = graphqlSchemaString;
-                        graphqlSchemaString = graphqlSchemaString.replace(
-                            simplePattern,
-                            (match, fieldDef, returnType) => {
-                                console.log(`[ArcheType] Final fallback replacement: "${match}" -> "${propertyKey}(${argsString}): ${returnType.trim()}"`);
-                                return `${propertyKey}(${argsString}): ${returnType.trim()}`;
-                            }
-                        );
-                        if (beforeReplace === graphqlSchemaString) {
-                            console.warn(`[ArcheType] All replacement attempts failed for ${nameFromStorage}.${propertyKey}`);
-                        }
-                    }
-                }
-                
-                // Replace String return type with actual GraphQL type if specified
-                if (options?.returnType && !['string', 'number', 'boolean'].includes(options.returnType)) {
-                    // Find the field in the schema
-                    const fieldIndex = graphqlSchemaString.indexOf(`  ${propertyKey}`);
-                    if (fieldIndex !== -1) {
-                        // Extract the line containing this field
-                        const lineStart = fieldIndex;
-                        const lineEnd = graphqlSchemaString.indexOf('\n', fieldIndex);
-                        const fieldLine = graphqlSchemaString.substring(lineStart, lineEnd !== -1 ? lineEnd : graphqlSchemaString.length);
-                        
-                        // Replace String with the actual return type in this line
-                        const updatedLine = fieldLine.replace(/:\s*String(\??)(\s*)$/, `: ${options.returnType}$1$2`);
-                        
-                        if (updatedLine !== fieldLine) {
-                            // Replace the line in the full schema
-                            graphqlSchemaString = graphqlSchemaString.substring(0, lineStart) + 
-                                                 updatedLine + 
-                                                 graphqlSchemaString.substring(lineEnd !== -1 ? lineEnd : graphqlSchemaString.length);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Debug: Log schema if it contains function arguments
-        if (!excludeFunctions && this.functions.some(f => f.options?.args && f.options.args.length > 0)) {
-            // console.log(`[ArcheType] Final schema for ${nameFromStorage} with function args:`, graphqlSchemaString);
-        }
-
-        // Cache the schema for this archetype
-        const cacheKey = `${nameFromStorage}_${excludeRelations}_${excludeFunctions}`;
-        archetypeSchemaCache.set(cacheKey, {
-            zodSchema: r,
-            graphqlSchema: graphqlSchemaString,
-        });
-
-        // Store for unified weaving
-        allArchetypeZodObjects.set(nameFromStorage, r);
-
-        return r;
+        const { buildZodObjectSchema } = require("./archetype/zodSchemaBuilder");
+        return buildZodObjectSchema(this, options);
     }
 
     /**