bunsane 0.1.0 → 0.1.1

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,7 +6,9 @@ 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;
@@ -23,7 +25,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 +38,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 +60,59 @@ 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)
+     */
+    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) {
+            // 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 +128,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,16 +148,23 @@ export class Entity {
         }
     }
 
+    @timed("Entity.save")
     public save() {
         return EntityManager.saveEntity(this);
     }
 
+    
+
     public doSave() {
         return new Promise<boolean>(async resolve => {
             if(!this._dirty) {
                 console.log("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`;
@@ -122,19 +175,70 @@ export class Entity {
                     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 +247,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 +297,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);
+}