bunsane 0.3.1 → 0.4.0

package/core/archetype/helpers.ts

@@ -0,0 +1,29 @@
+import type { ComponentPropertyMetadata } from "../metadata/definitions/Component";
+
+export const primitiveTypes = [String, Number, Boolean, Date];
+
+export 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.
+ */
+export function shouldUnwrapComponent(
+    componentProps: ComponentPropertyMetadata[],
+    fieldType: any
+): boolean {
+    if (
+        fieldType === String ||
+        fieldType === Number ||
+        fieldType === Boolean ||
+        fieldType === Date
+    ) {
+        return true;
+    }
+    return false;
+}

package/core/archetype/relationLoader.ts

@@ -0,0 +1,161 @@
+import { Entity } from "../Entity";
+import { getMetadataStorage } from "../metadata";
+import { Query } from "../../query";
+import { getRequestScope } from "../requestScope";
+
+/**
+ * Populate relation fields on an entity according to the archetype's relationMap.
+ * Extracted from BaseArcheType.populateRelations().
+ *
+ * When called inside a request scope (GraphQL execution), relation loads go
+ * through the request's DataLoaders so sibling entities resolved in the same
+ * tick batch into single queries (previously: one `new Query()` per relation
+ * per entity — a hard N+1). Relation fields of one entity are resolved
+ * concurrently for the same reason.
+ */
+export async function populateRelations(archetype: any, entity: Entity): Promise<void> {
+    const storage = getMetadataStorage();
+
+    const fieldPromises: Promise<void>[] = [];
+    for (const [fieldName, relatedArchetype] of Object.entries(archetype.relationMap)) {
+        const relationType = archetype.relationTypes[fieldName];
+        const relationOptions = archetype.relationOptions[fieldName];
+
+        if (relationType === "belongsTo") {
+            fieldPromises.push(populateBelongsTo(archetype, entity, fieldName, relatedArchetype, relationOptions, storage));
+        } else if (relationType === "hasMany") {
+            fieldPromises.push(populateHasMany(entity, fieldName, relatedArchetype, relationOptions, storage));
+        }
+    }
+    await Promise.all(fieldPromises);
+}
+
+function resolveRelatedArchetypeInstance(relatedArchetype: any, storage: any): any | null {
+    if (typeof relatedArchetype === "function") {
+        return new (relatedArchetype as any)();
+    }
+    const meta = storage.archetypes.find((a: any) => a.name === relatedArchetype);
+    return meta ? new (meta.target as any)() : null;
+}
+
+async function populateBelongsTo(
+    archetype: any,
+    entity: Entity,
+    fieldName: string,
+    relatedArchetype: any,
+    relationOptions: any,
+    storage: any,
+): Promise<void> {
+    const foreignKey = relationOptions?.foreignKey;
+    if (!foreignKey) return;
+
+    let foreignId: string | undefined;
+
+    if (foreignKey.includes('.')) {
+        const [innerField, propName] = foreignKey.split('.');
+        const compCtor = archetype.componentMap[innerField!];
+        if (compCtor) {
+            // entity.get batches via the ambient request scope when present
+            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: any) => 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) return;
+
+    // Batched path: the request-scoped entityById loader dedups/batches
+    // sibling lookups. The returned shell entity lazy-loads components
+    // through the same scope's component loader.
+    const scope = getRequestScope();
+    if (scope?.loaders?.entityById) {
+        const relatedEntity = await scope.loaders.entityById.load(foreignId);
+        if (relatedEntity) {
+            (entity as any)[fieldName] = relatedEntity;
+        }
+        return;
+    }
+
+    const relatedArchetypeInstance = resolveRelatedArchetypeInstance(relatedArchetype, storage);
+    if (!relatedArchetypeInstance) return;
+    const relatedEntity = await relatedArchetypeInstance.getEntityWithID(foreignId);
+    if (relatedEntity) {
+        (entity as any)[fieldName] = relatedEntity;
+    }
+}
+
+async function populateHasMany(
+    entity: Entity,
+    fieldName: string,
+    relatedArchetype: any,
+    relationOptions: any,
+    storage: any,
+): Promise<void> {
+    const foreignKey = relationOptions?.foreignKey;
+    if (!foreignKey) return;
+
+    const relatedArchetypeInstance = resolveRelatedArchetypeInstance(relatedArchetype, storage);
+    if (!relatedArchetypeInstance) return;
+
+    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: any) => prop.propertyKey === foreignKey);
+        if (hasForeignKey) {
+            foreignKeyComponent = compCtorAny;
+            break;
+        }
+    }
+    if (!foreignKeyComponent) return;
+
+    // Batched path: type-scoped FK loader collapses sibling parents sharing
+    // the same (componentType, fkField) into one query.
+    const scope = getRequestScope();
+    if (scope?.loaders?.relationsByComponentFk) {
+        const componentTypeId = storage.getComponentId(foreignKeyComponent.name);
+        (entity as any)[fieldName] = await scope.loaders.relationsByComponentFk.load({
+            entityId: entity.id,
+            componentTypeId,
+            foreignKeyField: foreignKey,
+        });
+        return;
+    }
+
+    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;
+    }
+}