bunsane 0.1.4 → 0.2.0

package/core/EntityHookManager.ts

@@ -1,5 +1,5 @@
 import type { Entity } from "./Entity";
-import type { BaseComponent } from "./Components";
+import { type BaseComponent } from "./components";
 import ArcheType from "./ArcheType";
 import {
     EntityLifecycleEvent,

package/core/EntityInterface.ts

@@ -1,4 +1,6 @@
+import type { SQL } from "bun";
+
 export interface IEntity {
-    doSave(): Promise<boolean>;
+    save(trx?: SQL): Promise<boolean>;
     doDelete(force?: boolean): Promise<boolean>;
 }

package/core/EntityManager.ts

@@ -15,18 +15,6 @@ class EntityManager {
         });
     }
 
-    public saveEntity(entity: IEntity) {
-        return new Promise<boolean>(async resolve => {
-            if(!this.dbReady) {
-                this.entityQueue.push(entity);
-                return resolve(true);
-            } else {
-                const result = await entity.doSave();
-                resolve(result);
-            }
-        })
-    }
-
     public deleteEntity(entity: IEntity, force: boolean = false) {
         return new Promise<boolean>(async resolve => {
             if(!this.dbReady) {
@@ -40,7 +28,7 @@ class EntityManager {
     private async savePendingEntities() {
         const promiseWait = [];
         for(const entity of this.entityQueue) {
-           promiseWait.push(entity.doSave()); 
+           promiseWait.push(entity.save()); 
         }
         return await Promise.all(promiseWait);
     }

package/core/ErrorHandler.ts

@@ -37,12 +37,18 @@ export function handleGraphQLError(err: any): never {
     if (err instanceof z.ZodError) {
         // Convert Zod errors to user-friendly messages
         const userFriendlyErrors = err.issues.map((issue: any) => {
+            // Use custom Zod message if available, otherwise use mapped error
+            const customMessage = issue.message && issue.message !== 'Required' && issue.message !== 'Invalid' 
+                ? issue.message 
+                : null;
+            
             const errorCode = mapZodPathToErrorCode(issue.path);
             const errorInfo = getErrorMessage(errorCode);
+            
             return {
                 field: issue.path.join('.'),
-                message: errorInfo.userMessage,
-                suggestion: errorInfo.suggestion,
+                message: customMessage || errorInfo.userMessage,
+                suggestion: customMessage ? undefined : errorInfo.suggestion,
                 code: errorCode
             };
         });

package/core/Logger.ts

@@ -3,6 +3,15 @@ import pino from "pino";
 const usePretty = process.env.LOG_PRETTY === 'true';
 export const logger = pino({
     level: process.env.LOG_LEVEL || 'info',
+    redact: {
+        paths: [
+            'password', 'secret', 'token', 'authorization',
+            'config.password', '*.password', '*.secret', '*.token',
+            '*.accessKeyId', '*.secretAccessKey', '*.sessionToken',
+            'accessKeyId', 'secretAccessKey', 'sessionToken',
+        ],
+        censor: '[REDACTED]',
+    },
     ...(usePretty && {
         transport: {
             target: 'pino-pretty',

package/core/Middleware.ts

@@ -0,0 +1,34 @@
+import { logger as MainLogger } from './Logger';
+const logger = MainLogger.child({ scope: 'Middleware' });
+
+export type MiddlewareNext = () => Promise<Response>;
+export type Middleware = (req: Request, next: MiddlewareNext) => Promise<Response>;
+
+/**
+ * Composes an array of middleware into a single handler function.
+ * Each middleware wraps the next, forming an onion-style execution chain.
+ */
+export function composeMiddleware(
+    middlewares: Middleware[],
+    finalHandler: (req: Request) => Promise<Response>,
+): (req: Request) => Promise<Response> {
+    return (req: Request) => {
+        let index = -1;
+
+        function dispatch(i: number): Promise<Response> {
+            if (i <= index) {
+                return Promise.reject(new Error('next() called multiple times'));
+            }
+            index = i;
+
+            if (i >= middlewares.length) {
+                return finalHandler(req);
+            }
+
+            const middleware = middlewares[i]!;
+            return middleware(req, () => dispatch(i + 1));
+        }
+
+        return dispatch(0);
+    };
+}

package/core/RequestContext.ts

@@ -2,12 +2,14 @@ import type { Plugin } from 'graphql-yoga';
 import { createRequestLoaders } from './RequestLoaders';
 import type { RequestLoaders } from './RequestLoaders';
 import db from '../database';
+import { CacheManager } from './cache/CacheManager';
 
 declare module 'graphql-yoga' {
   interface Context {
     locals: {
       loaders: RequestLoaders;
       requestId: string;
+      cacheManager: CacheManager;
     };
   }
 }
@@ -15,9 +17,11 @@ declare module 'graphql-yoga' {
 export function createRequestContextPlugin(): Plugin {
   return {
     onExecute: ({ args }) => {
+      const cacheManager = CacheManager.getInstance();
       (args as any).contextValue.locals = {
-        loaders: createRequestLoaders(db),
+        loaders: createRequestLoaders(db, cacheManager),
         requestId: crypto.randomUUID(),
+        cacheManager: cacheManager,
       };
     },
   };

package/core/RequestLoaders.ts

@@ -5,8 +5,11 @@ import { inList } from '../database/sqlHelpers';
 import {logger as MainLogger} from './Logger';
 const logger = MainLogger.child({ module: 'RequestLoaders' });
 import { getMetadataStorage } from './metadata';
+import type { CacheManager } from './cache/CacheManager';
 
 export type ComponentData = {
+  id: string;  // Component ID for updates
+  entityId: string; // Entity ID
   typeId: string;
   data: any;
   createdAt: Date;
@@ -20,75 +23,177 @@ export type RequestLoaders = {
   relationsByEntityField: DataLoader<{ entityId: string; relationField: string; relatedType: string; foreignKey?: string }, Entity[]>;
 };
 
-export function createRequestLoaders(db: any): RequestLoaders {
+export function createRequestLoaders(db: any, cacheManager?: CacheManager): RequestLoaders {
   const entityById = new DataLoader<string, Entity | null>(async (ids: readonly string[]) => {
     const startTime = Date.now();
     try {
-      const uniqueIds = [...new Set(ids)];
-      const idList = inList(uniqueIds, 1);
-      const rows = await db.unsafe(`
-        SELECT id
-        FROM entities
-        WHERE id IN ${idList.sql}
-          AND deleted_at IS NULL
-      `, idList.params);
-      const entities = rows.map((row: any) => {
-        const entity = new Entity(row.id);
-        entity.setPersisted(true);
-        return entity;
-      });
-      const map = new Map<string, Entity>();
-      entities.forEach((e: Entity) => map.set(e.id, e));
+      // Filter out empty/invalid IDs to prevent PostgreSQL UUID parsing errors
+      const validIds = ids.filter(id => id && typeof id === 'string' && id.trim() !== '');
+      if (validIds.length === 0) {
+        return ids.map(() => null);
+      }
+
+      const uniqueIds = [...new Set(validIds)];
+      const results = new Map<string, Entity | null>();
+
+      // Note: Entity cache now only tracks existence, not full entity data
+      // Full entities are always loaded from database for component access
+
+      // Find missing entities that weren't in cache
+      const missingIds = uniqueIds.filter(id => !results.has(id));
       
+      if (missingIds.length > 0) {
+        const idList = inList(missingIds, 1);
+        const rows = await db.unsafe(`
+          SELECT id
+          FROM entities
+          WHERE id IN ${idList.sql}
+            AND deleted_at IS NULL
+        `, idList.params);
+        
+        const entities = rows.map((row: any) => {
+          const entity = new Entity(row.id);
+          entity.setPersisted(true);
+          return entity;
+        });
+
+        // Cache the loaded entities if cache is enabled
+        if (cacheManager && cacheManager.getConfig().enabled && cacheManager.getConfig().entity?.enabled) {
+          try {
+            await cacheManager.setEntitiesWriteThrough(entities, cacheManager.getConfig().entity!.ttl);
+          } catch (error) {
+            logger.warn({ scope: 'cache', component: 'RequestLoaders', msg: 'Cache write failed for entities', error });
+          }
+        }
+
+        entities.forEach((e: Entity) => results.set(e.id, e));
+      }
+
       const duration = Date.now() - startTime;
       if (duration > 1000) { // Log slow queries
-        console.warn(`Slow entityById query: ${duration}ms for ${ids.length} entities`);
+        logger.warn(`Slow entityById query: ${duration}ms for ${ids.length} entities`);
       }
       
-      return ids.map(id => map.get(id) ?? null);
-    } catch (error) {
-      console.error(`Error in entityById DataLoader:`, error);
+      // Return null for invalid IDs
+      return ids.map(id => {
+        if (!id || typeof id !== 'string' || id.trim() === '') return null;
+        return results.get(id) ?? null;
+      });
+    } catch (error: any) {
+      logger.error(`Error in entityById DataLoader:`, error);
       throw error;
     }
+  }, {
+    maxBatchSize: 100 // Prevent extremely large batches
   });
 
   const componentsByEntityType = new DataLoader<{ entityId: string; typeId: string }, ComponentData | null>(
     async (keys: readonly { entityId: string; typeId: string }[]) => {
       const startTime = Date.now();
       try {
-        const entityIds = [...new Set(keys.map(k => k.entityId))];
-        const typeIds = [...new Set(keys.map(k => k.typeId))];
-        const entityIdList = inList(entityIds, 1);
-        const typeIdList = inList(typeIds, entityIdList.newParamIndex);
-        const rows = await db.unsafe(`
-          SELECT 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]);
-        const map = new Map<string, ComponentData>();
-        rows.forEach((row: any) => {
-          const key = `${row.entity_id}-${row.type_id}`;
-          map.set(key, {
+        // Filter out keys with empty/invalid entity IDs to prevent PostgreSQL UUID parsing errors
+        const validKeys = keys.filter(k => k.entityId && typeof k.entityId === 'string' && k.entityId.trim() !== '');
+        if (validKeys.length === 0) {
+          return keys.map(() => null);
+        }
+
+        const results = new Map<string, ComponentData | null>();
+
+        // Check cache first if cache manager is available
+        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);
+                cacheHits++;
+              } else {
+                cacheMisses++;
+              }
+            });
+          } catch (error: any) {
+            logger.warn({ scope: 'cache', component: 'RequestLoaders', msg: 'Cache read failed for components, falling back to database', error });
+            cacheMisses += validKeys.length;
+          }
+        } else {
+          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)}%` 
+          });
+        }
+
+        // Find missing components that weren't in cache
+        const missingKeys = validKeys.filter(k => !results.has(`${k.entityId}-${k.typeId}`));
+        
+        if (missingKeys.length > 0) {
+          const entityIds = [...new Set(missingKeys.map(k => k.entityId))];
+          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(`
+            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]);
+          
+          const components: ComponentData[] = rows.map((row: any) => ({
+            id: row.id,
+            entityId: row.entity_id,
             typeId: row.type_id,
             data: row.data,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
             deletedAt: row.deleted_at,
+          }));
+
+          // Cache the loaded components if cache is enabled
+          if (cacheManager && cacheManager.getConfig().enabled && cacheManager.getConfig().component?.enabled) {
+            try {
+              await cacheManager.setComponentsWriteThrough(components, cacheManager.getConfig().component!.ttl);
+            } catch (error: any) {
+              logger.warn({ scope: 'cache', component: 'RequestLoaders', msg: 'Cache write failed for components', error });
+            }
+          }
+
+          components.forEach((comp: ComponentData) => {
+            const key = `${comp.entityId}-${comp.typeId}`;
+            results.set(key, comp);
           });
-        });
-        
+        }
+
         const duration = Date.now() - startTime;
         if (duration > 1000) { // Log slow queries
-          console.warn(`Slow componentsByEntityType query: ${duration}ms for ${keys.length} keys`);
+          logger.warn(`Slow componentsByEntityType query: ${duration}ms for ${keys.length} keys`);
         }
         
-        return keys.map(k => map.get(`${k.entityId}-${k.typeId}`) ?? null);
-      } catch (error) {
-        console.error(`Error in componentsByEntityType DataLoader:`, error);
+        // Return null for keys with invalid entity IDs
+        return keys.map(k => {
+          if (!k.entityId || typeof k.entityId !== 'string' || k.entityId.trim() === '') return null;
+          return results.get(`${k.entityId}-${k.typeId}`) ?? null;
+        });
+      } catch (error: any) {
+        logger.error(`Error in componentsByEntityType DataLoader:`, error);
         throw error;
       }
+    },
+    {
+      maxBatchSize: 100 // Prevent extremely large batches
     }
   );
 
@@ -96,73 +201,98 @@ export function createRequestLoaders(db: any): RequestLoaders {
     async (keys: readonly { entityId: string; relationField: string; relatedType: string; foreignKey?: string }[]) => {
       const startTime = Date.now();
       try {
-        // Group keys by relation type for efficient querying
+        // Filter valid keys
+        const validKeys = keys.filter(k => k.entityId && typeof k.entityId === 'string' && k.entityId.trim() !== '');
+        if (validKeys.length === 0) {
+          return keys.map(() => []);
+        }
+
+        // Group keys by foreign key for efficient batching
+        const keysByForeignKey = new Map<string, typeof validKeys>();
+        for (const key of validKeys) {
+          const fk = key.foreignKey || 'default';
+          if (!keysByForeignKey.has(fk)) {
+            keysByForeignKey.set(fk, []);
+          }
+          keysByForeignKey.get(fk)!.push(key);
+        }
+
         const resultMap = new Map<string, Entity[]>();
-        
-        // For each key, find related entities based on foreign key relationships
-        for (const key of keys) {
-          let relatedEntities: 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))];
+          const entityIdList = inList(entityIds, 1);
+
+          let foreignKeyField: string;
+          let whereClause: string;
           
-          try {
-            logger.trace(`[RelationLoader] Looking for ${key.relatedType} entities with foreign key ${key.foreignKey || 'auto-detect'} pointing to ${key.entityId} for field ${key.relationField}`);
-
-            let whereClause: string;
-            if (key.foreignKey) {
-              // Use specific foreign key from relation metadata
-              whereClause = `(c.data->>'${key.foreignKey}' = $1)`;
-            } else {
-              // Fallback to common patterns for backward compatibility
-              // TODO: Remove this fallback in future versions
-              whereClause = `(
-                (c.data->>'user_id' = $1) OR
-                (c.data->>'parent_id' = $1)
-              )`;
-            }
-            
-            // Look for entities that have components with foreign keys pointing to our entity
-            const rows = await db.unsafe(`
-              SELECT DISTINCT c.entity_id, c.data, c.type_id
-              FROM components c
-              INNER JOIN entities e ON c.entity_id = e.id
-              WHERE e.deleted_at IS NULL 
-                AND c.deleted_at IS NULL
-                AND ${whereClause}
-            `, [key.entityId]);
-
-            logger.trace(`[RelationLoader] Found ${rows.length} components with foreign keys pointing to ${key.entityId}`);
-            rows.forEach((row: any) => {
-              logger.trace(`[RelationLoader] Component ${row.type_id} on entity ${row.entity_id}:`, row.data);
-            });
-            
-            // Create Entity objects for each related entity
-            const entityIds = [...new Set(rows.map((row: any) => row.entity_id as string))];
-            relatedEntities = entityIds.map((id: string) => {
-              const entity = new Entity(id);
+          if (foreignKey !== 'default') {
+            // Use specific foreign key from relation metadata
+            foreignKeyField = foreignKey;
+            whereClause = `c.data->>'${foreignKey}' = ANY($1)`;
+          } else {
+            // Fallback for backward compatibility
+            foreignKeyField = 'user_id'; // Default field for result mapping
+            whereClause = `(c.data->>'user_id' = ANY($1) OR c.data->>'parent_id' = ANY($1))`;
+          }
+
+          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, 
+              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 
+              AND c.deleted_at IS NULL
+              AND ${whereClause}
+          `, [entityIds]);
+
+          logger.trace(`[RelationLoader] Found ${rows.length} total components for ${entityIds.length} entities`);
+
+          // Map results back to original keys
+          for (const key of groupedKeys) {
+            const relatedEntityIds = rows
+              .filter((row: any) => {
+                // Match by specific foreign key or fallback
+                const fkValue = foreignKey !== 'default' ? row.fk_value : row.fallback_fk_value;
+                return fkValue === key.entityId;
+              })
+              .map((row: any) => row.entity_id);
+
+            const uniqueEntityIds = [...new Set(relatedEntityIds)];
+            const entities = uniqueEntityIds.map(id => {
+              const entity = new Entity(id as string);
               entity.setPersisted(true);
               return entity;
             });
 
-            logger.trace(`[RelationLoader] Created ${relatedEntities.length} related entities for ${key.relationField}`);
-
-          } catch (queryError) {
-            logger.error(`Error querying relations for ${key.entityId}:`);
-            logger.error(queryError);
-            relatedEntities = [];
+            const mapKey = `${key.entityId}-${key.relationField}-${key.relatedType}`;
+            resultMap.set(mapKey, entities);
+            
+            logger.trace(`[RelationLoader] Mapped ${entities.length} entities for ${key.relationField} on ${key.entityId}`);
           }
-          
-          const mapKey = `${key.entityId}-${key.relationField}-${key.relatedType}`;
-          resultMap.set(mapKey, relatedEntities);
         }
-        
+
         const duration = Date.now() - startTime;
         if (duration > 1000) {
           logger.warn(`Slow relationsByEntityField query: ${duration}ms for ${keys.length} keys`);
+        } else {
+          logger.trace(`[RelationLoader] Batched query completed in ${duration}ms for ${keys.length} keys`);
         }
-        
+
         return keys.map(k => {
+          if (!k.entityId || typeof k.entityId !== 'string' || k.entityId.trim() === '') {
+            return [];
+          }
           const mapKey = `${k.entityId}-${k.relationField}-${k.relatedType}`;
           const result = resultMap.get(mapKey) || [];
-          logger.trace(`[RelationLoader] Returning ${result.length} entities for ${k.relationField} on ${k.entityId}`);
           return result;
         });
       } catch (error) {
@@ -171,6 +301,10 @@ export function createRequestLoaders(db: any): RequestLoaders {
         // Return empty arrays for all keys on error
         return keys.map(() => []);
       }
+    },
+    {
+      // Add batch size limit to prevent extremely large queries
+      maxBatchSize: 50
     }
   );