bunsane 0.3.0 → 0.3.2

package/core/archetype/relationLoader.ts

@@ -0,0 +1,118 @@
+import { Entity } from "../Entity";
+import { getMetadataStorage } from "../metadata";
+import { Query } from "../../query";
+
+/**
+ * Populate relation fields on an entity according to the archetype's relationMap.
+ * Extracted from BaseArcheType.populateRelations().
+ */
+export async function populateRelations(archetype: any, entity: Entity): Promise<void> {
+    const storage = getMetadataStorage();
+
+    for (const [fieldName, relatedArchetype] of Object.entries(archetype.relationMap)) {
+        const relationType = archetype.relationTypes[fieldName];
+        const relationOptions = archetype.relationOptions[fieldName];
+
+        if (relationType === "belongsTo") {
+            const foreignKey = relationOptions?.foreignKey;
+            if (foreignKey) {
+                let foreignId: string | undefined;
+
+                if (foreignKey.includes('.')) {
+                    const [innerField, propName] = foreignKey.split('.');
+                    const compCtor = archetype.componentMap[innerField!];
+                    if (compCtor) {
+                        const componentInstance = await entity.get(compCtor as any);
+                        if (componentInstance && (componentInstance as any)[propName!] !== undefined) {
+                            foreignId = (componentInstance as any)[propName!];
+                        }
+                    }
+                } else {
+                    const candidateComponents: Array<{ compCtor: any }> = [];
+                    for (const compCtor of Object.values(archetype.componentMap)) {
+                        const compCtorAny = compCtor as any;
+                        const typeId = storage.getComponentId(compCtorAny.name);
+                        const componentProps = storage.getComponentProperties(typeId);
+                        const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
+                        if (hasForeignKey) {
+                            candidateComponents.push({ compCtor: compCtorAny });
+                        }
+                    }
+
+                    if (candidateComponents.length > 0) {
+                        const componentInstances = await Promise.all(
+                            candidateComponents.map(({ compCtor }) => entity.get(compCtor as any))
+                        );
+
+                        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) {
+                    let relatedArchetypeInstance: any;
+                    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;
+                        }
+                    }
+
+                    const relatedEntity = await relatedArchetypeInstance.getEntityWithID(foreignId);
+                    if (relatedEntity) {
+                        (entity as any)[fieldName] = relatedEntity;
+                    }
+                }
+            }
+        } else if (relationType === "hasMany") {
+            const foreignKey = relationOptions?.foreignKey;
+            if (foreignKey) {
+                let relatedArchetypeInstance: any;
+                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;
+                    }
+                }
+
+                let foreignKeyComponent: any = null;
+                for (const compCtor of Object.values(relatedArchetypeInstance.componentMap)) {
+                    const compCtorAny = compCtor as any;
+                    const typeId = storage.getComponentId(compCtorAny.name);
+                    const componentProps = storage.getComponentProperties(typeId);
+                    const hasForeignKey = componentProps.some(prop => prop.propertyKey === foreignKey);
+                    if (hasForeignKey) {
+                        foreignKeyComponent = compCtorAny;
+                        break;
+                    }
+                }
+
+                if (foreignKeyComponent) {
+                    const matchingEntities = await new Query()
+                        .with(foreignKeyComponent, {
+                            filters: [{ field: foreignKey, operator: '=', value: entity.id }]
+                        })
+                        .exec();
+
+                    (entity as any)[fieldName] = matchingEntities;
+                }
+            }
+        }
+    }
+}

package/core/archetype/schemaBuilder.ts

