bunsane 0.1.0 → 0.1.2

package/core/BatchLoader.ts

@@ -0,0 +1,100 @@
+import { Entity } from "core/Entity";
+import { BaseComponent } from "core/Components";
+import { timed } from "./Decorators";
+import db from "../database";
+import { sql } from "bun";
+
+// Phase 2A: Memory Pooling for Entity Objects
+class EntityPool {
+    private static instance: EntityPool;
+    private pool: Map<string, Entity[]> = new Map();
+    private maxPoolSize = 1000;
+
+    static getInstance(): EntityPool {
+        if (!EntityPool.instance) {
+            EntityPool.instance = new EntityPool();
+        }
+        return EntityPool.instance;
+    }
+
+    get(entityId: string): Entity | null {
+        const entities = this.pool.get(entityId);
+        if (entities && entities.length > 0) {
+            return entities.pop()!;
+        }
+        return null;
+    }
+
+    put(entity: Entity): void {
+        const entityId = entity.id;
+        let entities = this.pool.get(entityId);
+        if (!entities) {
+            entities = [];
+            this.pool.set(entityId, entities);
+        }
+        if (entities.length < this.maxPoolSize) {
+            entities.push(entity);
+        }
+    }
+
+    clear(): void {
+        this.pool.clear();
+    }
+}
+
+export class BatchLoader {
+    private static entityPool = EntityPool.getInstance();
+
+    @timed("BatchLoader.loadRelatedEntities")
+    static async loadRelatedEntities<C extends BaseComponent & { value: string }>(
+        entities: Entity[],
+        component: new () => C,
+        loader: (ids: string[]) => Promise<Entity[]>
+    ): Promise<Map<string, Entity>> {
+        const ids: string[] = [];
+        for (const entity of entities) {
+            const data = await entity.get(component) as any;
+            if (data?.value) {
+                ids.push(data.value);
+            }
+        }
+        const uniqueIds = [...new Set(ids)];
+        const relatedEntities = await loader(uniqueIds);
+        const map = new Map<string, Entity>();
+        for (const related of relatedEntities) {
+            map.set(related.id, related);
+        }
+        return map;
+    }
+
+    @timed("BatchLoader.loadRelatedEntitiesBatched")
+    static async loadRelatedEntitiesBatched<C extends BaseComponent>(
+        entities: Entity[],
+        component: new () => C,
+        loader: (ids: string[]) => Promise<Entity[]>
+    ): Promise<Map<string, Entity>> {
+        if (entities.length === 0) return new Map();
+
+        const comp = new component();
+        const typeId = comp.getTypeID();
+        const parentIds = entities.map(e => e.id);
+
+        const rows = await db`
+            SELECT c.entity_id, (c.data->>'value') AS related_id
+            FROM components c
+            WHERE c.entity_id IN ${sql(parentIds)}
+              AND c.type_id = ${typeId}
+              AND c.deleted_at IS NULL
+        `;
+
+        const uniqueIds = [...new Set(rows.map((r: any) => r.related_id).filter(Boolean))] as string[];
+        if (uniqueIds.length === 0) return new Map();
+
+        const relatedEntities = await loader(uniqueIds);
+        const map = new Map<string, Entity>();
+        for (const related of relatedEntities) {
+            map.set(related.id, related);
+        }
+        return map;
+    }
+}

package/core/ComponentRegistry.ts

@@ -1,6 +1,6 @@
 import { generateTypeId, type BaseComponent } from "./Components";
 import ApplicationLifecycle, { ApplicationPhase } from "./ApplicationLifecycle";
-import { CreateComponentPartitionTable } from "database/DatabaseHelper";
+import { CreateComponentPartitionTable, UpdateComponentIndexes } from "database/DatabaseHelper";
 import { GetSchema } from "database/DatabaseHelper";
 import { logger as MainLogger } from "./Logger";
 const logger = MainLogger.child({ scope: "ComponentRegistry" });
