bunsane 0.1.2 → 0.1.4

package/core/ComponentRegistry.ts

@@ -1,33 +1,34 @@
 import { generateTypeId, type BaseComponent } from "./Components";
 import ApplicationLifecycle, { ApplicationPhase } from "./ApplicationLifecycle";
-import { CreateComponentPartitionTable, UpdateComponentIndexes } from "database/DatabaseHelper";
+import { CreateComponentPartitionTable, GenerateTableName, UpdateComponentIndexes } from "database/DatabaseHelper";
 import { GetSchema } from "database/DatabaseHelper";
 import { logger as MainLogger } from "./Logger";
+import { getMetadataStorage } from "./metadata";
+import { registerDecoratedHooks } from "./decorators/EntityHooks";
+import ServiceRegistry from "service/ServiceRegistry";
 const logger = MainLogger.child({ scope: "ComponentRegistry" });
 
+type ComponentConstructor = new () => BaseComponent;
+
+export type { ComponentConstructor };
+
 class ComponentRegistry {
     static #instance: ComponentRegistry;
-    private componentQueue = new Map<string, new () => BaseComponent>();
+    private componentQueue = new Map<string, ComponentConstructor>();
     private currentTables: string[] = [];
     private componentsMap = new Map<string, string>();
-    private typeIdToCtor = new Map<string, new () => BaseComponent>();
+    private typeIdToCtor = new Map<string, ComponentConstructor>();
     private instantRegister: boolean = false;
+    private readinessPromises = new Map<string, Promise<void>>();
+    private readinessResolvers = new Map<string, () => void>();
+    private componentsRegistered: boolean = false;
 
     constructor() {
         
     }
 
     public init() {
-        ApplicationLifecycle.addPhaseListener(async (event) => {
-            if(event.detail === ApplicationPhase.DATABASE_READY) {
-                logger.trace("Registering Components...");
-                ApplicationLifecycle.setPhase(ApplicationPhase.COMPONENTS_REGISTERING);
-                logger.trace(`Total Components to register: ${this.componentQueue.size}`);
-                await this.populateCurrentTables();
-                await this.registerAllComponents();
-                this.instantRegister = true;
-            }
-        });
+        // Listener removed to make component registration sequential
     }
 
     public static get instance(): ComponentRegistry {
@@ -48,11 +49,14 @@ class ComponentRegistry {
 
     define(
         name: string,
-        ctor: new () => BaseComponent
+        ctor: ComponentConstructor
     ) {
         if(!this.instantRegister) {
             if(!this.componentQueue.has(name)) {
                 this.componentQueue.set(name, ctor);
+                this.readinessPromises.set(name, new Promise<void>(resolve => {
+                    this.readinessResolvers.set(name, resolve);
+                }));
                 return;
             }
         }
@@ -61,7 +65,10 @@ class ComponentRegistry {
                 logger.trace(`Component already registered: ${name}`);
                 return;
             }
-            this.register(name, generateTypeId(name), ctor);
+            this.register(name, generateTypeId(name), ctor).then(() => {
+                const resolve = this.readinessResolvers.get(name);
+                if(resolve) resolve();
+            });
         }
     }
 
@@ -73,6 +80,36 @@ class ComponentRegistry {
         return this.componentsMap.has(name);
     }
 
+    async getReadyPromise(name: string): Promise<void> {
+        if (this.isComponentReady(name)) {
+            return Promise.resolve();
+        }
+        
+        // Ensure components are registered before trying to find the component
+        await this.ensureComponentsRegistered();
+        
+        if (this.isComponentReady(name)) {
+            return Promise.resolve();
+        }
+        
+        const storage = getMetadataStorage();
+        const component = storage.components.find(c => c.name === name);
+        if (component) {
+            // Component exists in metadata but not registered yet, register it
+            return this.registerComponentFromMetadata(component);
+        }
+        // Check if component is in the queue (defined but not registered)
+        if (this.componentQueue.has(name)) {
+            const promise = this.readinessPromises.get(name);
+            if (promise) {
+                return promise;
+            }
+        }
+        // Component not found anywhere, try to register it dynamically
+        // This handles test components that are decorated but not imported in main app
+        return this.registerComponentDynamically(name);
+    }
+
     getComponentId(name: string) {
         return this.componentsMap.get(name);
     }
@@ -81,36 +118,142 @@ class ComponentRegistry {
         return this.typeIdToCtor.get(typeId);
     }
 
+    // TODO: OLD LOGIC Remove if not needed
+    // async registerAllComponents(): Promise<void> {
+    //     logger.trace(`Registering all components`);
+    //     for(const [name, ctor] of this.componentQueue) {
+    //         const typeId = generateTypeId(name);
+    //         await this.register(name, typeId, ctor);
+    //     }
+    //     ApplicationLifecycle.setPhase(ApplicationPhase.COMPONENTS_READY);
+    //     // Resolve all pending readiness promises
+    //     for(const [name] of this.componentQueue) {
+    //         const resolve = this.readinessResolvers.get(name);
+    //         if(resolve) resolve();
+    //     }
+    // }
+
     async registerAllComponents(): Promise<void> {
-        logger.trace(`Registering all components`);
-        for(const [name, ctor] of this.componentQueue) {
-            const typeId = generateTypeId(name);
-            await this.register(name, typeId, ctor);
+        if (this.componentsRegistered) {
+            return; // Already registered
         }
+        
+        logger.trace("Registering Components...");
+        ApplicationLifecycle.setPhase(ApplicationPhase.COMPONENTS_REGISTERING);
+        
+        await this.populateCurrentTables();
+        const storage = getMetadataStorage();
+        const promises = storage.components.map(async metadata => {
+            const { name, target: ctor, typeId } = metadata;
+            if(this.componentsMap.has(name)) {
+                logger.trace(`Component already registered: ${name}`);
+                return;
+            }
+            this.readinessPromises.set(name, new Promise<void>(resolve => {
+                this.readinessResolvers.set(name, resolve);
+            }));
+            await this.register(name, typeId, ctor as ComponentConstructor);
+            const resolve = this.readinessResolvers.get(name);
+            if(resolve) resolve();
+        });
+        await Promise.all(promises);
+        this.componentsRegistered = true;
+        
+        // Handle component-related setup that was previously in App.init()
+        await this.setupComponentFeatures();
+        
         ApplicationLifecycle.setPhase(ApplicationPhase.COMPONENTS_READY);
     }
 
-    register(name: string, typeid: string, ctor: new () => BaseComponent) {
+    register(name: string, typeid: string, ctor: ComponentConstructor) {
         return new Promise<boolean>(async resolve => {
-            const partitionTableName = `components_${this.sluggifyName(name)}`;
-            await this.populateCurrentTables();
-            const instance = new ctor();
-            const indexedProps = instance.indexedProperties();
+            const partitionTableName = GenerateTableName(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}`);
-                await CreateComponentPartitionTable(name, typeid, indexedProps);
-                await this.populateCurrentTables();
+                // await CreateComponentPartitionTable(name, typeid, indexedProps); // TODO: OLD Logic with indexedProps, remove if not needed
+                await CreateComponentPartitionTable(name, typeid);
+                // await this.populateCurrentTables();
             }
-            await UpdateComponentIndexes(partitionTableName, indexedProps);
+            // await UpdateComponentIndexes(partitionTableName, indexedProps); // TODO: OLD Logic with indexedProps, remove if not needed
             this.componentsMap.set(name, typeid);
             this.typeIdToCtor.set(typeid, ctor);
             resolve(true);
         });
     }
 
+    private async registerComponentFromMetadata(component: any): Promise<void> {
+        const { name, target: ctor, typeId } = component;
+        if (this.componentsMap.has(name)) {
+            return; // Already registered
+        }
+        this.readinessPromises.set(name, new Promise<void>(resolve => {
+            this.readinessResolvers.set(name, resolve);
+        }));
+        await this.register(name, typeId, ctor as ComponentConstructor);
+        const resolve = this.readinessResolvers.get(name);
+        if (resolve) resolve();
+    }
+
+    private async registerComponentDynamically(name: string): Promise<void> {
+        // Try to find the component in global metadata storage
+        const storage = getMetadataStorage();
+        const component = storage.components.find(c => c.name === name);
+        if (component) {
+            return this.registerComponentFromMetadata(component);
+        }
+
+        // If still not found, this is an error - component was never decorated
+        throw new Error(`Component ${name} not found in metadata storage. Make sure it's decorated with @Component`);
+    }
+
+    getComponents() {
+        // returns array of { name, ctor }
+        const components: { name: string, ctor: ComponentConstructor }[] = [];
+        for (const [name, typeid] of this.componentsMap) {
+            const ctor = this.typeIdToCtor.get(typeid);
+            if(ctor) {
+                components.push({ name, ctor });
+            }
+        }
+        return components;
+    }
+
+    async ensureComponentsRegistered(): Promise<void> {
+        if (!this.componentsRegistered) {
+            // If components haven't been registered yet, register them now
+            // This handles cases where components are needed before DATABASE_READY phase
+            logger.trace("Ensuring components are registered...");
+            await this.registerAllComponents();
+        }
+    }
 
-    private sluggifyName(name: string) {
-        return name.toLowerCase().replace(/\s+/g, '_');
+    private async setupComponentFeatures(): Promise<void> {
+        const components = this.getComponents();
+        
+        // Update component indexes for components that have indexed properties
+        for(const {name, ctor} of components) {
+            const instance = new ctor();
+            if(instance.indexedProperties().length > 0) {
+                const table_name = GenerateTableName(name);
+                UpdateComponentIndexes(table_name, instance.indexedProperties());
+                logger.trace(`Updated indexes for component: ${name}`);
+            }
+        }
+
+        // Automatically register decorated hooks for all services
+        const services = ServiceRegistry.getServices();
+        for (const service of services) {
+            try {
+                registerDecoratedHooks(service);
+            } catch (error) {
+                logger.warn(`Failed to register hooks for service ${service.constructor.name}`);
+                logger.warn(error);
+            }
+        }
+        logger.info(`Registered hooks for ${services.length} services`);
     }
 }
 

package/core/Components.ts

@@ -3,16 +3,90 @@ import "reflect-metadata";
 import { logger as MainLogger } from "./Logger";
 import ComponentRegistry from "./ComponentRegistry";
 import { uuidv7 } from 'utils/uuid';
+import { getMetadataStorage } from './metadata';
 const logger = MainLogger.child({ scope: "Components" });
 
 export function generateTypeId(name: string): string {
   return createHash('sha256').update(name).digest('hex');
 }
 
+const primitiveTypes = [String, Number, Boolean, Symbol, BigInt];
+
+//TODO: Continue here
 export function CompData(options?: { indexed?: boolean }) {
-    return Reflect.metadata("compData", { isData: true, indexed: options?.indexed ?? false });
+    return (target: any, propertyKey: string) => {
+        const storage = getMetadataStorage();
+        const typeId = storage.getComponentId(target.constructor.name);
+        const propType = Reflect.getMetadata("design:type", target, propertyKey);
+        let isEnum = !!(Reflect.getMetadata("isEnum", propType));
+        if (propType.name === 'ServiceType') isEnum = true;
+        // console.log(`Property ${propertyKey} type:`, propType?.name);
+        // console.log(`Is Enum:`, isEnum);
+        let enumValues: string[] | undefined = undefined;
+        let enumKeys: string[] | undefined = undefined;
+        if(isEnum) {
+            const metaEnumValues = Reflect.getMetadata("__enumValues", propType);
+            const metaEnumKeys = Reflect.getMetadata("__enumKeys", propType);
+            
+            if (metaEnumValues && metaEnumKeys) {
+                enumValues = metaEnumValues;
+                enumKeys = metaEnumKeys;
+            } else {
+                const staticKeys = Object.getOwnPropertyNames(propType).filter(key => 
+                    key !== 'prototype' && 
+                    key !== 'length' && 
+                    key !== 'name' &&
+                    key !== 'isEnum' &&
+                    key !== '__enumValues' &&
+                    key !== '__enumKeys' &&
+                    typeof propType[key] !== 'function' &&
+                    typeof propType[key] !== 'boolean'
+                );
+                if (staticKeys.length > 0) {
+                    enumValues = staticKeys.map(key => propType[key]);
+                    enumKeys = staticKeys;
+                } else {
+                    // Fallback for numeric enums
+                    enumValues = Object.keys(propType).filter(key => !isNaN(Number(key))).map(key => propType[key]);
+                }
+            }
+            
+            if (propType.name === 'ServiceType' && (!enumValues || enumValues.length === 0)) {
+                enumValues = ["jek", "car", "food", "package"];
+                enumKeys = ["BIKE", "CAR", "FOOD", "PACKAGE"];
+            }
+
+        }
+        storage.collectComponentPropertyMetadata({
+            component_id: typeId,
+            propertyKey: propertyKey,
+            propertyType: propType,
+            indexed: options?.indexed ?? false,
+            isPrimitive: primitiveTypes.includes(propType),
+            isEnum: isEnum,
+            enumValues: enumValues,
+            enumKeys: enumKeys,
+        })
+        // Reflect.metadata("compData", { isData: true, indexed: options?.indexed ?? false })(target, propertyKey);
+    };
 }
 
+// TODO: Component Property Casting
+// export enum CompCastingType {
+//     STRING = "string",
+//     NUMBER = "number",
+//     BOOLEAN = "boolean",
+//     DATE = "date",
+// }
+// /**
+//  * Cast property to specific type when loading from database
+//  * @param type Casting type for the property
+//  * @returns 
+//  */
+// export function Cast(type: CompCastingType) {
+//     return Reflect.metadata("compCast", { type });
+// }
+
 // Type helper to extract only data properties (excludes methods and private properties)
 export type ComponentDataType<T extends BaseComponent> = {
     [K in keyof T as T[K] extends Function ? never : 
@@ -21,8 +95,17 @@ export type ComponentDataType<T extends BaseComponent> = {
                     K]: T[K];
 };
 
-export function Component(target: any) {
-    ComponentRegistry.define(target.name, target);
+export function Component<T extends new () => BaseComponent>(target: T): T {
+    const storage = getMetadataStorage();
+    const typeId = storage.getComponentId(target.name);
+    const properties = storage.getComponentProperties(typeId);
+    // console.log(`Component decorator applied to ${target.name} with typeId ${typeId} and properties:`, properties);
+    storage.collectComponentMetadata({
+        name: target.name,
+        typeId: typeId,
+        target: target,
+    });
+    // ComponentRegistry.define(target.name, target);
     return target;
 }
 
@@ -35,7 +118,8 @@ export class BaseComponent {
 
     constructor() {
         this._comp_name = this.constructor.name;
-        this._typeId = ComponentRegistry.getComponentId(this._comp_name) || generateTypeId(this._comp_name);
+        const storage = getMetadataStorage();
+        this._typeId = storage.getComponentId(this._comp_name);
         this._dirty = false;
     }
 
@@ -44,10 +128,15 @@ export class BaseComponent {
     }
 
     properties(): string[] {
-        return Object.keys(this).filter(prop => {
-            const meta = Reflect.getMetadata("compData", Object.getPrototypeOf(this), prop);
-            return meta && meta.isData;
-        });
+        const storage = getMetadataStorage();
+        const props = storage.componentProperties.get(this._typeId);
+        if(!props) return [];
+        return props.map(p => p.propertyKey);
+        //
+        // return Object.keys(this).filter(prop => {
+        //     const meta = Reflect.getMetadata("compData", Object.getPrototypeOf(this), prop);
+        //     return meta && meta.isData;
+        // });
     }
 
     /**
@@ -65,18 +154,7 @@ export class BaseComponent {
     async save(trx: Bun.SQL, entity_id: string) {
         logger.trace(`Saving component ${this._comp_name} for entity ${entity_id}`);
         logger.trace(`Checking is Component can be saved (is registered)`);
-        await new Promise(resolve => {
-            if(ComponentRegistry.isComponentReady(this._comp_name)) {
-                resolve(true);
-            } else {
-                const interval = setInterval(() => {
-                    if (ComponentRegistry.isComponentReady(this._comp_name)) {
-                        clearInterval(interval);
-                        resolve(true);
-                    }
-                }, 100);
-            }
-        });
+        await ComponentRegistry.getReadyPromise(this._comp_name);
         logger.trace(`Component Registered`);
         if(this._persisted) {
             await this.update(trx);
@@ -112,10 +190,10 @@ export class BaseComponent {
     }
 
     indexedProperties(): string[] {
-        return Object.keys(this).filter(prop => {
-            const meta = Reflect.getMetadata("compData", Object.getPrototypeOf(this), prop);
-            return meta && meta.isData && meta.indexed;
-        });
+        const storage = getMetadataStorage();
+        const props = storage.componentProperties.get(this._typeId);
+        if(!props) return [];
+        return props.filter(p => p.indexed).map(p => p.propertyKey);
     }
 }
 

package/core/Decorators.ts

@@ -3,7 +3,6 @@ export function log(target: any, propertyKey: string, descriptor: PropertyDescri
   const originalMethod = descriptor.value;
 
   descriptor.value = function(...args: any[]) {
-    console.log(`Calling ${propertyKey} with:`, args);
     return originalMethod.apply(this, args);
   };
 }

package/core/Entity.ts

@@ -5,12 +5,13 @@ import EntityManager from "./EntityManager";
 import ComponentRegistry from "./ComponentRegistry";
 import { uuidv7 } from "utils/uuid";
 import { sql } from "bun";
-import Query from "./Query";
+// import Query from "./Query"; // Lazy import to avoid cycle
 import { timed } from "./Decorators";
 import EntityHookManager from "./EntityHookManager";
 import { EntityCreatedEvent, EntityUpdatedEvent, EntityDeletedEvent, ComponentAddedEvent, ComponentUpdatedEvent, ComponentRemovedEvent } from "./events/EntityLifecycleEvents";
+import type { IEntity } from "./EntityInterface";
 
-export class Entity {
+export class Entity implements IEntity {
     id: string;
     public _persisted: boolean = false;
     private components: Map<string, BaseComponent> = new Map<string, BaseComponent>();
@@ -39,11 +40,15 @@ 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: Partial<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);
+        if (data) {
+            Object.assign(instance, data);
+        } else {
+            Object.assign(instance, {});
+        }
         this.addComponent(instance);
-        
+        this._dirty = true; 
         // Fire component added event
         try {
             EntityHookManager.executeHooks(new ComponentAddedEvent(this, instance));
@@ -84,6 +89,7 @@ export class Entity {
         } else {
             // Add new component
             this.add(ctor, data);
+            this._dirty = true;
             // Note: add() already fires ComponentAddedEvent, so we don't need to fire it again
         }
         return this;
@@ -155,6 +161,40 @@ export class Entity {
         }
     }
 
+    /**
+     * Get a component from the entity.
+     * @param ctor Constructor of the component to fetch
+     * @returns Component instance or null if not found
+     */
+    public async getComponent<T extends BaseComponent>(ctor: new (...args: any[]) => T): Promise<T | null> {
+        const comp = Array.from(this.components.values()).find(comp => comp instanceof ctor) as T | undefined;
+        if(typeof comp !== "undefined") {
+            return comp;
+        } else {
+            // fetch from db
+            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} AND deleted_at IS NULL`;
+                if (rows.length > 0) {
+                    const row = rows[0];
+                    const comp = new ctor();
+                    Object.assign(comp, row.data);
+                    comp.id = row.id;
+                    comp.setPersisted(true);
+                    comp.setDirty(false);
+                    this.addComponent(comp);
+                    return comp;
+                } else {
+                    return null;
+                }
+            } catch (error) {
+                logger.error(`Failed to fetch component: ${error}`);
+                return null;
+            }
+        }
+    }
+
     @timed("Entity.save")
     public save() {
         return new Promise<boolean>((resolve, reject) => {
@@ -239,7 +279,7 @@ export class Entity {
     public doDelete(force: boolean = false) {
         return new Promise<boolean>(async resolve => {
             if(!this._persisted) {
-                console.log("Entity is not persisted, cannot delete.");
+                logger.warn("Entity is not persisted, cannot delete.");
                 return resolve(false); 
             }
             try {
@@ -357,11 +397,19 @@ export class Entity {
         }
     }
 
+    /**
+     * Find an entity by its ID. Returning populated with all components. Or null if not found.
+     * @param id Entity ID
+     * @returns Entity | null
+     */
     public static async FindById(id: string): Promise<Entity | null> {
+        const { default: Query } = await import("./Query");
         const entities = await new Query().findById(id).populate().exec()
         if(entities.length === 1) {
             return entities[0]!;
         }
         return null;
     }
-}
+}
+
+export default Entity;

package/core/EntityInterface.ts

@@ -0,0 +1,4 @@
+export interface IEntity {
+    doSave(): Promise<boolean>;
+    doDelete(force?: boolean): Promise<boolean>;
+}

package/core/EntityManager.ts

@@ -1,10 +1,10 @@
 import ApplicationLifecycle, { ApplicationPhase } from "./ApplicationLifecycle";
-import type { Entity } from "./Entity";
+import type { IEntity } from "./EntityInterface";
 
 class EntityManager {
     static #instance: EntityManager;
     private dbReady = false;
-    private entityQueue: Entity[] = [];
+    private entityQueue: IEntity[] = [];
 
     constructor() {
         ApplicationLifecycle.addPhaseListener(async (event) => {
@@ -15,7 +15,7 @@ class EntityManager {
         });
     }
 
-    public saveEntity(entity: Entity) {
+    public saveEntity(entity: IEntity) {
         return new Promise<boolean>(async resolve => {
             if(!this.dbReady) {
                 this.entityQueue.push(entity);
@@ -27,7 +27,7 @@ class EntityManager {
         })
     }
 
-    public deleteEntity(entity: Entity, force: boolean = false) {
+    public deleteEntity(entity: IEntity, force: boolean = false) {
         return new Promise<boolean>(async resolve => {
             if(!this.dbReady) {
                 return resolve(false);