noormme 1.0.0 → 1.0.2

package/dist/esm/repository/repository-factory.js

@@ -1,446 +1,328 @@
 /// <reference types="./repository-factory.d.ts" />
-import { NoormError, RelationshipNotFoundError } from '../errors/NoormError.js';
-import { wrapKyselyError } from '../utils/errorHelpers.js';
+import { RelationshipNotFoundError, ColumnNotFoundError } from '../errors/NoormError.js';
 /**
- * Repository factory that creates dynamic repository classes
+ * Simple repository factory for creating table repositories
  */
 export class RepositoryFactory {
     db;
-    config;
-    constructor(db, config = {}) {
+    performanceConfig;
+    constructor(db, performanceConfig) {
         this.db = db;
-        this.config = config;
+        this.performanceConfig = performanceConfig;
+    }
+    /**
+     * Transform boolean columns from SQLite integers (0/1) to JavaScript booleans
+     */
+    transformBooleans(data, table) {
+        // Find all boolean columns
+        const booleanColumns = table.columns
+            .filter(col => col.type === 'boolean')
+            .map(col => col.name);
+        if (booleanColumns.length === 0) {
+            return data;
+        }
+        const transformRecord = (record) => {
+            if (!record || typeof record !== 'object') {
+                return record;
+            }
+            const transformed = { ...record };
+            for (const col of booleanColumns) {
+                if (col in transformed) {
+                    // Convert 0/1 to false/true
+                    transformed[col] = Boolean(transformed[col]);
+                }
+            }
+            return transformed;
+        };
+        if (Array.isArray(data)) {
+            return data.map(transformRecord);
+        }
+        return transformRecord(data);
     }
     /**
      * Create a repository for the specified table
      */
     createRepository(table, relationships) {
+        // Determine the primary key column name
+        const primaryKey = table.columns.find(c => c.isPrimaryKey)?.name || 'id';
         const repository = {
-            // Basic CRUD operations
-            findById: async (id) => {
-                try {
-                    const result = await this.db
+            // Django-style objects wrapper
+            objects: {
+                all: async () => {
+                    return await this.db
                         .selectFrom(table.name)
                         .selectAll()
-                        .where(this.getPrimaryKeyCondition(table, id))
-                        .executeTakeFirst();
-                    return result;
-                }
-                catch (error) {
-                    throw wrapKyselyError(error, {
-                        table: table.name,
-                        operation: 'findById',
-                        availableColumns: table.columns.map(c => c.name)
-                    });
-                }
-            },
-            findAll: async () => {
-                try {
-                    const results = await this.db
+                        .execute();
+                },
+                get: async (id) => {
+                    return await this.db
                         .selectFrom(table.name)
                         .selectAll()
-                        .execute();
-                    return results;
-                }
-                catch (error) {
-                    throw wrapKyselyError(error, {
-                        table: table.name,
-                        operation: 'findAll',
-                        availableColumns: table.columns.map(c => c.name)
-                    });
-                }
-            },
-            create: async (data) => {
-                try {
-                    const result = await this.db
+                        .where(primaryKey, '=', id)
+                        .executeTakeFirst();
+                },
+                create: async (data) => {
+                    return await this.db
                         .insertInto(table.name)
                         .values(data)
                         .returningAll()
-                        .executeTakeFirstOrThrow();
-                    return result;
+                        .executeTakeFirst();
+                },
+                update: async (id, data) => {
+                    return await this.db
+                        .updateTable(table.name)
+                        .set(data)
+                        .where(primaryKey, '=', id)
+                        .returningAll()
+                        .executeTakeFirst();
+                },
+                delete: async (id) => {
+                    return await this.db
+                        .deleteFrom(table.name)
+                        .where(primaryKey, '=', id)
+                        .executeTakeFirst();
                 }
-                catch (error) {
-                    throw wrapKyselyError(error, {
-                        table: table.name,
-                        operation: 'create',
-                        availableColumns: table.columns.map(c => c.name)
-                    });
+            },
+            // Direct CRUD methods
+            findById: async (id) => {
+                const result = await this.db
+                    .selectFrom(table.name)
+                    .selectAll()
+                    .where(primaryKey, '=', id)
+                    .executeTakeFirst();
+                return (result ? this.transformBooleans(result, table) : null);
+            },
+            findAll: async () => {
+                const results = await this.db
+                    .selectFrom(table.name)
+                    .selectAll()
+                    .execute();
+                return this.transformBooleans(results, table);
+            },
+            create: async (data) => {
+                const result = await this.db
+                    .insertInto(table.name)
+                    .values(data)
+                    .returningAll()
+                    .executeTakeFirst();
+                if (!result) {
+                    throw new Error(`Failed to create entity in table ${table.name}`);
                 }
+                return result;
             },
             update: async (entity) => {
-                try {
-                    const primaryKeyValue = this.getPrimaryKeyValue(table, entity);
-                    const updateData = this.getUpdateData(table, entity);
-                    const result = await this.db
-                        .updateTable(table.name)
-                        .set(updateData)
-                        .where(this.getPrimaryKeyCondition(table, primaryKeyValue))
-                        .returningAll()
-                        .executeTakeFirstOrThrow();
-                    return result;
+                const id = entity[primaryKey];
+                if (id === undefined) {
+                    throw new Error(`Cannot update entity: missing primary key '${primaryKey}'. ` +
+                        `Please ensure the entity has a '${primaryKey}' property.`);
                 }
-                catch (error) {
-                    throw wrapKyselyError(error, {
-                        table: table.name,
-                        operation: 'update',
-                        availableColumns: table.columns.map(c => c.name)
-                    });
+                const result = await this.db
+                    .updateTable(table.name)
+                    .set(entity)
+                    .where(primaryKey, '=', id)
+                    .returningAll()
+                    .executeTakeFirst();
+                if (!result) {
+                    throw new Error(`Failed to update entity with ${primaryKey}=${id} in table ${table.name}. ` +
+                        `Entity may not exist.`);
                 }
+                return result;
             },
             delete: async (id) => {
-                try {
-                    const result = await this.db
-                        .deleteFrom(table.name)
-                        .where(this.getPrimaryKeyCondition(table, id))
-                        .execute();
-                    return result.length > 0;
-                }
-                catch (error) {
-                    throw wrapKyselyError(error, {
-                        table: table.name,
-                        operation: 'delete',
-                        availableColumns: table.columns.map(c => c.name)
-                    });
-                }
+                const result = await this.db
+                    .deleteFrom(table.name)
+                    .where(primaryKey, '=', id)
+                    .execute();
+                return result.length > 0 && Number(result[0].numDeletedRows) > 0;
             },
-            // Relationship operations
-            findWithRelations: async (id, relations) => {
-                const entity = await repository.findById(id);
-                if (!entity)
-                    return null;
-                // Validate relationships exist
-                for (const relationName of relations) {
-                    const relationship = relationships.find(r => r.name === relationName);
-                    if (!relationship) {
-                        throw new RelationshipNotFoundError(relationName, table.name, relationships.map(r => r.name));
-                    }
-                }
-                await this.loadRelationships([entity], relations, relationships);
-                return entity;
+            // Utility methods
+            count: async () => {
+                const result = await this.db
+                    .selectFrom(table.name)
+                    .select((eb) => eb.fn.countAll().as('count'))
+                    .executeTakeFirst();
+                return Number(result?.count || 0);
             },
-            loadRelationships: async (entities, relations) => {
-                // Validate relationships exist
-                for (const relationName of relations) {
-                    const relationship = relationships.find(r => r.name === relationName);
-                    if (!relationship) {
-                        throw new RelationshipNotFoundError(relationName, table.name, relationships.map(r => r.name));
-                    }
-                }
-                await this.loadRelationships(entities, relations, relationships);
+            exists: async (id) => {
+                const result = await this.db
+                    .selectFrom(table.name)
+                    .select(primaryKey)
+                    .where(primaryKey, '=', id)
+                    .executeTakeFirst();
+                return result !== undefined;
             },
-            // Pagination helper
+            // Pagination
             paginate: async (options) => {
-                try {
-                    const { page, limit, where, orderBy } = options;
-                    const offset = (page - 1) * limit;
-                    // Build base query
-                    let query = this.db.selectFrom(table.name);
-                    // Apply where conditions
-                    if (where) {
-                        Object.entries(where).forEach(([key, value]) => {
-                            if (value !== undefined) {
-                                query = query.where(key, '=', value);
-                            }
-                        });
-                    }
-                    // Get total count
-                    const countResult = await query
-                        .select(({ fn }) => [fn.count('*').as('count')])
-                        .executeTakeFirst();
-                    const total = Number(countResult?.count ?? 0);
-                    // Get paginated data
-                    let dataQuery = query.selectAll().limit(limit).offset(offset);
-                    if (orderBy) {
-                        dataQuery = dataQuery.orderBy(orderBy.column, orderBy.direction);
+                let query = this.db.selectFrom(table.name).selectAll();
+                // Apply where conditions
+                if (options.where) {
+                    for (const [key, value] of Object.entries(options.where)) {
+                        if (value !== undefined) {
+                            query = query.where(key, '=', value);
+                        }
                     }
-                    const data = await dataQuery.execute();
-                    return {
-                        data: data,
-                        pagination: {
-                            page,
-                            limit,
-                            total,
-                            totalPages: Math.ceil(total / limit),
-                            hasNext: offset + limit < total,
-                            hasPrev: page > 1,
-                        },
-                    };
-                }
-                catch (error) {
-                    throw wrapKyselyError(error, {
-                        table: table.name,
-                        operation: 'paginate',
-                        availableColumns: table.columns.map(c => c.name)
-                    });
                 }
-            },
-            // Count relationships
-            withCount: async (id, relationshipNames) => {
-                try {
-                    const entity = await repository.findById(id);
-                    if (!entity) {
-                        throw new NoormError(`${table.name} not found with id: ${id}`, {
-                            table: table.name,
-                            operation: 'withCount'
-                        });
-                    }
-                    const counts = {};
-                    for (const relationName of relationshipNames) {
-                        const relationship = relationships.find(r => r.name === relationName);
-                        if (!relationship) {
-                            throw new RelationshipNotFoundError(relationName, table.name, relationships.map(r => r.name));
+                // Count total with same where conditions
+                let countQuery = this.db
+                    .selectFrom(table.name)
+                    .select((eb) => eb.fn.countAll().as('count'));
+                if (options.where) {
+                    for (const [key, value] of Object.entries(options.where)) {
+                        if (value !== undefined) {
+                            countQuery = countQuery.where(key, '=', value);
                         }
-                        const countResult = await this.db
-                            .selectFrom(relationship.toTable)
-                            .where(relationship.toColumn, '=', entity[relationship.fromColumn])
-                            .select(({ fn }) => [fn.count('*').as('count')])
-                            .executeTakeFirst();
-                        counts[`${relationName}Count`] = Number(countResult?.count ?? 0);
                     }
-                    return { ...entity, ...counts };
                 }
-                catch (error) {
-                    if (error instanceof NoormError) {
-                        throw error;
-                    }
-                    throw wrapKyselyError(error, {
-                        table: table.name,
-                        operation: 'withCount',
-                        availableColumns: table.columns.map(c => c.name)
-                    });
+                const countResult = await countQuery.executeTakeFirst();
+                const total = Number(countResult?.count || 0);
+                // Apply order by
+                if (options.orderBy) {
+                    query = query.orderBy(options.orderBy.column, options.orderBy.direction);
                 }
-            },
-            // Count and exists methods (implemented in addCustomFinders)
-            count: async () => 0, // Will be overridden in addCustomFinders
-            exists: async (id) => false // Will be overridden in addCustomFinders
-        };
-        // Add custom finder methods based on table structure
-        this.addCustomFinders(repository, table);
-        return repository;
-    }
-    /**
-     * Add custom finder methods to repository
-     */
-    addCustomFinders(repository, table) {
-        // Add findBy methods for unique columns
-        for (const column of table.columns) {
-            if (column.name !== table.primaryKey?.[0]) {
-                const methodName = `findBy${this.toPascalCase(column.name)}`;
-                repository[methodName] = async (value) => {
-                    const result = await this.db
-                        .selectFrom(table.name)
-                        .selectAll()
-                        .where(column.name, '=', value)
-                        .executeTakeFirst();
-                    return result;
+                // Apply pagination
+                const offset = (options.page - 1) * options.limit;
+                query = query.limit(options.limit).offset(offset);
+                const data = await query.execute();
+                const totalPages = Math.ceil(total / options.limit);
+                const transformedData = this.transformBooleans(data, table);
+                return {
+                    data: transformedData,
+                    pagination: {
+                        page: options.page,
+                        limit: options.limit,
+                        total,
+                        totalPages,
+                        hasNext: options.page < totalPages,
+                        hasPrev: options.page > 1
+                    }
                 };
-            }
-        }
-        // Add findManyBy methods for non-unique columns
-        for (const column of table.columns) {
-            const methodName = `findManyBy${this.toPascalCase(column.name)}`;
-            repository[methodName] = async (value) => {
-                const results = await this.db
+            },
+            // Relationship methods
+            findWithRelations: async (id, relations) => {
+                // Basic implementation - fetches entity without loading relations
+                // Full relationship loading would require additional implementation
+                const result = await this.db
                     .selectFrom(table.name)
                     .selectAll()
-                    .where(column.name, '=', value)
-                    .execute();
-                return results;
-            };
-        }
-        // Add count methods
-        repository.count = async () => {
-            const result = await this.db
-                .selectFrom(table.name)
-                .select(this.db.fn.count('*').as('count'))
-                .executeTakeFirst();
-            return Number(result?.count || 0);
-        };
-        // Add exists method
-        repository.exists = async (id) => {
-            const result = await this.db
-                .selectFrom(table.name)
-                .select(this.db.fn.count('*').as('count'))
-                .where(this.getPrimaryKeyCondition(table, id))
-                .executeTakeFirst();
-            return Number(result?.count || 0) > 0;
-        };
-    }
-    /**
-     * Load relationships for entities
-     */
-    async loadRelationships(entities, relations, allRelationships) {
-        if (!this.config.enableBatchLoading) {
-            // Load relationships one by one
-            for (const entity of entities) {
-                await this.loadEntityRelationships(entity, relations, allRelationships);
-            }
-            return;
-        }
-        // Batch load relationships for performance
-        const batchSize = this.config.maxBatchSize || 100;
-        for (let i = 0; i < entities.length; i += batchSize) {
-            const batch = entities.slice(i, i + batchSize);
-            await this.batchLoadRelationships(batch, relations, allRelationships);
-        }
-    }
-    /**
-     * Load relationships for a single entity
-     */
-    async loadEntityRelationships(entity, relations, allRelationships) {
-        for (const relationName of relations) {
-            const relationship = allRelationships.find(r => r.name === relationName);
-            if (!relationship)
-                continue;
-            await this.loadSingleRelationship(entity, relationship);
-        }
-    }
-    /**
-     * Batch load relationships for multiple entities
-     */
-    async batchLoadRelationships(entities, relations, allRelationships) {
-        for (const relationName of relations) {
-            const relationship = allRelationships.find(r => r.name === relationName);
-            if (!relationship)
-                continue;
-            await this.batchLoadSingleRelationship(entities, relationship);
-        }
-    }
-    /**
-     * Load a single relationship for an entity
-     */
-    async loadSingleRelationship(entity, relationship) {
-        const entityValue = entity[relationship.fromColumn];
-        if (!entityValue)
-            return;
-        let relatedData;
-        switch (relationship.type) {
-            case 'many-to-one':
-                relatedData = await this.db
-                    .selectFrom(relationship.toTable)
-                    .selectAll()
-                    .where(relationship.toColumn, '=', entityValue)
+                    .where(primaryKey, '=', id)
                     .executeTakeFirst();
-                break;
-            case 'one-to-many':
-                relatedData = await this.db
-                    .selectFrom(relationship.toTable)
-                    .selectAll()
-                    .where(relationship.fromColumn, '=', entityValue)
-                    .execute();
-                break;
-            case 'many-to-many':
-                // TODO: Implement many-to-many relationships
-                relatedData = [];
-                break;
-        }
-        entity[relationship.name] = relatedData;
-    }
-    /**
-     * Batch load a single relationship for multiple entities
-     */
-    async batchLoadSingleRelationship(entities, relationship) {
-        const entityValues = entities
-            .map(e => e[relationship.fromColumn])
-            .filter(v => v !== undefined && v !== null);
-        if (entityValues.length === 0)
-            return;
-        let relatedData;
-        switch (relationship.type) {
-            case 'many-to-one':
-                relatedData = await this.db
-                    .selectFrom(relationship.toTable)
-                    .selectAll()
-                    .where(relationship.toColumn, 'in', entityValues)
-                    .execute();
-                break;
-            case 'one-to-many':
-                relatedData = await this.db
-                    .selectFrom(relationship.toTable)
+                return result ?? null;
+            },
+            loadRelationships: async (entities, relations) => {
+                // Stub implementation for relationship loading
+                // Full implementation would load related entities based on relationship definitions
+                // For now, this is a no-op to satisfy the interface
+            },
+            withCount: async (id, relationshipNames) => {
+                // Fetch the base entity
+                const rawEntity = await this.db
+                    .selectFrom(table.name)
                     .selectAll()
-                    .where(relationship.fromColumn, 'in', entityValues)
-                    .execute();
-                break;
-            case 'many-to-many':
-                // TODO: Implement many-to-many relationships
-                relatedData = [];
-                break;
-            default:
-                relatedData = [];
-        }
-        // Group related data by foreign key value
-        const groupedData = new Map();
-        for (const item of relatedData) {
-            const key = item[relationship.toColumn];
-            if (!groupedData.has(key)) {
-                groupedData.set(key, []);
-            }
-            groupedData.get(key).push(item);
-        }
-        // Assign related data to entities
-        for (const entity of entities) {
-            const entityValue = entity[relationship.fromColumn];
-            if (entityValue) {
-                let entityRelatedData;
-                if (relationship.type === 'many-to-one') {
-                    entityRelatedData = groupedData.get(entityValue)?.[0];
+                    .where(primaryKey, '=', id)
+                    .executeTakeFirst();
+                if (!rawEntity) {
+                    throw new Error(`Entity with ${primaryKey}=${id} not found in table ${table.name}`);
                 }
-                else {
-                    entityRelatedData = groupedData.get(entityValue) || [];
+                // Transform booleans in the entity
+                const entity = this.transformBooleans(rawEntity, table);
+                // Filter relationships to only those from this table
+                const tableRelationships = relationships.filter(r => r.fromTable === table.name);
+                const availableRelationshipNames = tableRelationships.map(r => r.name);
+                // Validate all relationships exist before executing queries
+                for (const relationshipName of relationshipNames) {
+                    const relationship = tableRelationships.find(r => r.name === relationshipName);
+                    if (!relationship) {
+                        throw new RelationshipNotFoundError(relationshipName, table.name, availableRelationshipNames);
+                    }
                 }
-                entity[relationship.name] = entityRelatedData;
-            }
-        }
-    }
-    /**
-     * Get primary key condition for queries
-     */
-    getPrimaryKeyCondition(table, id) {
-        if (table.primaryKey && table.primaryKey.length === 1) {
-            return { [table.primaryKey[0]]: id };
-        }
-        // Handle composite primary keys
-        if (table.primaryKey && table.primaryKey.length > 1) {
-            const conditions = {};
-            for (let i = 0; i < table.primaryKey.length; i++) {
-                conditions[table.primaryKey[i]] = id[i];
+                // Create counts object for each relationship
+                const counts = {};
+                for (const relationshipName of relationshipNames) {
+                    // Find the relationship definition for this table
+                    const relationship = tableRelationships.find(r => r.name === relationshipName);
+                    if (relationship) {
+                        // Count related entities based on relationship type
+                        // For one-to-many: count records in toTable where toColumn matches our fromColumn value
+                        // Example: For user.posts, count posts where posts.user_id = user.id
+                        const entityKeyValue = entity[relationship.fromColumn];
+                        // Only count if the foreign key value is not NULL
+                        if (entityKeyValue != null) {
+                            // Build query to count related records
+                            let countQuery = this.db
+                                .selectFrom(relationship.toTable)
+                                .select((eb) => eb.fn.countAll().as('count'))
+                                .where(relationship.toColumn, '=', entityKeyValue);
+                            // Find the related table's foreign keys to exclude orphaned records
+                            // Get all relationships FROM the target table to find its foreign keys
+                            const targetTableInfo = relationships
+                                .filter(r => r.fromTable === relationship.toTable)
+                                .map(r => r.fromColumn);
+                            // Exclude records where any foreign key is NULL (orphaned records)
+                            for (const fkColumn of targetTableInfo) {
+                                countQuery = countQuery.where(fkColumn, 'is not', null);
+                            }
+                            const relatedCount = await countQuery.executeTakeFirst();
+                            // Use camelCase format for count property (e.g., "posts" -> "postsCount")
+                            counts[`${relationshipName}Count`] = Number(relatedCount?.count || 0);
+                        }
+                        else {
+                            // If the foreign key is NULL, count is 0
+                            counts[`${relationshipName}Count`] = 0;
+                        }
+                    }
+                }
+                return { ...entity, ...counts };
             }
-            return conditions;
-        }
-        throw new Error(`No primary key defined for table ${table.name}`);
-    }
-    /**
-     * Get primary key value from entity
-     */
-    getPrimaryKeyValue(table, entity) {
-        if (table.primaryKey && table.primaryKey.length === 1) {
-            return entity[table.primaryKey[0]];
-        }
-        // Handle composite primary keys
-        if (table.primaryKey && table.primaryKey.length > 1) {
-            return table.primaryKey.map(key => entity[key]);
-        }
-        throw new Error(`No primary key defined for table ${table.name}`);
+        };
+        // Wrap repository in Proxy to handle dynamic method calls like findByXxx
+        return this.wrapWithDynamicMethods(repository, table);
     }
     /**
-     * Get update data (exclude primary key)
+     * Wrap repository with Proxy to handle dynamic method calls
      */
-    getUpdateData(table, entity) {
-        const updateData = {};
-        for (const column of table.columns) {
-            if (!table.primaryKey?.includes(column.name)) {
-                updateData[column.name] = entity[column.name];
+    wrapWithDynamicMethods(repository, table) {
+        const availableColumns = table.columns.map(c => c.name);
+        const db = this.db;
+        const transformBooleans = this.transformBooleans.bind(this);
+        return new Proxy(repository, {
+            get(target, prop, receiver) {
+                // Check if property exists on target
+                if (prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                // Handle dynamic findByXxx methods
+                if (typeof prop === 'string' && prop.startsWith('findBy')) {
+                    return async (value) => {
+                        // Extract column name from method name
+                        // findByEmail -> Email -> email
+                        // findByInvalidColumn -> InvalidColumn -> invalid_column
+                        const columnNameRaw = prop.substring(6); // Remove 'findBy'
+                        // Convert from PascalCase to snake_case
+                        // Handle both camelCase and PascalCase
+                        let columnName = columnNameRaw
+                            // Insert underscore before uppercase letters that follow lowercase
+                            .replace(/([a-z])([A-Z])/g, '$1_$2')
+                            // Insert underscore before uppercase letters that follow numbers
+                            .replace(/([0-9])([A-Z])/g, '$1_$2')
+                            // Convert to lowercase
+                            .toLowerCase();
+                        // Check if column exists (case-insensitive)
+                        const columnExists = availableColumns.some(col => col.toLowerCase() === columnName.toLowerCase());
+                        if (!columnExists) {
+                            throw new ColumnNotFoundError(columnName, table.name, availableColumns);
+                        }
+                        // Execute query with the valid column
+                        const actualColumn = availableColumns.find(col => col.toLowerCase() === columnName.toLowerCase());
+                        const result = await db
+                            .selectFrom(table.name)
+                            .selectAll()
+                            .where(actualColumn, '=', value)
+                            .executeTakeFirst();
+                        return transformBooleans(result || null, table);
+                    };
+                }
+                return undefined;
             }
-        }
-        return updateData;
-    }
-    /**
-     * Convert string to PascalCase
-     */
-    toPascalCase(str) {
-        return str
-            .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase())
-            .replace(/\s+/g, '')
-            .replace(/[_-]/g, '');
+        });
     }
 }