@@ -94,13 +94,14 @@ class ComponentRegistry {
         return new Promise<boolean>(async resolve => {
             const partitionTableName = `components_${this.sluggifyName(name)}`;
             await this.populateCurrentTables();
+            const instance = new ctor();
+            const indexedProps = instance.indexedProperties();
             if (!this.currentTables.includes(partitionTableName)) {
                 logger.trace(`Partition table ${partitionTableName} does not exist. Creating... name: ${name}, typeId: ${typeid}`);
-                const instance = new ctor();
-                const indexedProps = instance.indexedProperties();
                 await CreateComponentPartitionTable(name, typeid, indexedProps);
                 await this.populateCurrentTables();
             }
+            await UpdateComponentIndexes(partitionTableName, indexedProps);
             this.componentsMap.set(name, typeid);
             this.typeIdToCtor.set(typeid, ctor);
             resolve(true);

package/core/Components.ts

@@ -45,7 +45,7 @@ export class BaseComponent {
 
     properties(): string[] {
         return Object.keys(this).filter(prop => {
-            const meta = Reflect.getMetadata("compData", this, prop);
+            const meta = Reflect.getMetadata("compData", Object.getPrototypeOf(this), prop);
             return meta && meta.isData;
         });
     }
@@ -113,7 +113,7 @@ export class BaseComponent {
 
     indexedProperties(): string[] {
         return Object.keys(this).filter(prop => {
-            const meta = Reflect.getMetadata("compData", this, prop);
+            const meta = Reflect.getMetadata("compData", Object.getPrototypeOf(this), prop);
             return meta && meta.isData && meta.indexed;
         });
     }

package/core/Decorators.ts

@@ -1,3 +1,4 @@
+import { logger } from "./Logger";
 export function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
   const originalMethod = descriptor.value;
 
@@ -7,14 +8,20 @@ export function log(target: any, propertyKey: string, descriptor: PropertyDescri
   };
 }
 
-export function timed(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-  const originalMethod = descriptor.value;
+export function timed(hint?: string) {
+  return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
 
-  descriptor.value = async function(...args: any[]) {
-    const start = performance.now();
-    const result = await originalMethod.apply(this, args);
-    const end = performance.now();
-    console.log(`Execution time for ${propertyKey}: ${end - start} ms`);
-    return result;
+    descriptor.value = async function(...args: any[]) {
+      if(process.env.NODE_ENV !== 'production') {
+        const start = performance.now();
+        const result = await originalMethod.apply(this, args);
+        const end = performance.now();
+        logger.trace(`Execution time for ${propertyKey}${hint ? ` (${hint})` : ''}: ${end - start} ms`);
+        return result;
+      } else {
+        return await originalMethod.apply(this, args);
+      }
+    };
   };
 }

package/core/Entity.ts

@@ -6,12 +6,15 @@ import ComponentRegistry from "./ComponentRegistry";
 import { uuidv7 } from "utils/uuid";
 import { sql } from "bun";
 import Query from "./Query";
-
+import { timed } from "./Decorators";
+import EntityHookManager from "./EntityHookManager";
+import { EntityCreatedEvent, EntityUpdatedEvent, EntityDeletedEvent, ComponentAddedEvent, ComponentUpdatedEvent, ComponentRemovedEvent } from "./events/EntityLifecycleEvents";
 
 export class Entity {
     id: string;
     public _persisted: boolean = false;
     private components: Map<string, BaseComponent> = new Map<string, BaseComponent>();
+    private removedComponents: Set<string> = new Set<string>();
     protected _dirty: boolean = false;
 
     constructor(id?: string) {
@@ -23,7 +26,7 @@ export class Entity {
         return new Entity();
     }
 
-    private addComponent(component: BaseComponent): Entity {
+    protected addComponent(component: BaseComponent): Entity {
         this.components.set(component.getTypeID(), component);
         return this;
     }
@@ -36,10 +39,19 @@ export class Entity {
      * Adds a new component to the entity.
      * Use like: entity.add(Component, { value: "Test" })
      */
-    public add<T extends BaseComponent>(ctor: new (...args: any[]) => T, data: ComponentDataType<T>): this {
+    public add<T extends BaseComponent>(ctor: new (...args: any[]) => T, data: Partial<ComponentDataType<T>>): this {
         const instance = new ctor();
         Object.assign(instance, data);
         this.addComponent(instance);
+        
+        // Fire component added event
+        try {
+            EntityHookManager.executeHooks(new ComponentAddedEvent(this, instance));
+        } catch (error) {
+            logger.error(`Error firing component added hook for ${instance.getTypeID()}: ${error}`);
+            // Don't fail the add operation if hooks fail
+        }
+        
         return this;
     }
 
@@ -49,24 +61,65 @@ export class Entity {
      * If it doesn't exist, it adds a new component.
      * Use like: entity.set(Component, { value: "Test" })
      */
-    public async set<T extends BaseComponent>(ctor: new (...args: any[]) => T, data: Record<string, any>): Promise<this> {
+    public async set<T extends BaseComponent>(ctor: new (...args: any[]) => T, data: Partial<ComponentDataType<T>>): Promise<this> {
         await this.get(ctor);
         
         const component = Array.from(this.components.values()).find(comp => comp instanceof ctor) as T;
         if (component) {
-            console.log("Updating Existing Component", component.getTypeID())
+            // Store old data for the update event
+            const oldData = { ...component };
+            
             // Update existing component
             Object.assign(component, data);
             component.setDirty(true);
             this._dirty = true;
+            
+            // Fire component updated event
+            try {
+                EntityHookManager.executeHooks(new ComponentUpdatedEvent(this, component, oldData, component));
+            } catch (error) {
+                logger.error(`Error firing component updated hook for ${component.getTypeID()}: ${error}`);
+                // Don't fail the set operation if hooks fail
+            }
         } else {
             // Add new component
-            console.log("Adding New Component")
-            this.add(ctor, data as any);
-            this._dirty = true;
+            this.add(ctor, data);
+            // Note: add() already fires ComponentAddedEvent, so we don't need to fire it again
         }
         return this;
     }
+
+    /**
+     * Removes a component from the entity.
+     * Use like: entity.remove(Component)
+     * WARNING: This will delete the component from the database upon saving the entity.
+     * If you want to keep the component in the database but just remove it from the entity instance,
+     * consider implementing a different method.
+     */
+    public remove<T extends BaseComponent>(ctor: new (...args: any[]) => T): boolean {
+        const component = Array.from(this.components.values()).find(comp => comp instanceof ctor) as T;
+        
+        if (component) {
+            // Track the component type for database deletion
+            this.removedComponents.add(component.getTypeID());
+            
+            // Remove the component from the map
+            this.components.delete(component.getTypeID());
+            this._dirty = true;
+            
+            // Fire component removed event
+            try {
+                EntityHookManager.executeHooks(new ComponentRemovedEvent(this, component));
+            } catch (error) {
+                logger.error(`Error firing component removed hook for ${component.getTypeID()}: ${error}`);
+                // Don't fail the remove operation if hooks fail
+            }
+            
+            return true;
+        }
+        
+        return false;
+    }
     /**
      * Get component from entities. If entity is populated in query the component will get within the entitiy
      * If not it will fetch from database
@@ -82,7 +135,7 @@ export class Entity {
             const temp = new ctor();
             const typeId = temp.getTypeID();
             try {
-                const rows = await db`SELECT id, data FROM components WHERE entity_id = ${this.id} AND type_id = ${typeId}`;
+                const rows = await db`SELECT id, data FROM components WHERE entity_id = ${this.id} AND type_id = ${typeId} AND deleted_at IS NULL`;
                 if (rows.length > 0) {
                     const row = rows[0];
                     const comp = new ctor();
@@ -102,39 +155,122 @@ export class Entity {
         }
     }
 
+    @timed("Entity.save")
     public save() {
-        return EntityManager.saveEntity(this);
+        return new Promise<boolean>((resolve, reject) => {
+            // Add timeout to prevent hanging
+            const timeout = setTimeout(() => {
+                logger.error(`Entity save timeout for entity ${this.id}`);
+                reject(new Error(`Entity save timeout for entity ${this.id}`));
+            }, 30000); // 30 second timeout
+
+            this.doSave()
+                .then(result => {
+                    clearTimeout(timeout);
+                    resolve(result);
+                })
+                .catch(error => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+        });
     }
 
+    
+
     public doSave() {
         return new Promise<boolean>(async resolve => {
             if(!this._dirty) {
-                console.log("Entity is not dirty, no need to save.");
+                logger.trace("Entity is not dirty, no need to save.");
                 return resolve(true); 
             }
+
+            const wasNew = !this._persisted;
+            const changedComponents = this.getDirtyComponents();
+
             await db.transaction(async (trx) => {
                 if(!this._persisted) {
                     await trx`INSERT INTO entities (id) VALUES (${this.id}) ON CONFLICT DO NOTHING`;
                     this._persisted = true;
                 }
+                
+                // Delete removed components from database
+                if (this.removedComponents.size > 0) {
+                    const typeIds = Array.from(this.removedComponents);
+                    await trx`DELETE FROM components WHERE entity_id = ${this.id} AND type_id IN ${sql(typeIds)}`;
+                    await trx`DELETE FROM entity_components WHERE entity_id = ${this.id} AND type_id IN ${sql(typeIds)}`;
+                    this.removedComponents.clear();
+                }
+                
                 if(this.components.size === 0) {
                     logger.trace(`No components to save for entity ${this.id}`);
                     return;
                 }
                 const waitable = [];
-                    
                 for(const comp of this.components.values()) {
                     waitable.push(comp.save(trx, this.id));
                 }
-
                 await Promise.all(waitable);
             });
+
             this._dirty = false;
+
+            // Fire lifecycle events after successful save
+            try {
+                if (wasNew) {
+                    await EntityHookManager.executeHooks(new EntityCreatedEvent(this));
+                } else if (changedComponents.length > 0) {
+                    await EntityHookManager.executeHooks(new EntityUpdatedEvent(this, changedComponents));
+                }
+            } catch (error) {
+                logger.error(`Error firing lifecycle hooks for entity ${this.id}: ${error}`);
+                // Don't fail the save operation if hooks fail
+            }
+
             resolve(true);
         })
         
     }
 
+    public delete(force: boolean = false) {
+        return EntityManager.deleteEntity(this, force);
+    }
+
+    public doDelete(force: boolean = false) {
+        return new Promise<boolean>(async resolve => {
+            if(!this._persisted) {
+                console.log("Entity is not persisted, cannot delete.");
+                return resolve(false); 
+            }
+            try {
+                await db.transaction(async (trx) => {
+                    if(force) {
+                        await trx`DELETE FROM entity_components WHERE entity_id = ${this.id}`;
+                        await trx`DELETE FROM components WHERE entity_id = ${this.id}`;
+                        await trx`DELETE FROM entities WHERE id = ${this.id}`;
+                    } else {
+                        await trx`UPDATE entities SET deleted_at = CURRENT_TIMESTAMP WHERE id = ${this.id} AND deleted_at IS NULL`;
+                        await trx`UPDATE entity_components SET deleted_at = CURRENT_TIMESTAMP WHERE entity_id = ${this.id} AND deleted_at IS NULL`;
+                        await trx`UPDATE components SET deleted_at = CURRENT_TIMESTAMP WHERE entity_id = ${this.id} AND deleted_at IS NULL`;
+                    }
+                });
+
+                // Fire lifecycle event after successful deletion
+                try {
+                    await EntityHookManager.executeHooks(new EntityDeletedEvent(this, !force));
+                } catch (error) {
+                    logger.error(`Error firing delete lifecycle hook for entity ${this.id}: ${error}`);
+                    // Don't fail the delete operation if hooks fail
+                }
+
+                resolve(true);
+            } catch (error) {
+                logger.error(`Failed to delete entity: ${error}`);
+                resolve(false);
+            }
+        })
+    }
+
     public setPersisted(persisted: boolean) {
         this._persisted = persisted;
     }
@@ -143,13 +279,28 @@ export class Entity {
         this._dirty = dirty;
     }
 
+    /**
+     * Get list of component type IDs that are dirty
+     */
+    private getDirtyComponents(): string[] {
+        const dirtyComponents: string[] = [];
+        for (const component of this.components.values()) {
+            if ((component as any)._dirty) {
+                dirtyComponents.push(component.getTypeID());
+            }
+        }
+        return dirtyComponents;
+    }
+
+
+    @timed("Entity.LoadMultiple")
     public static async LoadMultiple(ids: string[]): Promise<Entity[]> {
         if (ids.length === 0) return [];
 
         const components = await db`
             SELECT c.id, c.entity_id, c.type_id, c.data
             FROM components c
-            WHERE c.entity_id IN ${sql(ids)}
+            WHERE c.entity_id IN ${sql(ids)} AND c.deleted_at IS NULL
         `;
 
         const entitiesMap = new Map<string, Entity>();
@@ -178,6 +329,34 @@ export class Entity {
         return Array.from(entitiesMap.values());
     }
 
+    public static async LoadComponents(entities: Entity[], componentIds: string[]): Promise<void> {
+        if (entities.length === 0 || componentIds.length === 0) return;
+
+        const entityIds = entities.map(e => e.id);
+
+        const components = await db`
+            SELECT c.id, c.entity_id, c.type_id, c.data
+            FROM components c
+            WHERE c.entity_id IN ${sql(entityIds)} AND c.type_id IN ${sql(componentIds)} AND c.deleted_at IS NULL
+        `;
+
+        for (const row of components) {
+            const { id, entity_id, type_id, data } = row;
+            const entity = entities.find(e => e.id === entity_id);
+            if (entity) {
+                const ctor = ComponentRegistry.getConstructor(type_id);
+                if (ctor) {
+                    const comp = new ctor();
+                    Object.assign(comp, data);
+                    comp.id = id;
+                    comp.setPersisted(true);
+                    comp.setDirty(false);
+                    entity.addComponent(comp);
+                }
+            }
+        }
+    }
+
     public static async FindById(id: string): Promise<Entity | null> {
         const entities = await new Query().findById(id).populate().exec()
         if(entities.length === 1) {

package/core/EntityCache.ts

@@ -0,0 +1,15 @@
+import type { RequestLoaders, ComponentData } from './RequestLoaders';
+import { Entity } from './Entity';
+
+export async function getEntityById(ctx: { locals: { loaders: RequestLoaders } }, id: string): Promise<Entity | null> {
+  return ctx.locals.loaders.entityById.load(id);
+}
+
+export async function getComponent(ctx: { locals: { loaders: RequestLoaders } }, entityId: string, typeId: number): Promise<ComponentData | null> {
+  return ctx.locals.loaders.componentsByEntityType.load({ entityId, typeId });
+}
+
+export async function preloadComponents(ctx: { locals: { loaders: RequestLoaders } }, entityIds: string[], typeId: number): Promise<void> {
+  const keys = entityIds.map(entityId => ({ entityId, typeId }));
+  await ctx.locals.loaders.componentsByEntityType.loadMany(keys);
+}