bunsane 0.1.1 → 0.1.2

package/core/App.ts

@@ -140,55 +140,104 @@ export default class App {
     private async handleRequest(req: Request): Promise<Response> {
         const url = new URL(req.url);
         const method = req.method;
+        const startTime = Date.now();
       
-        // Check for static assets
-        for (const [route, folder] of this.staticAssets) {
-            if (url.pathname.startsWith(route)) {
-                const relativePath = url.pathname.slice(route.length);
-                const filePath = path.join(folder, relativePath);
-                try {
-                    const file = Bun.file(filePath);
-                    if (await file.exists()) {
-                        return new Response(file);
+        // Add request timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+            logger.warn(`Request timeout: ${method} ${url.pathname}`);
+        }, 30000); // 30 second timeout
+
+        try {
+            // Health check endpoint
+            if (url.pathname === '/health') {
+                clearTimeout(timeoutId);
+                return new Response(JSON.stringify({ 
+                    status: 'ok', 
+                    timestamp: new Date().toISOString(),
+                    uptime: process.uptime()
+                }), {
+                    headers: { 'Content-Type': 'application/json' }
+                });
+            }
+            for (const [route, folder] of this.staticAssets) {
+                if (url.pathname.startsWith(route)) {
+                    const relativePath = url.pathname.slice(route.length);
+                    const filePath = path.join(folder, relativePath);
+                    try {
+                        const file = Bun.file(filePath);
+                        if (await file.exists()) {
+                            clearTimeout(timeoutId);
+                            return new Response(file);
+                        }
+                    } catch (error) {
+                        logger.error(`Error serving static file ${filePath}:`, error as any);
                     }
-                } catch (error) {
-                    logger.error(`Error serving static file ${filePath}:`, error as any);
                 }
             }
-        }
 
-        // Lookup REST endpoint using map for O(1) performance
-        const endpointKey = `${method}:${url.pathname}`;
-        const endpoint = this.restEndpointMap.get(endpointKey);
-        if (endpoint) {
-            try {
-                const result = await endpoint.handler(req);
-                if (result instanceof Response) {
-                    return result;
-                } else {
-                    return new Response(JSON.stringify(result), {
+            // Lookup REST endpoint using map for O(1) performance
+            const endpointKey = `${method}:${url.pathname}`;
+            const endpoint = this.restEndpointMap.get(endpointKey);
+            if (endpoint) {
+                try {
+                    const result = await endpoint.handler(req);
+                    const duration = Date.now() - startTime;
+                    logger.trace(`REST ${method} ${url.pathname} completed in ${duration}ms`);
+                    
+                    clearTimeout(timeoutId);
+                    if (result instanceof Response) {
+                        return result;
+                    } else {
+                        return new Response(JSON.stringify(result), {
+                            headers: { 'Content-Type': 'application/json' }
+                        });
+                    }
+                } catch (error) {
+                    const duration = Date.now() - startTime;
+                    logger.error(`Error in REST endpoint ${method} ${endpoint.path} after ${duration}ms`, error as any);
+                    clearTimeout(timeoutId);
+                    return new Response(JSON.stringify({ error: 'Internal server error' }), {
+                        status: 500,
                         headers: { 'Content-Type': 'application/json' }
                     });
                 }
-            } catch (error) {
-                logger.error(`Error in REST endpoint ${method} ${endpoint.path}`, error as any);
-                return new Response(JSON.stringify({ error: 'Internal server error' }), {
-                    status: 500,
+            }
+
+            if (this.yoga) {
+                const response = await this.yoga(req);
+                const duration = Date.now() - startTime;
+                logger.trace(`GraphQL request completed in ${duration}ms`);
+                clearTimeout(timeoutId);
+                return response;
+            }
+
+            clearTimeout(timeoutId);
+            return new Response('Not Found', { status: 404 });
+        } catch (error) {
+            const duration = Date.now() - startTime;
+            logger.error(`Request failed after ${duration}ms: ${method} ${url.pathname}`, error as any);
+            clearTimeout(timeoutId);
+            
+            if ((error as Error).name === 'AbortError') {
+                return new Response(JSON.stringify({ error: 'Request timeout' }), {
+                    status: 408,
                     headers: { 'Content-Type': 'application/json' }
                 });
             }
+            
+            return new Response(JSON.stringify({ error: 'Internal server error' }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' }
+            });
         }
-
-        if (this.yoga) {
-            return this.yoga(req);
-        }
-
-        return new Response('Not Found', { status: 404 });
     }
 
     async start() {
         logger.info("Application Started");
         const server = Bun.serve({
+            port: parseInt(process.env.PORT || "3000"),
             fetch: this.handleRequest.bind(this),
         });
         logger.info(`Server is running on ${new URL(this.yoga?.graphqlEndpoint || '/graphql', `http://${server.hostname}:${server.port}`)}`)

package/core/Entity.ts

@@ -14,6 +14,7 @@ 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) {
@@ -91,11 +92,17 @@ export class Entity {
     /**
      * 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;
@@ -150,7 +157,23 @@ 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);
+                });
+        });
     }
 
     
@@ -158,7 +181,7 @@ export class Entity {
     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); 
             }
 
@@ -170,6 +193,15 @@ export class Entity {
                     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;

package/core/Query.ts

@@ -117,6 +117,10 @@ class Query {
 
     private buildFilterCondition(filter: QueryFilter, alias: string, paramIndex: number): { sql: string, params: any[], newParamIndex: number } {
         const { field, operator, value } = filter;
+
+        // Build JSON path for nested properties (e.g., "parent.child" -> data->'parent'->>'child')
+        const jsonPath = this.buildJsonPath(field, alias);
+
         switch (operator) {
             case "=":
             case ">":
@@ -125,22 +129,22 @@ class Query {
             case "<=":
             case "!=":
                 if (typeof value === "string") {
-                    return { sql: `${alias}.data->>'${field}' ${operator} $${paramIndex}`, params: [value], newParamIndex: paramIndex + 1 };
+                    return { sql: `${jsonPath} ${operator} $${paramIndex}`, params: [value], newParamIndex: paramIndex + 1 };
                 } else {
-                    return { sql: `(${alias}.data->>'${field}')::numeric ${operator} $${paramIndex}`, params: [value], newParamIndex: paramIndex + 1 };
+                    return { sql: `(${jsonPath})::numeric ${operator} $${paramIndex}`, params: [value], newParamIndex: paramIndex + 1 };
                 }
             case "LIKE":
-                return { sql: `${alias}.data->>'${field}' LIKE $${paramIndex}`, params: [value], newParamIndex: paramIndex + 1 };
+                return { sql: `${jsonPath} LIKE $${paramIndex}`, params: [value], newParamIndex: paramIndex + 1 };
             case "IN":
                 if (Array.isArray(value)) {
                     const placeholders = Array.from({length: value.length}, (_, i) => `$${paramIndex + i}`).join(', ');
-                    return { sql: `${alias}.data->>'${field}' IN (${placeholders})`, params: value, newParamIndex: paramIndex + value.length };
+                    return { sql: `${jsonPath} IN (${placeholders})`, params: value, newParamIndex: paramIndex + value.length };
                 }
                 throw new Error("IN operator requires an array of values");
             case "NOT IN":
                 if (Array.isArray(value)) {
                     const placeholders = Array.from({length: value.length}, (_, i) => `$${paramIndex + i}`).join(', ');
-                    return { sql: `${alias}.data->>'${field}' NOT IN (${placeholders})`, params: value, newParamIndex: paramIndex + value.length };
+                    return { sql: `${jsonPath} NOT IN (${placeholders})`, params: value, newParamIndex: paramIndex + value.length };
                 }
                 throw new Error("NOT IN operator requires an array of values");
             default:
@@ -148,6 +152,27 @@ class Query {
         }
     }
 
+    /**
+     * Build PostgreSQL JSON path expression for nested properties
+     * @param field Field path (e.g., "parent.child.grandchild")
+     * @param alias Table alias for the components table
+     * @returns PostgreSQL JSON path expression
+     */
+    private buildJsonPath(field: string, alias: string): string {
+        const parts = field.split('.');
+
+        if (parts.length === 1) {
+            // Single level: data->>'field'
+            return `${alias}.data->>'${field}'`;
+        } else {
+            // Nested levels: data->'parent'->'child'->>'grandchild'
+            const pathParts = parts.slice(0, -1).map(part => `'${part}'`);
+            const lastPart = parts[parts.length - 1];
+
+            return `${alias}.data->${pathParts.join('->')}->>'${lastPart}'`;
+        }
+    }
+
     private buildFilterWhereClause(typeId: string, filters: QueryFilter[], alias: string, paramIndex: number): { sql: string, params: any[], newParamIndex: number } {
         if (filters.length === 0) return { sql: '', params: [], newParamIndex: paramIndex };
         
@@ -235,6 +260,26 @@ class Query {
 
     @timed("Query.exec")
     public async exec(): Promise<Entity[]> {
+        return new Promise<Entity[]>((resolve, reject) => {
+            // Add timeout to prevent hanging queries
+            const timeout = setTimeout(() => {
+                logger.error(`Query execution timeout`);
+                reject(new Error(`Query execution timeout after 30 seconds`));
+            }, 30000); // 30 second timeout
+
+            this.doExec()
+                .then(result => {
+                    clearTimeout(timeout);
+                    resolve(result);
+                })
+                .catch(error => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+        });
+    }
+
+    private async doExec(): Promise<Entity[]> {
         const componentIds = Array.from(this.requiredComponents);
         const excludedIds = Array.from(this.excludedComponents);
         const componentCount = componentIds.length;
@@ -422,7 +467,10 @@ class Query {
             const componentAlias = `c_${typeId}`;
             const direction = order.direction.toUpperCase();
             const nulls = order.nullsFirst ? 'NULLS FIRST' : 'NULLS LAST';
-            orderClauses.push(`(${componentAlias}.data->>'${order.property}')::text ${direction} ${nulls}`);
+
+            // Use buildJsonPath for nested property support
+            const jsonPath = this.buildJsonPath(order.property, componentAlias);
+            orderClauses.push(`(${jsonPath})::text ${direction} ${nulls}`);
         }
 
         // Always include entity_id as final tiebreaker for consistent ordering
@@ -475,7 +523,9 @@ class Query {
         const direction = order.direction.toUpperCase();
         const nullsClause = order.nullsFirst ? "NULLS FIRST" : "NULLS LAST";
 
-        const selectExpr = `, (${alias}.data->>'${order.property}')::numeric as sort_val`;
+        // Use buildJsonPath for nested property support
+        const jsonPath = this.buildJsonPath(order.property, alias);
+        const selectExpr = `, (${jsonPath})::numeric as sort_val`;
         const orderByExpr = `ORDER BY sort_val ${direction} ${nullsClause}, ec.entity_id ASC`;
 
         return { select: selectExpr, orderBy: orderByExpr };

package/core/RequestLoaders.ts

@@ -18,46 +18,70 @@ export type RequestLoaders = {
 
 export function createRequestLoaders(db: any): RequestLoaders {
   const entityById = new DataLoader<string, Entity | null>(async (ids: readonly string[]) => {
-    const uniqueIds = [...new Set(ids)];
-    const rows = await db`
-      SELECT id
-      FROM entities
-      WHERE id IN ${inList(uniqueIds)}
-        AND deleted_at IS NULL
-    `;
-    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));
-    return ids.map(id => map.get(id) ?? null);
+    const startTime = Date.now();
+    try {
+      const uniqueIds = [...new Set(ids)];
+      const rows = await db`
+        SELECT id
+        FROM entities
+        WHERE id IN ${inList(uniqueIds, 1)}
+          AND deleted_at IS NULL
+      `;
+      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));
+      
+      const duration = Date.now() - startTime;
+      if (duration > 1000) { // Log slow queries
+        console.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);
+      throw error;
+    }
   });
 
   const componentsByEntityType = new DataLoader<{ entityId: string; typeId: number }, ComponentData | null>(
     async (keys: readonly { entityId: string; typeId: number }[]) => {
-      const entityIds = [...new Set(keys.map(k => k.entityId))];
-      const typeIds = [...new Set(keys.map(k => k.typeId))];
-      const rows = await db`
-        SELECT entity_id, type_id, data, created_at, updated_at, deleted_at
-        FROM components
-        WHERE entity_id IN ${inList(entityIds)}
-          AND type_id IN ${inList(typeIds)}
-          AND deleted_at IS NULL
-      `;
-      const map = new Map<string, ComponentData>();
-      rows.forEach((row: any) => {
-        const key = `${row.entity_id}-${row.type_id}`;
-        map.set(key, {
-          typeId: row.type_id,
-          data: row.data,
-          createdAt: row.created_at,
-          updatedAt: row.updated_at,
-          deletedAt: row.deleted_at,
+      const startTime = Date.now();
+      try {
+        const entityIds = [...new Set(keys.map(k => k.entityId))];
+        const typeIds = [...new Set(keys.map(k => k.typeId))];
+        const rows = await db`
+          SELECT entity_id, type_id, data, created_at, updated_at, deleted_at
+          FROM components
+          WHERE entity_id IN ${inList(entityIds, 1)}
+            AND type_id IN ${inList(typeIds, entityIds.length + 1)}
+            AND deleted_at IS NULL
+        `;
+        const map = new Map<string, ComponentData>();
+        rows.forEach((row: any) => {
+          const key = `${row.entity_id}-${row.type_id}`;
+          map.set(key, {
+            typeId: row.type_id,
+            data: row.data,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            deletedAt: row.deleted_at,
+          });
         });
-      });
-      return keys.map(k => map.get(`${k.entityId}-${k.typeId}`) ?? null);
+        
+        const duration = Date.now() - startTime;
+        if (duration > 1000) { // Log slow queries
+          console.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);
+        throw error;
+      }
     }
   );
 

package/database/index.ts

@@ -2,11 +2,11 @@ import {SQL} from "bun";
 import { logger } from "core/Logger";
 
 const db = new SQL({
-    url: `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@${process.env.POSTGRES_HOST}:5432/${process.env.POSTGRES_DB}`,
-    // Connection pool settings
-    max: parseInt(process.env.POSTGRES_MAX_CONNECTIONS ?? '10', 10), // Maximum connections in pool
-    idleTimeout: 0, // Close idle connections after 30s
-    maxLifetime: 0, // Connection lifetime in seconds (0 = forever)
+    url: `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@${process.env.POSTGRES_HOST}:${process.env.POSTGRES_PORT ?? "5432"}/${process.env.POSTGRES_DB}`,
+    // Connection pool settings - FIXED
+    max: parseInt(process.env.POSTGRES_MAX_CONNECTIONS ?? '20', 10), // Increased max connections
+    idleTimeout: 30000, // Close idle connections after 30s (was 0)
+    maxLifetime: 600000, // Connection lifetime 10 minutes (was 0 = forever)
     connectionTimeout: 30, // Timeout when establishing new connections
     onclose: (err) => {
         if (err) {

package/gql/Generator.ts

@@ -57,7 +57,7 @@ export function generateGraphQLSchema(services: any[]): { schema: GraphQLSchema
     let typeDefs = `
     `;
     const scalarTypes: Set<string> = new Set();
-    const resolvers: any = { Query: {}, Mutation: {} };
+    const resolvers: any = {};
     const queryFields: string[] = [];
     const mutationFields: string[] = [];
 
@@ -80,6 +80,7 @@ export function generateGraphQLSchema(services: any[]): { schema: GraphQLSchema
         if (service.__graphqlOperations) {
             service.__graphqlOperations.forEach((op: any) => {
                 const { type, name, input, output, propertyKey } = op;
+                if (!resolvers[type]) resolvers[type] = {};
                 let fieldDef = `${name}`;
                 if (input) {
                     const inputName = `${name}Input`;

package/gql/index.ts

@@ -71,9 +71,19 @@ const staticResolvers = {
 };
 
 const maskError = (error: any, message: string): GraphQLError => {
+    // Handle authentication errors
+    if (error.message === 'Unauthenticated' || error.extensions?.http?.status === 401 || error.extensions?.code === 'UNAUTHENTICATED') {
+        return new GraphQLError('Unauthorized', {
+            extensions: {
+                code: 'UNAUTHORIZED',
+                http: { status: 401 }
+            }
+        });
+    }
+    
     // Handle JWT authentication errors specifically
     if (error.extensions?.code === 'DOWNSTREAM_SERVICE_ERROR' && error.extensions?.http?.status === 401) {
-        return new GraphQLError('Error: Unauthorized', {
+        return new GraphQLError('Unauthorized', {
             extensions: {
                 code: 'UNAUTHORIZED',
                 http: { status: 401 }

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "bunsane",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "author": {
     "name": "yaaruu"
   },
+  "keywords": [
+    "bun",
+    "framework",
+    "entity-component-system",
+    "ecs",
+    "graphql",
+    "typescript"
+  ],
   "module": "index.ts",
   "type": "module",
   "devDependencies": {
@@ -13,13 +21,13 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "dataloader": "^2.2.2",
-    "graphql": "^16.11.0",
-    "graphql-yoga": "^5.15.1",
-    "pino": "^9.9.0",
-    "pino-pretty": "^13.1.1",
-    "reflect-metadata": "^0.2.2",
-    "zod": "^4.1.5"
+    "dataloader": "2.2.2",
+    "graphql": "16.11.0",
+    "graphql-yoga": "5.15.1",
+    "pino": "9.9.0",
+    "pino-pretty": "13.1.1",
+    "reflect-metadata": "0.2.2",
+    "zod": "4.1.5"
   },
   "repository": {
     "type": "git",