@@ -0,0 +1,141 @@
+import type { BaseComponent } from "../components";
+import type { ArcheTypeFieldOptions } from "../metadata/definitions/ArcheType";
+import { z, ZodObject } from "zod";
+import { asEnumType } from "@gqloom/zod";
+import { getMetadataStorage } from "../metadata";
+import { compNameToFieldName, primitiveTypes } from "./helpers";
+import { customTypeRegistry } from "./customTypes";
+
+// Component-level schema cache
+export const componentSchemaCache = new Map<string, ZodObject<any>>();
+
+// Enum schema cache to prevent duplicate registrations
+export const enumSchemaCache = new Map<string, any>();
+
+/**
+ * Generate Zod schema for a component and cache it.
+ */
+export function getOrCreateComponentSchema(
+    componentCtor: new (...args: any[]) => BaseComponent,
+    componentId: string,
+    fieldOptions?: ArcheTypeFieldOptions
+): any | null {
+    if (componentSchemaCache.has(componentId)) {
+        return componentSchemaCache.get(componentId)!;
+    }
+
+    const storage = getMetadataStorage();
+    const props = storage.getComponentProperties(componentId);
+
+    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`;
+
+            let enumSchema = enumSchemaCache.get(enumTypeName);
+
+            if (!enumSchema) {
+                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;
+                            },
+                            {}
+                        ),
+                    });
+                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);
+    componentSchemaCache.set(componentId, componentSchema);
+
+    return componentSchema;
+}

package/core/archetype/weaver.ts

@@ -0,0 +1,218 @@
+import { ZodObject } from "zod";
+import { weave } from "@gqloom/core";
+import { ZodWeaver } from "@gqloom/zod";
+import { printSchema } from "graphql";
+import { getMetadataStorage } from "../metadata";
+import { componentSchemaCache } from "./schemaBuilder";
+import { inputTypeRegistry, customTypeNameRegistry } from "./customTypes";
+
+export const archetypeSchemaCache = new Map<
+    string,
+    { zodSchema: ZodObject<any>; graphqlSchema: string }
+>();
+export const allArchetypeZodObjects = new Map<string, ZodObject<any>>();
+
+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 weaveAllArchetypes() {
+    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();
+            } catch (error) {
+                console.warn(
+                    `Could not generate schema for archetype ${archetypeName}:`,
+                    error
+                );
+            }
+        }
+    }
+
+    if (allArchetypeZodObjects.size === 0) {
+        return null;
+    }
+    const archetypeSchemas = Array.from(allArchetypeZodObjects.values());
+    const componentSchemas = Array.from(componentSchemaCache.values());
+
+    const allSchemas = archetypeSchemas;
+
+    try {
+        const schema = weave(ZodWeaver, ...allSchemas);
+        let schemaString = printSchema(schema);
+
+        if (!schemaString.includes('scalar Date')) {
+            schemaString = 'scalar Date\n\n' + schemaString;
+        }
+
+        schemaString = schemaString.replace(/\bid:\s*String\b/g, "id: ID");
+
+        schemaString = schemaString.replace(/\b(\w*_at|\w*_date|\w*Date|date\w*):\s*String(!?)/gi, (match, fieldName, nullable) => {
+            return `${fieldName}: Date${nullable}`;
+        });
+
+        for (const archetypeMetadata of storage.archetypes) {
+            const archetypeName = archetypeMetadata.name;
+            try {
+                const ArchetypeClass = archetypeMetadata.target as any;
+                const instance = new ArchetypeClass();
+
+                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) {
+                        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`
+                            );
+                        }
+
+                        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 {
+                        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);
+            }
+
+            if (archetypeMetadata.functions) {
+                for (const { propertyKey, options } of archetypeMetadata.functions) {
+
+                    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, '\\$&');
+
+                        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)) {
+                        const typePattern = new RegExp(`type ${archetypeName}\\s*\\{([\\s\\S]*?)\\n\\}`, 'g');
+                        const typeMatch = typePattern.exec(schemaString);
+
+                        if (typeMatch) {
+                            const typeBody = typeMatch[1]!;
+
+                            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);
+
+                                const updatedLine = fieldLine.replace(/:\s*String(\??)(\s*)$/, `: ${options.returnType}$1$2`);
+
+                                if (updatedLine !== fieldLine) {
+                                    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;
+    }
+}