bunsane 0.1.0

package/core/Entity.ts

@@ -0,0 +1,188 @@
+import type { ComponentDataType, ComponentGetter, BaseComponent } from "./Components";
+import { logger } from "./Logger";
+import db from "database";
+import EntityManager from "./EntityManager";
+import ComponentRegistry from "./ComponentRegistry";
+import { uuidv7 } from "utils/uuid";
+import { sql } from "bun";
+import Query from "./Query";
+
+
+export class Entity {
+    id: string;
+    public _persisted: boolean = false;
+    private components: Map<string, BaseComponent> = new Map<string, BaseComponent>();
+    protected _dirty: boolean = false;
+
+    constructor(id?: string) {
+        this.id = id ?? uuidv7();
+        this._dirty = true;
+    }
+
+    public static Create(): Entity {
+        return new Entity();
+    }
+
+    private addComponent(component: BaseComponent): Entity {
+        this.components.set(component.getTypeID(), component);
+        return this;
+    }
+
+    public componentList(): BaseComponent[] {
+        return Array.from(this.components.values());
+    }
+
+    /**
+     * 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 {
+        const instance = new ctor();
+        Object.assign(instance, data);
+        this.addComponent(instance);
+        return this;
+    }
+
+    /**
+     * Sets/updates a component on the entity.
+     * If the component exists, it updates its properties.
+     * 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> {
+        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())
+            // Update existing component
+            Object.assign(component, data);
+            component.setDirty(true);
+            this._dirty = true;
+        } else {
+            // Add new component
+            console.log("Adding New Component")
+            this.add(ctor, data as any);
+            this._dirty = true;
+        }
+        return this;
+    }
+    /**
+     * Get component from entities. If entity is populated in query the component will get within the entitiy
+     * If not it will fetch from database
+     * @param Component
+     * @returns `Component | null` *if entity doesn't have the component
+     */
+    public async get<T extends BaseComponent>(ctor: new (...args: any[]) => T): Promise<ComponentDataType<T> | null> {
+        const comp = Array.from(this.components.values()).find(comp => comp instanceof ctor) as ComponentGetter<T> | undefined;
+        if(typeof comp !== "undefined") {
+            return comp.data();
+        } 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}`;
+                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.data();
+                } else {
+                    return null;
+                }
+            } catch (error) {
+                logger.error(`Failed to fetch component: ${error}`);
+                return null;
+            }
+        }
+    }
+
+    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); 
+            }
+            await db.transaction(async (trx) => {
+                if(!this._persisted) {
+                    await trx`INSERT INTO entities (id) VALUES (${this.id}) ON CONFLICT DO NOTHING`;
+                    this._persisted = true;
+                }
+                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;
+            resolve(true);
+        })
+        
+    }
+
+    public setPersisted(persisted: boolean) {
+        this._persisted = persisted;
+    }
+
+    public setDirty(dirty: boolean) {
+        this._dirty = dirty;
+    }
+
+    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)}
+        `;
+
+        const entitiesMap = new Map<string, Entity>();
+
+        for (const id of ids) {
+            const entity = new Entity();
+            entity.id = id;
+            entity.setPersisted(true);
+            entity.setDirty(false);
+            entitiesMap.set(id, entity);
+        }
+
+        for (const row of components) {
+            const { id, entity_id, type_id, data } = row;
+            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);
+                entitiesMap.get(entity_id)?.addComponent(comp);
+            }
+        }
+
+        return Array.from(entitiesMap.values());
+    }
+
+    public static async FindById(id: string): Promise<Entity | null> {
+        const entities = await new Query().findById(id).populate().exec()
+        if(entities.length === 1) {
+            return entities[0]!;
+        }
+        return null;
+    }
+}

package/core/EntityManager.ts

@@ -0,0 +1,46 @@
+import ApplicationLifecycle, { ApplicationPhase } from "./ApplicationLifecycle";
+import type { Entity } from "./Entity";
+
+class EntityManager {
+    static #instance: EntityManager;
+    private dbReady = false;
+    private entityQueue: Entity[] = [];
+
+    constructor() {
+        ApplicationLifecycle.addPhaseListener(async (event) => {
+            if (event.detail === ApplicationPhase.DATABASE_READY) {
+                this.dbReady = true;
+                await this.savePendingEntities();
+            }
+        });
+    }
+
+    public saveEntity(entity: Entity) {
+        return new Promise<boolean>(async resolve => {
+            if(!this.dbReady) {
+                this.entityQueue.push(entity);
+                return resolve(true);
+            } else {
+                resolve(entity.doSave());
+            }
+        })
+        
+    }
+
+    private async savePendingEntities() {
+        const promiseWait = [];
+        for(const entity of this.entityQueue) {
+           promiseWait.push(entity.doSave()); 
+        }
+        return await Promise.all(promiseWait);
+    }
+
+    public static get instance(): EntityManager {
+        if (!this.#instance) {
+            this.#instance = new EntityManager();
+        }
+        return this.#instance;
+    }
+}
+
+export default EntityManager.instance;

