bunsane 0.3.2 → 0.4.0

package/core/app/cors.ts

@@ -1,4 +1,5 @@
 import type { CorsConfig } from "../App";
+import { setResponseHeaders } from "../middleware/headers";
 
 export function assertValidCorsConfig(cors: CorsConfig): void {
     if (cors.origin === undefined) {
@@ -80,15 +81,5 @@ export function addCorsHeaders(
 ): Response {
     const corsHeaders = getCorsHeaders(cors, req);
     if (Object.keys(corsHeaders).length === 0) return response;
-
-    const newHeaders = new Headers(response.headers);
-    for (const [key, value] of Object.entries(corsHeaders)) {
-        newHeaders.set(key, value);
-    }
-
-    return new Response(response.body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: newHeaders,
-    });
+    return setResponseHeaders(response, Object.entries(corsHeaders));
 }

package/core/app/preparedStatementWarmup.ts

@@ -1,55 +1,15 @@
-import { ComponentRegistry } from "../components";
 import { logger as MainLogger } from "../Logger";
-import { preparedStatementCache } from "../../database/PreparedStatementCache";
-import db from "../../database";
 
 const logger = MainLogger.child({ scope: "App" });
 
+/**
+ * @deprecated No-op. The framework-level prepared statement cache was
+ * removed from the query hot path — Bun SQL auto-prepares parameterized
+ * statements per connection (prepare:true default), so server-side plan
+ * reuse happens at the driver layer and "warming" a placeholder map bought
+ * nothing. Kept so bootstrap's call site and the public App surface remain
+ * stable.
+ */
 export async function warmUpPreparedStatementCache(_app: any): Promise<void> {
-    const components = ComponentRegistry.getComponents();
-
-    if (components.length === 0) {
-        logger.trace("No components registered yet, skipping cache warm-up");
-        return;
-    }
-
-    const commonQueries: Array<{ sql: string; key: string }> = [];
-
-    commonQueries.push({
-        sql: "SELECT COUNT(*) as count FROM (SELECT DISTINCT ec.entity_id as id FROM entity_components ec WHERE ec.deleted_at IS NULL) AS subquery",
-        key: "count_all_entities",
-    });
-
-    for (let i = 0; i < Math.min(5, components.length); i++) {
-        const component = components[i];
-        if (component) {
-            const { name } = component;
-            const typeId = ComponentRegistry.getComponentId(name);
-            if (typeId) {
-                commonQueries.push({
-                    sql: `SELECT DISTINCT ec.entity_id as id FROM entity_components ec WHERE ec.type_id = '${typeId}' AND ec.deleted_at IS NULL LIMIT 10`,
-                    key: `find_${name.toLowerCase()}_sample`,
-                });
-            }
-        }
-    }
-
-    if (components.length >= 2) {
-        const typeIds = components
-            .slice(0, 3)
-            .map((component: { name: string; ctor: any }) =>
-                ComponentRegistry.getComponentId(component.name)
-            )
-            .filter((id: string | undefined) => id)
-            .join("','");
-
-        if (typeIds) {
-            commonQueries.push({
-                sql: `SELECT DISTINCT ec.entity_id as id FROM entity_components ec WHERE ec.type_id IN ('${typeIds}') AND ec.deleted_at IS NULL LIMIT 10`,
-                key: "find_multi_component_sample",
-            });
-        }
-    }
-
-    await preparedStatementCache.warmUp(commonQueries, db);
+    logger.trace("Prepared statement warm-up skipped (driver-level auto-prepare in effect)");
 }

package/core/app/requestRouter.ts

@@ -1,6 +1,6 @@
 import * as path from "path";
 import { logger as MainLogger } from "../Logger";
-import { getSerializedMetadataStorage } from "../metadata";
+import { getMetadataScript } from "../metadata";
 import { addCorsHeaders, getCorsHeaders } from "./cors";
 import {
     handleHealth,
@@ -24,6 +24,8 @@ function combineSignals(signals: AbortSignal[]): AbortSignal {
             controller.abort((s as any).reason);
             return controller.signal;
         }
+        // { once: true } auto-removes the listener after first fire, so no
+        // explicit removeEventListener is needed; GC cleans up the rest.
         s.addEventListener('abort', () => controller.abort((s as any).reason), { once: true });
     }
     return controller.signal;
@@ -58,6 +60,8 @@ export async function handleRequest(app: any, req: Request): Promise<Response> {
             msg: 'Request timeout',
         }, `Request timeout: ${method} ${url.pathname}`);
     }, 30000);
