bunsane 0.1.2 → 0.1.4

package/core/Query.ts

@@ -7,7 +7,7 @@ import db from "database";
 import { timed } from "./Decorators";
 import { inList } from "../database/sqlHelpers";
 
-export type FilterOperator = "=" | ">" | "<" | ">=" | "<=" | "!=" | "LIKE" | "IN" | "NOT IN";
+export type FilterOperator = "=" | ">" | "<" | ">=" | "<=" | "!=" | "LIKE" | "IN" | "NOT IN" | string;
 
 export const FilterOp = {
     EQ: "=" as FilterOperator,
@@ -50,6 +50,12 @@ class Query {
     private eagerComponents: Set<string> = new Set<string>();
     private sortOrders: SortOrder[] = [];
 
+    private static customFilterBuilders: Map<string, (filter: QueryFilter, alias: string, paramIndex: number) => { sql: string, params: any[], newParamIndex: number }> = new Map();
+
+    public static registerFilterBuilder(operator: string, builder: (filter: QueryFilter, alias: string, paramIndex: number) => { sql: string, params: any[], newParamIndex: number }) {
+        this.customFilterBuilders.set(operator, builder);
+    }
+
     static filterOp = FilterOp;
 
     public findById(id: string) {
@@ -118,6 +124,11 @@ class Query {
     private buildFilterCondition(filter: QueryFilter, alias: string, paramIndex: number): { sql: string, params: any[], newParamIndex: number } {
         const { field, operator, value } = filter;
 
+        // Check for custom filter builders first
+        if (Query.customFilterBuilders.has(operator)) {
+            return Query.customFilterBuilders.get(operator)!(filter, alias, paramIndex);
+        }
+
         // Build JSON path for nested properties (e.g., "parent.child" -> data->'parent'->>'child')
         const jsonPath = this.buildJsonPath(field, alias);
 
@@ -258,6 +269,10 @@ class Query {
         return this;
     }
 
+    public count(): Promise<number> {
+        return this.doCount();
+    }
+
     @timed("Query.exec")
     public async exec(): Promise<Entity[]> {
         return new Promise<Entity[]>((resolve, reject) => {
@@ -339,7 +354,6 @@ class Query {
                 let queryStr: any;
                 let requiredOnlyQueryResult: any;
                 if (componentCount === 1) {
-                    // Phase 2A: Optimize single component sorting with JOIN
                     if (this.sortOrders.length > 0) {
                         const typeId = componentIds[0]!;
                         const sortExpression = this.buildSortExpressionForSingleComponent(typeId, "c");
@@ -679,7 +693,9 @@ class Query {
 
         const filteredResult = await db.unsafe(sql, params);
         return filteredResult.map((row: any) => row.id);
-    }    private async getIdsWithFiltersAndExclusions(componentIds: string[], excludedIds: string[], componentCount: number, limit?: number | null, offset?: number): Promise<string[]> {
+    }
+
+    private async getIdsWithFiltersAndExclusions(componentIds: string[], excludedIds: string[], componentCount: number, limit?: number | null, offset?: number): Promise<string[]> {
         const entityIds = await this.getIdsWithFilters(componentIds, componentCount);
         
         if (entityIds.length === 0) {
@@ -709,6 +725,156 @@ class Query {
         const exclusionResult = await query;
         return exclusionResult.map((row: any) => row.id);
     }
+
+    private async doCount(): Promise<number> {
+        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;
+        
+        switch (true) {
+            case !hasRequired && !hasExcluded && !hasWithId:
+                return 0;
+            case !hasRequired && !hasExcluded && hasWithId:
+                const result = await db`SELECT COUNT(*) as count FROM entities WHERE id = ${this.withId} AND deleted_at IS NULL`;
+                return parseInt(result[0].count);
+            case hasRequired && hasExcluded && hasFilters:
+                return await this.getCountWithFiltersAndExclusions(componentIds, excludedIds, componentCount);
+            case hasRequired && hasExcluded:
+                const componentIdsString = inList(componentIds, 1);
+                const excludedIdsString = inList(excludedIds, componentIdsString.newParamIndex);
+                const excludedQuery = db`
+                    SELECT COUNT(*) as count FROM (
+                        SELECT ec.entity_id
+                        FROM entity_components ec
+                        WHERE ec.type_id IN ${db.unsafe(componentIdsString.sql, componentIdsString.params)} AND ec.deleted_at IS NULL
+                        ${this.withId ? db`AND ec.entity_id = ${this.withId}` : db``}
+                        AND NOT EXISTS (
+                            SELECT 1 FROM entity_components ec_ex 
+                            WHERE ec_ex.entity_id = ec.entity_id AND ec_ex.type_id IN ${db.unsafe(excludedIdsString.sql, excludedIdsString.params)} AND ec_ex.deleted_at IS NULL
+                        )
+                        GROUP BY ec.entity_id
+                        HAVING COUNT(DISTINCT ec.type_id) = ${componentCount}
+                    ) as subquery
+                `;
+                const excludedResult = await excludedQuery;
+                return parseInt(excludedResult[0].count);
+            case hasRequired && hasFilters:
+                return await this.getCountWithFilters(componentIds, componentCount);
+            case hasRequired:
+                if (componentCount === 1) {
+                    const countQuery = db`SELECT COUNT(*) as count FROM entity_components WHERE type_id = ${componentIds[0]} ${this.withId ? db`AND entity_id = ${this.withId}` : db``} AND deleted_at IS NULL`;
+                    const countResult = await countQuery;
+                    return parseInt(countResult[0].count);
+                } else {
+                    const compIds = inList(componentIds, 1);
+                    const multiComponentQuery = db`
+                        SELECT COUNT(*) as count FROM (
+                            SELECT entity_id FROM entity_components 
+                            WHERE type_id IN ${db.unsafe(compIds.sql, compIds.params)} ${this.withId ? db`AND entity_id = ${this.withId}` : db``} AND deleted_at IS NULL 
+                            GROUP BY entity_id 
+                            HAVING COUNT(DISTINCT type_id) = ${componentCount}
+                        ) as subquery
+                    `;
+                    const multiComponentResult = await multiComponentQuery;
+                    return parseInt(multiComponentResult[0].count);
+                }
+            case hasExcluded:
+                const onlyExcludedIdsString = inList(excludedIds, 1);
+                const onlyExcludedQuery = db`
+                    SELECT COUNT(*) as count FROM (
+                        SELECT DISTINCT ec.entity_id
+                        FROM entity_components ec 
+                        WHERE ${this.withId ? db`ec.entity_id = ${this.withId} AND ` : db``} NOT EXISTS (
+                            SELECT 1 FROM entity_components ec_ex 
+                            WHERE ec_ex.entity_id = ec.entity_id AND ec_ex.type_id IN ${db.unsafe(onlyExcludedIdsString.sql, onlyExcludedIdsString.params)} AND ec_ex.deleted_at IS NULL
+                        )
+                        AND ec.deleted_at IS NULL
+                    ) as subquery
+                `;
+                const onlyExcludedResult = await onlyExcludedQuery;
+                return parseInt(onlyExcludedResult[0].count);
+            default:
+                return 0;
+        }
+    }
+
+    private async getCountWithFilters(componentIds: string[], componentCount: number): Promise<number> {
+        let params: any[] = [];
+        let paramIndex = 1;
+        const compIds = inList(componentIds, paramIndex);
+        params.push(...compIds.params);
+        paramIndex = compIds.newParamIndex;
+
+        const joins: string[] = [];
+        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 = $${paramIndex} AND ${alias}.deleted_at IS NULL`);
+                params.push(typeId);
+                paramIndex++;
+                joinIndex++;
+            }
+        }
+
+        let sql: string = `SELECT COUNT(*) as count FROM (SELECT DISTINCT ec.entity_id FROM entity_components ec ${joins.join(' ')} WHERE ec.type_id IN ${compIds.sql} AND ec.deleted_at IS NULL`;
+
+        if (this.withId) {
+            sql += ` AND ec.entity_id = $${paramIndex}`;
+            params.push(this.withId);
+            paramIndex++;
+        }
+
+        joinIndex = 0;
+        for (const [typeId, filters] of this.componentFilters.entries()) {
+            if (componentIds.includes(typeId)) {
+                const alias = `c${joinIndex}`;
+                const filterConditions = this.buildFilterWhereClause(typeId, filters, alias, paramIndex);
+                if (filterConditions.sql) {
+                    sql += ` AND ${filterConditions.sql}`;
+                    params.push(...filterConditions.params);
+                    paramIndex = filterConditions.newParamIndex;
+                }
+                joinIndex++;
+            }
+        }
+
+        sql += ` GROUP BY ec.entity_id HAVING COUNT(DISTINCT ec.type_id) = $${paramIndex}) as subquery`;
+        params.push(componentCount);
+
+        const filteredResult = await db.unsafe(sql, params);
+        return parseInt(filteredResult[0].count);
+    }
+
+    private async getCountWithFiltersAndExclusions(componentIds: string[], excludedIds: string[], componentCount: number): Promise<number> {
+        const entityIds = await this.getIdsWithFilters(componentIds, componentCount);
+        
+        if (entityIds.length === 0) {
+            return 0;
+        }
+        
+        const idsList = sql(entityIds);
+        const excludedList = inList(excludedIds, 1);
+        const query = db`
+            SELECT COUNT(*) as count FROM (
+                WITH entity_list AS (
+                    SELECT unnest(${idsList}) 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 ${db.unsafe(excludedList.sql, excludedList.params)} AND ec.deleted_at IS NULL
+                )
+            ) as subquery
+        `;
+        const exclusionResult = await query;
+        return parseInt(exclusionResult[0].count);
+    }
 }
 
 export default Query;

package/core/RequestLoaders.ts

@@ -2,9 +2,12 @@ import DataLoader from 'dataloader';
 import { Entity } from './Entity';
 import db from '../database';
 import { inList } from '../database/sqlHelpers';
+import {logger as MainLogger} from './Logger';
+const logger = MainLogger.child({ module: 'RequestLoaders' });
+import { getMetadataStorage } from './metadata';
 
 export type ComponentData = {
-  typeId: number;
+  typeId: string;
   data: any;
   createdAt: Date;
   updatedAt: Date;
@@ -13,7 +16,8 @@ export type ComponentData = {
 
 export type RequestLoaders = {
   entityById: DataLoader<string, Entity | null>;
-  componentsByEntityType: DataLoader<{ entityId: string; typeId: number }, ComponentData | null>;
+  componentsByEntityType: DataLoader<{ entityId: string; typeId: string }, ComponentData | null>;
+  relationsByEntityField: DataLoader<{ entityId: string; relationField: string; relatedType: string; foreignKey?: string }, Entity[]>;
 };
 
 export function createRequestLoaders(db: any): RequestLoaders {
@@ -21,12 +25,13 @@ export function createRequestLoaders(db: any): RequestLoaders {
     const startTime = Date.now();
     try {
       const uniqueIds = [...new Set(ids)];
-      const rows = await db`
+      const idList = inList(uniqueIds, 1);
+      const rows = await db.unsafe(`
         SELECT id
         FROM entities
-        WHERE id IN ${inList(uniqueIds, 1)}
+        WHERE id IN ${idList.sql}
           AND deleted_at IS NULL
-      `;
+      `, idList.params);
       const entities = rows.map((row: any) => {
         const entity = new Entity(row.id);
         entity.setPersisted(true);
@@ -47,19 +52,21 @@ export function createRequestLoaders(db: any): RequestLoaders {
     }
   });
 
-  const componentsByEntityType = new DataLoader<{ entityId: string; typeId: number }, ComponentData | null>(
-    async (keys: readonly { entityId: string; typeId: number }[]) => {
+  const componentsByEntityType = new DataLoader<{ entityId: string; typeId: string }, ComponentData | null>(
+    async (keys: readonly { entityId: string; typeId: string }[]) => {
       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`
+        const entityIdList = inList(entityIds, 1);
+        const typeIdList = inList(typeIds, entityIdList.newParamIndex);
+        const rows = await db.unsafe(`
           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)}
+          WHERE entity_id IN ${entityIdList.sql}
+            AND type_id IN ${typeIdList.sql}
             AND deleted_at IS NULL
-        `;
+        `, [...entityIdList.params, ...typeIdList.params]);
         const map = new Map<string, ComponentData>();
         rows.forEach((row: any) => {
           const key = `${row.entity_id}-${row.type_id}`;
@@ -85,5 +92,87 @@ export function createRequestLoaders(db: any): RequestLoaders {
     }
   );
 
-  return { entityById, componentsByEntityType };
+  const relationsByEntityField = new DataLoader<{ entityId: string; relationField: string; relatedType: string; foreignKey?: string }, Entity[]>(
+    async (keys: readonly { entityId: string; relationField: string; relatedType: string; foreignKey?: string }[]) => {
+      const startTime = Date.now();
+      try {
+        // Group keys by relation type for efficient querying
+        const resultMap = new Map<string, Entity[]>();
+        
+        // For each key, find related entities based on foreign key relationships
+        for (const key of keys) {
+          let relatedEntities: Entity[] = [];
+          
+          try {
+            logger.trace(`[RelationLoader] Looking for ${key.relatedType} entities with foreign key ${key.foreignKey || 'auto-detect'} pointing to ${key.entityId} for field ${key.relationField}`);
+
+            let whereClause: string;
+            if (key.foreignKey) {
+              // Use specific foreign key from relation metadata
+              whereClause = `(c.data->>'${key.foreignKey}' = $1)`;
+            } else {
+              // Fallback to common patterns for backward compatibility
+              // TODO: Remove this fallback in future versions
+              whereClause = `(
+                (c.data->>'user_id' = $1) OR
+                (c.data->>'parent_id' = $1)
+              )`;
+            }
+            
+            // Look for entities that have components with foreign keys pointing to our entity
+            const rows = await db.unsafe(`
+              SELECT DISTINCT c.entity_id, c.data, c.type_id
+              FROM components c
+              INNER JOIN entities e ON c.entity_id = e.id
+              WHERE e.deleted_at IS NULL 
+                AND c.deleted_at IS NULL
+                AND ${whereClause}
+            `, [key.entityId]);
+
+            logger.trace(`[RelationLoader] Found ${rows.length} components with foreign keys pointing to ${key.entityId}`);
+            rows.forEach((row: any) => {
+              logger.trace(`[RelationLoader] Component ${row.type_id} on entity ${row.entity_id}:`, row.data);
+            });
+            
+            // Create Entity objects for each related entity
+            const entityIds = [...new Set(rows.map((row: any) => row.entity_id as string))];
+            relatedEntities = entityIds.map((id: string) => {
+              const entity = new Entity(id);
+              entity.setPersisted(true);
+              return entity;
+            });
+
+            logger.trace(`[RelationLoader] Created ${relatedEntities.length} related entities for ${key.relationField}`);
+
+          } catch (queryError) {
+            logger.error(`Error querying relations for ${key.entityId}:`);
+            logger.error(queryError);
+            relatedEntities = [];
+          }
+          
+          const mapKey = `${key.entityId}-${key.relationField}-${key.relatedType}`;
+          resultMap.set(mapKey, relatedEntities);
+        }
+        
+        const duration = Date.now() - startTime;
+        if (duration > 1000) {
+          logger.warn(`Slow relationsByEntityField query: ${duration}ms for ${keys.length} keys`);
+        }
+        
+        return keys.map(k => {
+          const mapKey = `${k.entityId}-${k.relationField}-${k.relatedType}`;
+          const result = resultMap.get(mapKey) || [];
+          logger.trace(`[RelationLoader] Returning ${result.length} entities for ${k.relationField} on ${k.entityId}`);
+          return result;
+        });
+      } catch (error) {
+        logger.error(`Error in relationsByEntityField DataLoader:`);
+        logger.error(error);
+        // Return empty arrays for all keys on error
+        return keys.map(() => []);
+      }
+    }
+  );
+
+  return { entityById, componentsByEntityType, relationsByEntityField };
 }

package/core/SchedulerManager.ts

@@ -685,10 +685,9 @@ export class SchedulerManager {
 
         // Handle excluded components
         if (componentTarget.excludeComponents && componentTarget.excludeComponents.length > 0) {
-            // Note: The current Query API might not directly support exclusion
-            // This would require extending the Query API or using post-filtering
-            // For now, we'll log a warning and continue
-            loggerInstance.warn('excludeComponents is not fully supported in scheduled tasks yet. Consider using post-query filtering.');
+            for(const component of componentTarget.excludeComponents){
+                query = query.without(component);
+            }
         }
 
         return query;

package/core/metadata/definitions/ArcheType.ts

@@ -0,0 +1,9 @@
+export interface ArcheTypeMetadata {
+    name: string;
+    target: Function;
+    typeId: string;
+}
+
+export interface ArcheTypeFieldOptions {
+    nullable?: boolean;
+}

package/core/metadata/definitions/Component.ts

@@ -0,0 +1,16 @@
+export interface ComponentMetadata {
+    name: string;
+    typeId: string;
+    target: Function;
+}
+
+export interface ComponentPropertyMetadata {
+    propertyKey: string;
+    propertyType?: any;
+    component_id: string;
+    indexed: boolean;
+    isPrimitive: boolean;
+    isEnum: boolean;
+    enumValues?: string[];
+    enumKeys?: string[];
+}

package/core/metadata/definitions/gqlObject.ts

@@ -0,0 +1,10 @@
+import {
+    GraphQLScalar,
+    type GraphQLObject,
+    type GraphQLField
+} from "gql/types"
+
+export interface GQLObjectMetaData {
+    name: string;
+    fields: GraphQLField[];
+}

package/core/metadata/getMetadataStorage.ts

@@ -0,0 +1,14 @@
+import { MetadataStorage } from "./metadata-storage";
+
+declare global {
+  // eslint-disable-next-line vars-on-top, no-var
+  var BunsaneMetadataStorage: MetadataStorage;
+}
+
+export function getMetadataStorage(): MetadataStorage {
+  if (!global.BunsaneMetadataStorage) {
+    global.BunsaneMetadataStorage = new MetadataStorage();
+  }
+
+  return global.BunsaneMetadataStorage;
+}

package/core/metadata/index.ts

@@ -0,0 +1,17 @@
+import "reflect-metadata";
+export {getMetadataStorage} from "./getMetadataStorage";
+export function Enum() {
+    return (target: any) => {
+        Reflect.defineMetadata("isEnum", true, target);
+        const staticKeys = Object.getOwnPropertyNames(target).filter(key => 
+            key !== 'prototype' && 
+            key !== 'length' && 
+            key !== 'name' && 
+            typeof target[key] !== 'function'
+        );
+        if (staticKeys.length > 0) {
+            Reflect.defineMetadata("__enumValues", staticKeys.map(key => target[key]), target);
+            Reflect.defineMetadata("__enumKeys", staticKeys, target);
+        }
+    };
+}

package/core/metadata/metadata-storage.ts

@@ -0,0 +1,81 @@
+import { createHash } from 'crypto';
+import type { 
+    ComponentMetadata,
+    ComponentPropertyMetadata
+ } from "./definitions/Component";
+import type { ArcheTypeMetadata, ArcheTypeFieldOptions } from './definitions/ArcheType';
+import type { RelationOptions } from '../ArcheType';
+
+function generateTypeId(name: string): string {
+  return createHash('sha256').update(name).digest('hex');
+}
+
+type ArcheTypeRelationMap = {fieldName: string, relatedArcheType: new (...args: any[]) => any | string, relationType: 'hasMany' | 'belongsTo' | 'hasOne' | 'belongsToMany', options?: RelationOptions, type?: any}
+type ArcheTypeFieldMap = {fieldName: string, component: new (...args: any[]) => any, options?: ArcheTypeFieldOptions, type?: any};
+type ArcheTypeUnionMap = {fieldName: string, components: (new (...args:any[]) => any)[], options?: ArcheTypeFieldOptions, type?:any};
+export class MetadataStorage {
+    components_ids_map: Map<string, string> = new Map();
+    components: ComponentMetadata[] = [];
+    components_map: Map<string, ComponentMetadata> = new Map();
+    componentProperties: Map<string, ComponentPropertyMetadata[]> = new Map();
+    archetypes: ArcheTypeMetadata[] = [];
+    archetypes_field_map: Map<string, ArcheTypeFieldMap[]> = new Map();
+    archetypes_relations_map: Map<string, ArcheTypeRelationMap[]> = new Map();
+    archetypes_union_map: Map<string, ArcheTypeUnionMap[]> = new Map();
+
+
+    graphql_types: Map<string, any> = new Map();
+
+    getComponentId(componentName: string): string {
+        if(this.components_ids_map.has(componentName)) {
+            return this.components_ids_map.get(componentName)!;
+        }
+        const typeId = generateTypeId(componentName);
+        this.components_ids_map.set(componentName, typeId);
+        return typeId;
+    }
+
+    collectComponentMetadata(metadata: ComponentMetadata) {
+        this.components.push(metadata);
+        this.components_map.set(metadata.name, metadata);
+    }
+
+
+    collectComponentPropertyMetadata(metadata: ComponentPropertyMetadata ) {
+        if(!this.componentProperties.has(metadata.component_id)) {
+            this.componentProperties.set(metadata.component_id, []);
+        }
+        this.componentProperties.get(metadata.component_id)!.push(metadata);
+    }
+
+
+    getComponentProperties(component_id: string): ComponentPropertyMetadata[] {
+        return this.componentProperties.get(component_id) || [];
+    }
+
+    collectArchetypeField(archetype_id: string, fieldName: string, component: new (...args: any[]) => any, options?: ArcheTypeFieldOptions, type?: any) {
+        if(!this.archetypes_field_map.has(archetype_id)) {
+            this.archetypes_field_map.set(archetype_id, []);
+        }
+        this.archetypes_field_map.get(archetype_id)!.push({fieldName, component, options, type});
+    }
+
+    collectArchetypeUnion(archetype_id: string, fieldName: string, components: (new (...args: any[]) => any)[], options?: ArcheTypeFieldOptions, type?: any) {
+        if(!this.archetypes_union_map.has(archetype_id)) {
+            this.archetypes_union_map.set(archetype_id, []);
+        }
+        this.archetypes_union_map.get(archetype_id)!.push({fieldName, components, options, type});
+    }
+
+    collectArchetypeRelation(archetype_id: string, fieldName: string, relatedArcheType: new (...args: any[]) => any | string, relationType: 'hasMany' | 'belongsTo' | 'hasOne' | 'belongsToMany', options?: RelationOptions, type?: any) {
+        if(!this.archetypes_relations_map.has(archetype_id)) {
+            this.archetypes_relations_map.set(archetype_id, []);
+        }
+        this.archetypes_relations_map.get(archetype_id)!.push({fieldName, relatedArcheType, relationType, options, type});
+    }
+
+    collectArcheTypeMetadata(metadata: ArcheTypeMetadata) {
+        this.archetypes.push(metadata);
+    }
+}
+

package/database/DatabaseHelper.ts

@@ -91,7 +91,6 @@ export const GetDatabaseDataSize = async () => {
 
 
 export const SetupDatabaseExtensions = async () => {
-    // await db`CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`;
 }
 
 export const CreateEntityTable = async () => {
@@ -173,16 +172,17 @@ export const UpdateComponentIndexes = async (table_name: string, indexedProperti
     }
 }
 
-
-export const CreateComponentPartitionTable = async (comp_name: string, type_id: string, indexedProperties?: string[]) => {
+//TODO: Cleanup and optimize
+export const CreateComponentPartitionTable = async (comp_name: string, type_id: string) => {
     try {
         comp_name = validateIdentifier(comp_name);
-        // type_id is a value, not identifier, so no validation
-        if (indexedProperties) {
-            indexedProperties = indexedProperties.map(prop => validateIdentifier(prop));
-        }
+        // // type_id is a value, not identifier, so no validation
+        // if (indexedProperties) {
+        //     indexedProperties = indexedProperties.map(prop => validateIdentifier(prop));
+        // }
         logger.trace(`Attempt adding partition table for component: ${comp_name}`);
-        const table_name = `components_${comp_name.toLowerCase().replace(/\s+/g, '_')}`;
+        // const table_name = `components_${comp_name.toLowerCase().replace(/\s+/g, '_')}`;
+        const table_name = GenerateTableName(comp_name);
         logger.trace(`Checking for existing partition table: ${table_name}`);
         const existingPartition = await db.unsafe(`SELECT 1 FROM information_schema.tables 
             WHERE table_name = '${table_name}' 
@@ -202,16 +202,17 @@ export const CreateComponentPartitionTable = async (comp_name: string, type_id:
         });
         logger.trace(`Successfully created partition table: ${table_name}`);
 
-        if (BUNSANE_RELATION_TYPED_COLUMN && indexedProperties?.includes('value')) {
-            logger.trace(`Adding typed FK column for ${table_name}`);
-            await retryWithBackoff(async () => {
-                await db.unsafe(`ALTER TABLE ${table_name} ADD COLUMN IF NOT EXISTS fk_id UUID GENERATED ALWAYS AS ((data->>'value')::UUID) STORED`);
-            });
-            await retryWithBackoff(async () => {
-                await db.unsafe(`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_${table_name}_fk_id ON ${table_name} (fk_id)`);
-            });
-            logger.trace(`Added fk_id column and index for ${table_name}`);
-        }
+        // TODO: Not sure if this is needed here or should be handled separately
+        // if (BUNSANE_RELATION_TYPED_COLUMN && indexedProperties?.includes('value')) {
+        //     logger.trace(`Adding typed FK column for ${table_name}`);
+        //     await retryWithBackoff(async () => {
+        //         await db.unsafe(`ALTER TABLE ${table_name} ADD COLUMN IF NOT EXISTS fk_id UUID GENERATED ALWAYS AS ((data->>'value')::UUID) STORED`);
+        //     });
+        //     await retryWithBackoff(async () => {
+        //         await db.unsafe(`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_${table_name}_fk_id ON ${table_name} (fk_id)`);
+        //     });
+        //     logger.trace(`Added fk_id column and index for ${table_name}`);
+        // }
         
     } catch (error) {
         logger.error(`Failed to create component partition table for ${comp_name}: ${error}`);
@@ -257,7 +258,8 @@ export const CreateEntityComponentTable = async () => {
     await db`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_entity_components_type_id ON entity_components (type_id);`
     await db`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_entity_components_type_entity ON entity_components (type_id, entity_id);`
 
-    // Phase 2A: Add composite indexes for sorting optimization
     await db`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_entity_components_type_entity_deleted ON entity_components (type_id, entity_id, deleted_at);`
     await db`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_entity_components_deleted_type ON entity_components (deleted_at, type_id) WHERE deleted_at IS NULL;`
-}
+}
+
+export const GenerateTableName = (name: string) => `components_${name.toLowerCase().replace(/\s+/g, '_')}`;

package/database/index.ts

@@ -1,8 +1,13 @@
 import {SQL} from "bun";
 import { logger } from "core/Logger";
 
+let connectionUrl = `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@${process.env.POSTGRES_HOST}:${process.env.POSTGRES_PORT ?? "5432"}/${process.env.POSTGRES_DB}`;
+if(process.env.DB_CONNECTION_URL) {
+    connectionUrl = process.env.DB_CONNECTION_URL;
+}
+logger.info(`Database connection URL: ${connectionUrl}`);
 const db = new SQL({
-    url: `postgres://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASSWORD}@${process.env.POSTGRES_HOST}:${process.env.POSTGRES_PORT ?? "5432"}/${process.env.POSTGRES_DB}`,
+    url: connectionUrl,
     // 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)

package/database/sqlHelpers.ts

@@ -1,5 +1,3 @@
-import { sql } from 'bun';
-
 export function inList<T>(values: T[], paramIndex: number): { sql: string, params: any[], newParamIndex: number } {
   if (values.length === 0) return { sql: '()', params: [], newParamIndex: paramIndex };
   const placeholders = Array.from({length: values.length}, (_, i) => `$${paramIndex + i}`).join(', ');