bunsane 0.3.1 → 0.4.0

package/core/Logger.ts

@@ -27,3 +27,13 @@ export const logger = pino({
         }
     })
 });
+
+// pino-pretty serializes each log line synchronously on the main thread — 5-10x
+// slower than production JSON output. Warn once so operators don't accidentally
+// ship a pretty-print config to production.
+if (usePretty && process.env.NODE_ENV === 'production') {
+    logger.warn(
+        'LOG_PRETTY=true is set in a production environment. ' +
+        'pino-pretty is 5-10x slower than JSON output and should not run in production.'
+    );
+}

package/core/RequestContext.ts

@@ -4,6 +4,14 @@ import type { RequestLoaders } from './RequestLoaders';
 import db from '../database';
 import { CacheManager } from './cache/CacheManager';
 import { getRequestId } from './middleware/RequestId';
+import { runWithRequestScope } from './requestScope';
+
+export interface RequestStats {
+  operationName: string;
+  dataLoaderCalls: { entity: number; component: number; relation: number };
+  dbQueryCount: number;
+  startTime: number;
+}
 
 declare module 'graphql-yoga' {
   interface Context {
@@ -11,6 +19,8 @@ declare module 'graphql-yoga' {
     loaders: RequestLoaders;
     requestId: string;
     cacheManager: CacheManager;
+    requestStats: RequestStats;
+    signal?: AbortSignal;
   }
 }
 
@@ -20,17 +30,65 @@ declare module 'graphql-yoga' {
  * IMPORTANT: Loaders are mounted at context.loaders (NOT context.locals.loaders)
  * to match what ArcheType.ts resolvers expect. This enables DataLoader batching
  * for BelongsTo/HasMany relations, preventing N+1 queries.
+ *
+ * Also threads the request `AbortSignal` into Query/DataLoader DB calls so
+ * the framework's wall-clock timeout (handled in core/app/requestRouter.ts)
+ * cancels in-flight Postgres queries via Bun's `Query.cancel()`. Without
+ * this, an aborted request leaks its backend connection into
+ * `idle in transaction` under pgbouncer transaction-mode pooling.
+ *
+ * Captures per-request stats (operationName, DataLoader call counts,
+ * dbQueryCount) and attaches them to the underlying Request via
+ * `__bunsaneStats` so the HTTP router's catch handler + AccessLog
+ * middleware can read them after the GraphQL pipeline rejects.
  */
 export function createRequestContextPlugin(): Plugin {
   return {
-    onExecute: ({ args }) => {
+    onExecute: ({ args, executeFn, setExecuteFn }) => {
       const cacheManager = CacheManager.getInstance();
-      // Mount loaders at context.loaders to match ArcheType.ts resolver access pattern
-      (args as any).contextValue.loaders = createRequestLoaders(db, cacheManager);
+      const ctx: any = (args as any).contextValue;
+      const request: Request | undefined = ctx?.request;
+      const signal: AbortSignal | undefined = request?.signal;
+
+      // GraphQL operation name. Falls back to first named operation in the
+      // document, or 'anonymous' if the client supplied an inline query
+      // with no name.
+      const operationName: string =
+        (typeof args.operationName === 'string' && args.operationName)
+        || (args.document?.definitions?.find?.(
+              (d: any) => d?.kind === 'OperationDefinition' && d?.name?.value,
+           ) as any)?.name?.value
+        || 'anonymous';
+
+      const stats: RequestStats = {
+        operationName,
+        dataLoaderCalls: { entity: 0, component: 0, relation: 0 },
+        dbQueryCount: 0,
+        startTime: performance.now(),
+      };
+
+      // Mount loaders at context.loaders to match ArcheType.ts resolver access pattern.
+      ctx.loaders = createRequestLoaders(db, cacheManager, signal, stats);
       // Prefer the HTTP-layer request id (from requestId() middleware's
       // AsyncLocalStorage) so access log + GraphQL logs share the same id.
-      (args as any).contextValue.requestId = getRequestId() ?? crypto.randomUUID();
-      (args as any).contextValue.cacheManager = cacheManager;
+      ctx.requestId = getRequestId() ?? crypto.randomUUID();
+      ctx.cacheManager = cacheManager;
+      ctx.requestStats = stats;
+      ctx.signal = signal;
+
+      // Attach to the raw Request so the HTTP router catch block + access
+      // log middleware can read stats after Yoga rejects.
+      if (request) {
+        (request as any).__bunsaneStats = stats;
+      }
+
+      // Run the whole execution inside an AsyncLocalStorage scope so bare
+      // `entity.get(Component)` calls (e.g. inside @ArcheTypeFunction
+      // bodies, Unwrap(), service helpers) pick up the request's batching
+      // DataLoaders + AbortSignal without explicit context threading.
+      const scope = { loaders: ctx.loaders as RequestLoaders, signal, perRequest: stats };
+      setExecuteFn(((execArgs: any) =>
+        runWithRequestScope(scope, () => (executeFn as any)(execArgs))) as any);
     },
   };
-}
+}

package/core/RequestLoaders.ts

@@ -2,10 +2,12 @@ import DataLoader from 'dataloader';
 import { Entity } from './Entity';
 import db from '../database';
 import { inList } from '../database/sqlHelpers';
+import { timedUnsafe, incrementDataLoaderCall, type PerRequestCounters } from '../database/instrumentedDb';
 import {logger as MainLogger} from './Logger';
 const logger = MainLogger.child({ module: 'RequestLoaders' });
 import { getMetadataStorage } from './metadata';
 import type { CacheManager } from './cache/CacheManager';
+import { COMPONENT_TOMBSTONE } from './cache/CacheManager';
 
 export type ComponentData = {
   id: string;  // Component ID for updates
@@ -21,10 +23,17 @@ export type RequestLoaders = {
   entityById: DataLoader<string, Entity | null>;
   componentsByEntityType: DataLoader<{ entityId: string; typeId: string }, ComponentData | null>;
   relationsByEntityField: DataLoader<{ entityId: string; relationField: string; relatedType: string; foreignKey?: string }, Entity[]>;
+  relationsByComponentFk: DataLoader<{ entityId: string; componentTypeId: string; foreignKeyField: string }, Entity[]>;
 };
 
-export function createRequestLoaders(db: any, cacheManager?: CacheManager): RequestLoaders {
+export function createRequestLoaders(
+  db: any,
+  cacheManager?: CacheManager,
+  signal?: AbortSignal,
+  perRequest?: PerRequestCounters,
+): RequestLoaders {
   const entityById = new DataLoader<string, Entity | null>(async (ids: readonly string[]) => {
+    incrementDataLoaderCall('entity', perRequest);
     const startTime = Date.now();
     try {
       // Filter out empty/invalid IDs to prevent PostgreSQL UUID parsing errors
@@ -44,12 +53,12 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
       
       if (missingIds.length > 0) {
         const idList = inList(missingIds, 1);
-        const rows = await db.unsafe(`
+        const rows = await timedUnsafe<any[]>(db, `
           SELECT id
           FROM entities
           WHERE id IN ${idList.sql}
             AND deleted_at IS NULL
-        `, idList.params);
+        `, idList.params, signal, perRequest);
         
         const entities = rows.map((row: any) => {
           const entity = new Entity(row.id);
@@ -87,8 +96,9 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
     maxBatchSize: 100 // Prevent extremely large batches
   });
 
-  const componentsByEntityType = new DataLoader<{ entityId: string; typeId: string }, ComponentData | null>(
+  const componentsByEntityType = new DataLoader<{ entityId: string; typeId: string }, ComponentData | null, string>(
     async (keys: readonly { entityId: string; typeId: string }[]) => {
+      incrementDataLoaderCall('component', perRequest);
       const startTime = Date.now();
       try {
         // Filter out keys with empty/invalid entity IDs to prevent PostgreSQL UUID parsing errors
@@ -99,16 +109,20 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
 
         const results = new Map<string, ComponentData | null>();
 
-        // Check cache first if cache manager is available
+        // Check cache first if cache manager is available. Tombstone hits
+        // are recorded as null in `results` so the DB-fetch step skips them.
         let cacheHits = 0;
         let cacheMisses = 0;
         if (cacheManager && cacheManager.getConfig().enabled && cacheManager.getConfig().component?.enabled) {
           try {
             const cachedComponents = await cacheManager.getComponents(validKeys);
-            cachedComponents.forEach((component, index) => {
-              if (component) {
-                const key = `${validKeys[index]!.entityId}-${validKeys[index]!.typeId}`;
-                results.set(key, component);
+            cachedComponents.forEach((value, index) => {
+              const key = `${validKeys[index]!.entityId}-${validKeys[index]!.typeId}`;
+              if (value === COMPONENT_TOMBSTONE) {
+                results.set(key, null);
+                cacheHits++;
+              } else if (value) {
+                results.set(key, value);
                 cacheHits++;
               } else {
                 cacheMisses++;
@@ -122,17 +136,16 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
           cacheMisses += validKeys.length;
         }
 
-        // Log cache hit/miss rates for monitoring
         if (validKeys.length > 0) {
           const hitRate = (cacheHits / validKeys.length) * 100;
-          logger.debug({ 
-            scope: 'cache', 
-            component: 'RequestLoaders', 
-            msg: 'Component cache statistics', 
-            total: validKeys.length, 
-            hits: cacheHits, 
-            misses: cacheMisses, 
-            hitRate: `${hitRate.toFixed(1)}%` 
+          logger.trace({
+            scope: 'cache',
+            component: 'RequestLoaders',
+            msg: 'Component cache statistics',
+            total: validKeys.length,
+            hits: cacheHits,
+            misses: cacheMisses,
+            hitRate: `${hitRate.toFixed(1)}%`,
           });
         }
 
@@ -144,13 +157,13 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
           const typeIds = [...new Set(missingKeys.map(k => k.typeId))];
           const entityIdList = inList(entityIds, 1);
           const typeIdList = inList(typeIds, entityIdList.newParamIndex);
-          const rows = await db.unsafe(`
+          const rows = await timedUnsafe<any[]>(db, `
             SELECT id, entity_id, type_id, data, created_at, updated_at, deleted_at
             FROM components
             WHERE entity_id IN ${entityIdList.sql}
               AND type_id IN ${typeIdList.sql}
               AND deleted_at IS NULL
-          `, [...entityIdList.params, ...typeIdList.params]);
+          `, [...entityIdList.params, ...typeIdList.params], signal, perRequest);
           
           const components: ComponentData[] = rows.map((row: any) => ({
             id: row.id,
@@ -162,10 +175,15 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
             deletedAt: row.deleted_at,
           }));
 
-          // Cache the loaded components if cache is enabled
+          // Cache the loaded components + tombstone any requested keys whose
+          // row was absent (single setMany — see CacheManager.setComponentsWriteThrough).
           if (cacheManager && cacheManager.getConfig().enabled && cacheManager.getConfig().component?.enabled) {
             try {
-              await cacheManager.setComponentsWriteThrough(components, cacheManager.getConfig().component!.ttl);
+              await cacheManager.setComponentsWriteThrough(
+                components,
+                missingKeys,
+                cacheManager.getConfig().component!.ttl,
+              );
             } catch (error: any) {
               logger.warn({ scope: 'cache', component: 'RequestLoaders', msg: 'Cache write failed for components', error });
             }
@@ -193,12 +211,17 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
       }
     },
     {
-      maxBatchSize: 100 // Prevent extremely large batches
+      maxBatchSize: 100, // Prevent extremely large batches
+      // Object keys default to identity (===) comparison, which never dedups
+      // distinct literals — collapse to a stable string so sibling resolvers
+      // requesting the same (entity, type) share one load within a request.
+      cacheKeyFn: (k: { entityId: string; typeId: string }) => `${k.entityId}\x00${k.typeId}`,
     }
   );
 
-  const relationsByEntityField = new DataLoader<{ entityId: string; relationField: string; relatedType: string; foreignKey?: string }, Entity[]>(
+  const relationsByEntityField = new DataLoader<{ entityId: string; relationField: string; relatedType: string; foreignKey?: string }, Entity[], string>(
     async (keys: readonly { entityId: string; relationField: string; relatedType: string; foreignKey?: string }[]) => {
+      incrementDataLoaderCall('relation', perRequest);
       const startTime = Date.now();
       try {
         // Filter valid keys
@@ -207,9 +230,35 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
           return keys.map(() => []);
         }
 
+        const resultMap = new Map<string, Entity[]>();
+
+        // Negative-cache lookup: skip DB for keys recorded as empty.
+        let keysToQuery = validKeys;
+        const relCacheEnabled = !!(cacheManager
+          && cacheManager.getConfig().enabled
+          && cacheManager.getConfig().relation?.negativeCacheEnabled);
+        if (relCacheEnabled) {
+          try {
+            const tombstones = await cacheManager!.getRelationsEmpty(validKeys);
+            const remaining: typeof validKeys = [];
+            tombstones.forEach((isEmpty, i) => {
+              const k = validKeys[i]!;
+              if (isEmpty) {
+                const mapKey = `${k.entityId}\x00${k.relationField}\x00${k.relatedType}`;
+                resultMap.set(mapKey, []);
+              } else {
+                remaining.push(k);
+              }
+            });
+            keysToQuery = remaining;
+          } catch (error) {
+            logger.warn({ scope: 'cache', component: 'RequestLoaders', msg: 'Cache read failed for relation tombstones', error });
+          }
+        }
+
         // Group keys by foreign key for efficient batching
-        const keysByForeignKey = new Map<string, typeof validKeys>();
-        for (const key of validKeys) {
+        const keysByForeignKey = new Map<string, typeof keysToQuery>();
+        for (const key of keysToQuery) {
           const fk = key.foreignKey || 'default';
           if (!keysByForeignKey.has(fk)) {
             keysByForeignKey.set(fk, []);
@@ -217,8 +266,6 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
           keysByForeignKey.get(fk)!.push(key);
         }
 
-        const resultMap = new Map<string, Entity[]>();
-
         // OPTIMIZED: Batch query for each foreign key type (instead of N separate queries)
         for (const [foreignKey, groupedKeys] of keysByForeignKey) {
           const entityIds = [...new Set(groupedKeys.map(k => k.entityId))];
@@ -240,19 +287,19 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
           logger.trace(`[RelationLoader] Batched query for ${groupedKeys.length} keys with foreign key ${foreignKey}`);
 
           // SINGLE BATCHED QUERY for all entities in this group
-          const rows = await db.unsafe(`
-            SELECT DISTINCT 
-              c.entity_id, 
-              c.data, 
+          const rows = await timedUnsafe<any[]>(db, `
+            SELECT DISTINCT
+              c.entity_id,
+              c.data,
               c.type_id,
               c.data->>'${foreignKeyField}' as fk_value,
               COALESCE(c.data->>'user_id', c.data->>'parent_id') as fallback_fk_value
             FROM components c
             INNER JOIN entities e ON c.entity_id = e.id
-            WHERE e.deleted_at IS NULL 
+            WHERE e.deleted_at IS NULL
               AND c.deleted_at IS NULL
               AND ${whereClause}
-          `, [entityIds]);
+          `, [entityIds], signal, perRequest);
 
           logger.trace(`[RelationLoader] Found ${rows.length} total components for ${entityIds.length} entities`);
 
@@ -281,6 +328,22 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
           }
         }
 
+        // Write tombstones for queried keys whose result was empty.
+        if (relCacheEnabled && keysToQuery.length > 0) {
+          const emptyKeys = keysToQuery.filter(k => {
+            const mapKey = `${k.entityId}\x00${k.relationField}\x00${k.relatedType}`;
+            const r = resultMap.get(mapKey);
+            return !r || r.length === 0;
+          });
+          if (emptyKeys.length > 0) {
+            try {
+              await cacheManager!.setRelationsEmpty(emptyKeys);
+            } catch (error) {
+              logger.warn({ scope: 'cache', component: 'RequestLoaders', msg: 'Cache write failed for relation tombstones', error });
+            }
+          }
+        }
+
         const duration = Date.now() - startTime;
         if (duration > 1000) {
           logger.warn(`Slow relationsByEntityField query: ${duration}ms for ${keys.length} keys`);
@@ -306,9 +369,97 @@ export function createRequestLoaders(db: any, cacheManager?: CacheManager): Requ
     },
     {
       // Add batch size limit to prevent extremely large queries
-      maxBatchSize: 50
+      maxBatchSize: 50,
+      // Stable string key (null-byte separated, matches the result-map key) so
+      // identical relation requests dedup within a request instead of being
+      // treated as distinct object identities.
+      cacheKeyFn: (k: { entityId: string; relationField: string; relatedType: string; foreignKey?: string }) =>
+        `${k.entityId}\x00${k.relationField}\x00${k.relatedType}\x00${k.foreignKey ?? ''}`,
+    }
+  );
+
+  // Type-scoped foreign-key relation loader. Backs @HasMany/@BelongsToMany
+  // array relations that declare a `foreignKey`. Previously those resolved one
+  // `new Query().exec()` PER PARENT ROW (a hard N+1). This batches all parents
+  // sharing a (componentType, fkField) into a single `data->>'fk' = ANY($2)`
+  // query. Unlike relationsByEntityField it pins `type_id`, preserving the
+  // exact semantics of the per-parent Query (which filtered by the specific
+  // component type) rather than matching any component sharing the field name.
+  const relationsByComponentFk = new DataLoader<{ entityId: string; componentTypeId: string; foreignKeyField: string }, Entity[], string>(
+    async (keys: readonly { entityId: string; componentTypeId: string; foreignKeyField: string }[]) => {
+      incrementDataLoaderCall('relation', perRequest);
+      const startTime = Date.now();
+      try {
+        const validKeys = keys.filter(k => k.entityId && typeof k.entityId === 'string' && k.entityId.trim() !== '');
+        if (validKeys.length === 0) return keys.map(() => []);
+
+        const resultMap = new Map<string, Entity[]>();
+
+        // Group by (componentTypeId, foreignKeyField) so each distinct relation
+        // shape is one batched query.
+        const groups = new Map<string, typeof validKeys>();
+        for (const key of validKeys) {
+          const gk = `${key.componentTypeId}\x00${key.foreignKeyField}`;
+          if (!groups.has(gk)) groups.set(gk, []);
+          groups.get(gk)!.push(key);
+        }
+
+        for (const [gk, groupedKeys] of groups) {
+          const sep = gk.indexOf('\x00');
+          const componentTypeId = gk.slice(0, sep);
+          const foreignKeyField = gk.slice(sep + 1);
+          const entityIds = [...new Set(groupedKeys.map(k => k.entityId))];
+          if (entityIds.length === 0) continue;
+
+          // type_id + entity ids are parameterized via inList (the proven
+          // pattern — passing a JS array to `= ANY($n)` is serialized as a
+          // comma-string by the Bun SQL driver and fails). foreignKeyField
+          // comes from trusted relation decorator metadata.
+          const entityList = inList(entityIds, 2);
+          const rows = await timedUnsafe<any[]>(db, `
+            SELECT c.entity_id, c.data->>'${foreignKeyField}' AS fk_value
+            FROM components c
+            INNER JOIN entities e ON c.entity_id = e.id
+            WHERE c.type_id = $1
+              AND c.deleted_at IS NULL
+              AND e.deleted_at IS NULL
+              AND c.data->>'${foreignKeyField}' IN ${entityList.sql}
+          `, [componentTypeId, ...entityList.params], signal, perRequest);
+
+          for (const key of groupedKeys) {
+            const relatedIds = [...new Set(
+              rows.filter((r: any) => r.fk_value === key.entityId).map((r: any) => r.entity_id)
+            )];
+            const entities = relatedIds.map(id => {
+              const e = new Entity(id as string);
+              e.setPersisted(true);
+              return e;
+            });
+            resultMap.set(`${key.entityId}\x00${componentTypeId}\x00${foreignKeyField}`, entities);
+          }
+        }
+
+        const duration = Date.now() - startTime;
+        if (duration > 1000) {
+          logger.warn(`Slow relationsByComponentFk query: ${duration}ms for ${keys.length} keys`);
+        }
+
+        return keys.map(k => {
+          if (!k.entityId || typeof k.entityId !== 'string' || k.entityId.trim() === '') return [];
+          return resultMap.get(`${k.entityId}\x00${k.componentTypeId}\x00${k.foreignKeyField}`) || [];
+        });
+      } catch (error) {
+        logger.error(`Error in relationsByComponentFk DataLoader:`);
+        logger.error(error);
+        return keys.map(() => []);
+      }
+    },
+    {
+      maxBatchSize: 50,
+      cacheKeyFn: (k: { entityId: string; componentTypeId: string; foreignKeyField: string }) =>
+        `${k.entityId}\x00${k.componentTypeId}\x00${k.foreignKeyField}`,
     }
   );
 
-  return { entityById, componentsByEntityType, relationsByEntityField };
+  return { entityById, componentsByEntityType, relationsByEntityField, relationsByComponentFk };
 }