+    // Prevent the timer from keeping the Bun event loop alive at high concurrency.
+    (timeoutId as any).unref?.();
     const combinedSignal = combineSignals([req.signal, controller.signal]);
     req = new Request(req, { signal: combinedSignal });
 
@@ -172,9 +176,7 @@ export async function handleRequest(app: any, req: Request): Promise<Response> {
                     const studioFile = Bun.file(studioIndexPath);
                     if (await studioFile.exists()) {
                         let html = await studioFile.text();
-                        const metadata = getSerializedMetadataStorage();
-                        const metadataScript = `<script>window.bunsaneMetadata = ${JSON.stringify(metadata)};</script>`;
-                        html = html.replace("</head>", `${metadataScript}</head>`);
+                        html = html.replace("</head>", `${getMetadataScript()}</head>`);
                         return wrap(new Response(html, {
                             headers: { "Content-Type": "text/html" },
                         }));
@@ -214,11 +216,10 @@ export async function handleRequest(app: any, req: Request): Promise<Response> {
         let endpoint = app.restEndpointMap.get(endpointKey);
 
         if (!endpoint) {
+            // Only iterate endpoints that have params (regex precompiled at registration).
             for (const ep of app.restEndpoints) {
-                if (ep.method !== method) continue;
-                const pattern = ep.path.replace(/:[^/]+/g, '[^/]+');
-                const regex = new RegExp(`^${pattern}$`);
-                if (regex.test(url.pathname)) {
+                if (!ep.regex || ep.method !== method) continue;
+                if (ep.regex.test(url.pathname)) {
                     endpoint = ep;
                     break;
                 }

package/core/app/restRegistry.ts

@@ -8,9 +8,17 @@ export function collectRestEndpoints(app: any, services: any[]): void {
         if (!endpoints) continue;
 
         for (const endpoint of endpoints) {
+            // Precompile the parameterized regex once so the hot-path router
+            // never calls replace + new RegExp per request.
+            const hasParams = endpoint.path.includes(':');
+            const regex = hasParams
+                ? new RegExp(`^${endpoint.path.replace(/:[^/]+/g, '[^/]+')}$`)
+                : undefined;
+
             const endpointInfo = {
                 method: endpoint.method,
                 path: endpoint.path,
+                regex,
                 handler: endpoint.handler.bind(service),
                 service: service,
             };

package/core/archetype/fieldResolvers.ts

@@ -57,13 +57,22 @@ export function buildFieldResolvers(archetype: any): FieldResolverEntry[] {
 
         const isUnwrapped = shouldUnwrapComponent(componentProps, fieldType);
 
+        // Detect whether the unwrapped 'value' prop is a Date so we can
+        // normalize Date instances to ISO strings before they reach
+        // gqloom's GraphQLString coercion (which would call .valueOf() and
+        // emit epoch ms instead).
+        const unwrappedValueProp = componentProps.find(p => p.propertyKey === 'value');
+        const isUnwrappedDate = isUnwrapped && unwrappedValueProp?.propertyType === Date;
+        const normalizeDateValue = (v: any) =>
+            isUnwrappedDate && v instanceof Date ? v.toISOString() : v;
+
         if (isUnwrapped) {
             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];
+                    if (!entityId) return normalizeDateValue((parent as any)[field]);
 
                     if (parent instanceof Entity) {
                         if (parent.wasRemoved(componentCtor)) {
@@ -71,7 +80,7 @@ export function buildFieldResolvers(archetype: any): FieldResolverEntry[] {
                         }
                         const inMemoryComp = parent.getInMemory(componentCtor);
                         if (inMemoryComp) {
-                            return (inMemoryComp as any)?.value;
+                            return normalizeDateValue((inMemoryComp as any)?.value);
                         }
                     }
 
@@ -82,13 +91,13 @@ export function buildFieldResolvers(archetype: any): FieldResolverEntry[] {
                                 typeId: typeIdHex,
                             });
                         if (componentData?.data?.value !== undefined) {
-                            return componentData.data.value;
+                            return normalizeDateValue(componentData.data.value);
                         }
                     }
 
                     const entity = await ensureEntity(parent, context);
                     const comp = await entity.get(componentCtor);
-                    return (comp as any)?.value;
+                    return normalizeDateValue((comp as any)?.value);
                 },
             });
         } else {
@@ -129,10 +138,17 @@ export function buildFieldResolvers(archetype: any): FieldResolverEntry[] {
             const componentTypeName = compNameToFieldName(componentName);
 
             for (const prop of componentProps) {
+                const isDateProp = prop.propertyType === Date;
                 resolvers.push({
                     typeName: componentTypeName,
                     fieldName: prop.propertyKey,
-                    resolver: (parent: any) => parent[prop.propertyKey],
+                    resolver: (parent: any) => {
+                        const v = parent[prop.propertyKey];
+                        if (isDateProp && v instanceof Date) {
+                            return v.toISOString();
+                        }
+                        return v;
+                    },
                 });
             }
         }
@@ -313,6 +329,54 @@ export function buildFieldResolvers(archetype: any): FieldResolverEntry[] {
                 },
             });
         } else if (isArray) {
+            // Resolve the FK-bearing component + field ONCE (lazily, then
+            // memoized) rather than re-instantiating the related archetype and
+            // walking its component metadata on every parent row. The result is
+            // captured in the resolver closure.
+            let fkResolution:
+                | { componentCtor: any; componentTypeId: string; foreignKeyField: string }
+                | null
+                | undefined;
+            const resolveFk = () => {
+                if (fkResolution !== undefined) return fkResolution;
+                fkResolution = null;
+                if (!relationOptions?.foreignKey) return fkResolution;
+
+                let relatedArchetypeInstance: any = null;
+                if (typeof relatedArcheType === "function") {
+                    relatedArchetypeInstance = new (relatedArcheType as any)();
+                } else if (typeof relatedArcheType === "string") {
+                    const meta = storage.archetypes.find((a) => a.name === relatedArcheType);
+                    if (meta) relatedArchetypeInstance = new (meta.target as any)();
+                }
+                if (!relatedArchetypeInstance) return fkResolution;
+
+                let componentCtor: any = null;
+                let foreignKeyField: string = relationOptions.foreignKey;
+                if (relationOptions.foreignKey.includes('.')) {
+                    const [fieldName, propName] = relationOptions.foreignKey.split('.');
+                    componentCtor = relatedArchetypeInstance.componentMap[fieldName!];
+                    foreignKeyField = propName!;
+                } else {
+                    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) {
+                    fkResolution = {
+                        componentCtor,
+                        componentTypeId: storage.getComponentId(componentCtor.name),
+                        foreignKeyField,
+                    };
+                }
+                return fkResolution;
+            };
+
             resolvers.push({
                 typeName: archetypeName,
                 fieldName: field,
@@ -321,44 +385,25 @@ export function buildFieldResolvers(archetype: any): FieldResolverEntry[] {
                     if (!entityId) return [];
 
                     if (relationOptions?.foreignKey) {
-                        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") {
-                            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 {
-                                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 {
+                        const r = resolveFk();
+                        if (!r) {
                             console.warn(`No component found with foreign key ${relationOptions.foreignKey} in ${relatedTypeName}`);
                             return [];
                         }
+                        // Batched path: dedups across sibling parents in the
+                        // same request via the type-scoped FK loader (was N+1).
+                        if (context?.loaders?.relationsByComponentFk) {
+                            return await context.loaders.relationsByComponentFk.load({
+                                entityId,
+                                componentTypeId: r.componentTypeId,
+                                foreignKeyField: r.foreignKeyField,
+                            });
+                        }
+                        // Fallback for non-request contexts (direct service
+                        // calls with no loaders mounted): single query.
+                        const query = new Query();
+                        query.with(r.componentCtor, Query.filters(Query.filter(r.foreignKeyField, Query.filterOp.EQ, entityId)));
+                        return await query.exec();
                     } else {
                         if (context?.loaders?.relationsByEntityField) {
                             return context.loaders.relationsByEntityField.load({

package/core/archetype/relationLoader.ts

@@ -1,118 +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") {
-            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;
-                            }
-                        }
-                    }
-                }
+            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);
+}
 
-                if (!foreignId && foreignKey === 'id') {
-                    foreignId = entity.id;
-                }
+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;
+}
 
-                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;
-                    }
-                }
+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 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;
-                    }
-                }
+    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 (foreignKeyComponent) {
-                    const matchingEntities = await new Query()
-                        .with(foreignKeyComponent, {
-                            filters: [{ field: foreignKey, operator: '=', value: entity.id }]
-                        })
-                        .exec();
+        if (candidateComponents.length > 0) {
+            const componentInstances = await Promise.all(
+                candidateComponents.map(({ compCtor }) => entity.get(compCtor as any))
+            );
 
-                    (entity as any)[fieldName] = matchingEntities;
+            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;
 }