package/core/ErrorHandler.ts

@@ -0,0 +1,35 @@
+import * as z from "zod";
+import { GraphQLError, type GraphQLErrorOptions } from "graphql";
+
+export function responseError(message: string, extensions?: GraphQLErrorOptions) {
+    return new GraphQLError(message, {
+        extensions: {
+            code: "UNKNOWN_ERROR",
+        },
+        ...extensions
+    });
+}
+
+export function handleGraphQLError(err: any): never {
+    if (err instanceof z.ZodError) {
+        const errorMessages = err.issues.map((error: any) => 
+            `${error.path.join('.')}: ${error.message}`
+        ).join(', ');
+        
+        throw new GraphQLError(`Validation failed: ${errorMessages}`, {
+            extensions: {
+                code: "VALIDATION_ERROR",
+                validationErrors: err.issues
+            }
+        });
+    }
+    if (err instanceof GraphQLError) {
+        throw err;
+    }
+    throw new GraphQLError("An unexpected error occurred", {
+        extensions: {
+            code: "INTERNAL_ERROR",
+            originalError: process.env.NODE_ENV === 'development' ? err : undefined
+        }
+    });
+}

package/core/Logger.ts

@@ -0,0 +1,16 @@
+import pino from "pino";
+
+const usePretty = process.env.LOG_PRETTY === 'true';
+export const logger = pino({
+    level: process.env.LOG_LEVEL || 'info',
+    ...(usePretty && {
+        transport: {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                messageFormat: '[{scope}{component}] => {msg}',
+                ignore: 'pid,hostname,scope'
+            }
+        }
+    })
+});

package/core/Query.ts

@@ -0,0 +1,296 @@
+import type { BaseComponent } from "./Components";
+import { Entity } from "./Entity";
+import ComponentRegistry from "./ComponentRegistry";
+import { logger } from "./Logger";
+import { sql } from "bun";
+import db from "database";
+import { timed } from "./Decorators";
+
+export type FilterOperator = "=" | ">" | "<" | ">=" | "<=" | "!=" | "LIKE" | "IN" | "NOT IN";
+export interface QueryFilter {
+    field: string;
+    operator: FilterOperator;
+    value: any;
+}
+
+export type QueryFilterOptions = {
+    filters?: QueryFilter[];
+};
+
+function wrapLog(str: string) {
+    // console.log(str);
+}
+class Query {
+    private requiredComponents: Set<string> = new Set<string>();
+    private excludedComponents: Set<string> = new Set<string>();
+    private componentFilters: Map<string, QueryFilter[]> = new Map();
+    private populateComponents: boolean = false;
+    private withId: string | null = null;
+
+    public findById(id: string) {
+        this.withId = id;
+        return this;
+    }
+
+    public async findOneById(id: string): Promise<Entity | null> {
+        const entities = await this.findById(id).exec();
+        return entities.length > 0 ? entities[0]! : null;
+    }
+
+    public with<T extends BaseComponent>(ctor: new (...args: any[]) => T, options?: QueryFilterOptions) {
+        const type_id = ComponentRegistry.getComponentId(ctor.name);
+        if(!type_id) {
+            throw new Error(`Component ${ctor.name} is not registered.`);
+        }
+        this.requiredComponents.add(type_id);
+        
+        if (options?.filters && options.filters.length > 0) {
+            this.componentFilters.set(type_id, options.filters);
+        }
+        
+        return this;
+    }
+
+    
+    public static filter(field: string, operator: FilterOperator, value: any): QueryFilter {
+        return { field, operator, value };
+    }
+
+    public static filters(...filters: QueryFilter[]): QueryFilterOptions {
+        return { filters };
+    }
+
+    private buildFilterCondition(filter: QueryFilter): string {
+        const { field, operator, value } = filter;
+        switch (operator) {
+            case "=":
+            case ">":
+            case "<":
+            case ">=":
+            case "<=":
+            case "!=":
+                if (typeof value === "string") {
+                    return `data->>'${field}' ${operator} '${value}'`;
+                } else {
+                    return `(data->>'${field}')::numeric ${operator} ${value}`;
+                }
+            case "LIKE":
+                return `data->>'${field}' LIKE '${value}'`;
+            case "IN":
+                if (Array.isArray(value)) {
+                    const valueList = value.map(v => typeof v === "string" ? `'${v}'` : v).join(", ");
+                    return `data->>'${field}' IN (${valueList})`;
+                }
+                throw new Error("IN operator requires an array of values");
+            case "NOT IN":
+                if (Array.isArray(value)) {
+                    const valueList = value.map(v => typeof v === "string" ? `'${v}'` : v).join(", ");
+                    return `data->>'${field}' NOT IN (${valueList})`;
+                }
+                throw new Error("NOT IN operator requires an array of values");
+            default:
+                throw new Error(`Unsupported operator: ${operator}`);
+        }
+    }
+
+    private buildFilterWhereClause(typeId: string, filters: QueryFilter[]): string {
+        if (filters.length === 0) return "";
+        
+        const conditions = filters.map(filter => this.buildFilterCondition(filter));
+        return conditions.join(" AND ");
+    }
+
+
+    public without<T extends BaseComponent>(ctor: new (...args: any[]) => T) {
+        const type_id = ComponentRegistry.getComponentId(ctor.name);
+        if(!type_id) {
+            throw new Error(`Component ${ctor.name} is not registered.`);
+        }
+        this.excludedComponents.add(type_id);
+        return this;
+    }
+
+    public populate(): this {
+        this.populateComponents = true;
+        return this;
+    }
+
+    @timed
+    public async exec(): Promise<Entity[]> {
+        const componentIds = Array.from(this.requiredComponents);
+        const excludedIds = Array.from(this.excludedComponents);
+        const componentCount = componentIds.length;
+        const hasRequired = componentCount > 0;
+        const hasExcluded = excludedIds.length > 0;
+        const hasFilters = this.componentFilters.size > 0;
+        const hasWithId = this.withId !== null;
+        
+        let ids: string[] = [];
+        
+        switch (true) {
+            case !hasRequired && !hasExcluded && !hasWithId:
+                return [];
+            case !hasRequired && !hasExcluded && hasWithId:
+                const result = await db`SELECT id FROM entities WHERE id = ${this.withId!}`;
+                ids = result.map((row: any) => row.id);
+                break;
+            case hasRequired && hasExcluded && hasFilters:
+                ids = await this.getIdsWithFiltersAndExclusions(componentIds, excludedIds, componentCount);
+                break;
+            case hasRequired && hasExcluded:
+                const componentIdsString = componentIds.map(id => `'${id}'`).join(', ');
+                const excludedIdsString = excludedIds.map(id => `'${id}'`).join(', ');
+                const excludedQuery = `
+                    SELECT ec.entity_id as id
+                    FROM entity_components ec
+                    WHERE ec.type_id IN (${componentIdsString})
+                    ${this.withId ? `AND ec.entity_id = '${this.withId}'` : ''}
+                    AND NOT EXISTS (
+                        SELECT 1 FROM entity_components ec_ex 
+                        WHERE ec_ex.entity_id = ec.entity_id AND ec_ex.type_id IN (${excludedIdsString})
+                    )
+                    GROUP BY ec.entity_id
+                    HAVING COUNT(DISTINCT ec.type_id) = ${componentCount}
+                `;
+                wrapLog(`Executing query: ${excludedQuery}`);
+                const excludedQueryResult = await db.unsafe(excludedQuery);
+                ids = excludedQueryResult.map((row: any) => row.id);
+                break;
+            case hasRequired && hasFilters:
+                ids = await this.getIdsWithFilters(componentIds, componentCount);
+                break;
+            case hasRequired:
+                let queryStr: string;
+                let requiredOnlyQueryResult: any;
+                if (componentCount === 1) {
+                    // Optimize for single component: no need for GROUP BY, HAVING, or DISTINCT
+                    queryStr = `SELECT entity_id as id FROM entity_components WHERE type_id = '${componentIds[0]}' ${this.withId ? `AND entity_id = '${this.withId}'` : ''}`;
+                    wrapLog(`Executing optimized query: ${queryStr}`);
+                    requiredOnlyQueryResult = await db.unsafe(queryStr);
+                } else {
+                    queryStr = `SELECT DISTINCT entity_id as id FROM entity_components WHERE type_id IN (${componentIds.map(id => `'${id}'`).join(', ')}) ${this.withId ? `AND entity_id = '${this.withId}'` : ''} GROUP BY entity_id HAVING COUNT(DISTINCT type_id) = ${componentCount}`;
+                    wrapLog(`Executing query: ${queryStr}`);
+                    requiredOnlyQueryResult = await db`
+                        SELECT DISTINCT entity_id as id FROM entity_components
+                        WHERE type_id IN ${sql(componentIds)}
+                        ${this.withId ? sql`AND entity_id = ${this.withId}` : sql``}
+                        GROUP BY entity_id
+                        HAVING COUNT(DISTINCT type_id) = ${componentCount}
+                    `;
+                }
+                ids = requiredOnlyQueryResult.map((row: any) => row.id);
+                break;
+            case hasExcluded:
+                const onlyExcludedIdsString = excludedIds.map(id => `'${id}'`).join(', ');
+                const onlyExcludedQuery = `
+                    SELECT DISTINCT ec.entity_id as id
+                    FROM entity_components ec
+                    WHERE ${this.withId ? `ec.entity_id = '${this.withId}' AND ` : ''} NOT EXISTS (
+                        SELECT 1 FROM entity_components ec_ex 
+                        WHERE ec_ex.entity_id = ec.entity_id AND ec_ex.type_id IN (${onlyExcludedIdsString})
+                    )
+                `;
+                wrapLog(`Executing query: ${onlyExcludedQuery}`);
+                const onlyExcludedQueryResult = await db.unsafe(onlyExcludedQuery);
+                ids = onlyExcludedQueryResult.map((row: any) => row.id);
+                break;
+            default:
+                return [];
+        }
+        
+        if (this.populateComponents) {
+            return await Entity.LoadMultiple(ids);
+        } else {
+            const len = ids.length;
+            const entities = new Array(len);
+            for (let i = 0; i < len; i += 4) {
+                if (i < len) {
+                    const entity = new Entity(ids[i]);
+                    entity.setPersisted(true);
+                    entity.setDirty(false);
+                    entities[i] = entity;
+                }
+                if (i + 1 < len) {
+                    const entity = new Entity(ids[i + 1]);
+                    entity.setPersisted(true);
+                    entity.setDirty(false);
+                    entities[i + 1] = entity;
+                }
+                if (i + 2 < len) {
+                    const entity = new Entity(ids[i + 2]);
+                    entity.setPersisted(true);
+                    entity.setDirty(false);
+                    entities[i + 2] = entity;
+                }
+                if (i + 3 < len) {
+                    const entity = new Entity(ids[i + 3]);
+                    entity.setPersisted(true);
+                    entity.setDirty(false);
+                    entities[i + 3] = entity;
+                }
+            }
+            return entities;
+        }
+    }
+
+    private async getIdsWithFilters(componentIds: string[], componentCount: number): Promise<string[]> {
+        let query = `
+            SELECT DISTINCT ec.entity_id as id 
+            FROM entity_components ec
+        `;
+        
+        const joins: string[] = [];
+        const whereConditions: string[] = [`ec.type_id IN (${componentIds.map(id => `'${id}'`).join(', ')})`];
+        if (this.withId) {
+            whereConditions.push(`ec.entity_id = '${this.withId}'`);
+        }
+        
+        let joinIndex = 0;
+        for (const [typeId, filters] of this.componentFilters.entries()) {
+            if (componentIds.includes(typeId)) {
+                const alias = `c${joinIndex}`;
+                joins.push(`JOIN components ${alias} ON ec.entity_id = ${alias}.entity_id AND ${alias}.type_id = '${typeId}'`);
+                
+                const filterCondition = this.buildFilterWhereClause(typeId, filters);
+                if (filterCondition) {
+                    whereConditions.push(filterCondition.replace(/data->/g, `${alias}.data->`));
+                }
+                joinIndex++;
+            }
+        }
+        
+        query += joins.join(' ');
+        query += ` WHERE ${whereConditions.join(' AND ')}`;
+        query += ` GROUP BY ec.entity_id HAVING COUNT(DISTINCT ec.type_id) = ${componentCount}`;
+        
+        wrapLog(`Executing filtered query: ${query}`);
+        const filteredResult = await db.unsafe(query);
+        return filteredResult.map((row: any) => row.id);
+    }
+
+    private async getIdsWithFiltersAndExclusions(componentIds: string[], excludedIds: string[], componentCount: number): Promise<string[]> {
+        const entityIds = await this.getIdsWithFilters(componentIds, componentCount);
+        
+        if (entityIds.length === 0) {
+            return [];
+        }
+        
+        const idsString = entityIds.map(id => `'${id}'`).join(', ');
+        const excludedString = excludedIds.map(id => `'${id}'`).join(', ');
+        const query = `
+            WITH entity_list AS (
+                SELECT unnest(ARRAY[${idsString}]) as id
+            )
+            SELECT el.id
+            FROM entity_list el
+            WHERE NOT EXISTS (
+                SELECT 1 FROM entity_components ec 
+                WHERE ec.entity_id = el.id AND ec.type_id IN (${excludedString})
+            )
+        `;
+        const exclusionResult = await db.unsafe(query);
+        return exclusionResult.map((row: any) => row.id);
+    }
+}
+
+export default Query;