noormme 1.0.0

package/dist/esm/relationships/relationship-engine.js

@@ -0,0 +1,203 @@
+/// <reference types="./relationship-engine.d.ts" />
+/**
+ * Relationship engine that handles foreign key relationships
+ */
+export class RelationshipEngine {
+    db;
+    config;
+    relationships = [];
+    constructor(db, config = {}) {
+        this.db = db;
+        this.config = config;
+    }
+    /**
+     * Initialize the relationship engine with schema relationships
+     */
+    initialize(relationships) {
+        this.relationships = relationships;
+    }
+    /**
+     * Load relationships for entities
+     */
+    async loadRelationships(entities, relations) {
+        if (!this.config.enableBatchLoading) {
+            // Load relationships one by one
+            for (const entity of entities) {
+                await this.loadEntityRelationships(entity, relations);
+            }
+            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);
+        }
+    }
+    /**
+     * Load relationships for a single entity
+     */
+    async loadEntityRelationships(entity, relations) {
+        for (const relationName of relations) {
+            const relationship = this.relationships.find(r => r.name === relationName);
+            if (!relationship)
+                continue;
+            await this.loadSingleRelationship(entity, relationship);
+        }
+    }
+    /**
+     * Batch load relationships for multiple entities
+     */
+    async batchLoadRelationships(entities, relations) {
+        for (const relationName of relations) {
+            const relationship = this.relationships.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)
+                    .executeTakeFirst();
+                break;
+            case 'one-to-many':
+                relatedData = await this.db
+                    .selectFrom(relationship.toTable)
+                    .selectAll()
+                    .where(relationship.fromColumn, '=', entityValue)
+                    .execute();
+                break;
+            case 'many-to-many':
+                relatedData = await this.loadManyToManyRelationship(entity, relationship);
+                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)
+                    .selectAll()
+                    .where(relationship.fromColumn, 'in', entityValues)
+                    .execute();
+                break;
+            case 'many-to-many':
+                relatedData = await this.batchLoadManyToManyRelationship(entities, relationship);
+                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];
+                }
+                else {
+                    entityRelatedData = groupedData.get(entityValue) || [];
+                }
+                entity[relationship.name] = entityRelatedData;
+            }
+        }
+    }
+    /**
+     * Load many-to-many relationship
+     */
+    async loadManyToManyRelationship(entity, relationship) {
+        if (!relationship.throughTable) {
+            throw new Error('Many-to-many relationship requires throughTable');
+        }
+        const entityValue = entity[relationship.fromColumn];
+        if (!entityValue)
+            return [];
+        return await this.db
+            .selectFrom(relationship.toTable)
+            .innerJoin(relationship.throughTable, relationship.throughToColumn, `${relationship.toTable}.${relationship.toColumn}`)
+            .where(relationship.throughFromColumn, '=', entityValue)
+            .selectAll(relationship.toTable)
+            .execute();
+    }
+    /**
+     * Batch load many-to-many relationships
+     */
+    async batchLoadManyToManyRelationship(entities, relationship) {
+        if (!relationship.throughTable) {
+            throw new Error('Many-to-many relationship requires throughTable');
+        }
+        const entityValues = entities
+            .map(e => e[relationship.fromColumn])
+            .filter(v => v !== undefined && v !== null);
+        if (entityValues.length === 0)
+            return [];
+        return await this.db
+            .selectFrom(relationship.toTable)
+            .innerJoin(relationship.throughTable, relationship.throughToColumn, `${relationship.toTable}.${relationship.toColumn}`)
+            .where(relationship.throughFromColumn, 'in', entityValues)
+            .selectAll(relationship.toTable)
+            .execute();
+    }
+    /**
+     * Get relationships for a specific table
+     */
+    getRelationshipsForTable(tableName) {
+        return this.relationships.filter(r => r.fromTable === tableName);
+    }
+    /**
+     * Get all relationships
+     */
+    getAllRelationships() {
+        return [...this.relationships];
+    }
+    /**
+     * Add a new relationship
+     */
+    addRelationship(relationship) {
+        this.relationships.push(relationship);
+    }
+    /**
+     * Remove a relationship
+     */
+    removeRelationship(relationshipName) {
+        this.relationships = this.relationships.filter(r => r.name !== relationshipName);
+    }
+}

package/dist/esm/repository/repository-factory.d.ts

@@ -0,0 +1,54 @@
+import type { Kysely } from '../kysely.js';
+import { TableInfo, RelationshipInfo, Repository, PerformanceConfig } from '../types';
+/**
+ * Repository factory that creates dynamic repository classes
+ */
+export declare class RepositoryFactory {
+    private db;
+    private config;
+    constructor(db: Kysely<any>, config?: PerformanceConfig);
+    /**
+     * Create a repository for the specified table
+     */
+    createRepository<T>(table: TableInfo, relationships: RelationshipInfo[]): Repository<T>;
+    /**
+     * Add custom finder methods to repository
+     */
+    private addCustomFinders;
+    /**
+     * Load relationships for entities
+     */
+    private loadRelationships;
+    /**
+     * Load relationships for a single entity
+     */
+    private loadEntityRelationships;
+    /**
+     * Batch load relationships for multiple entities
+     */
+    private batchLoadRelationships;
+    /**
+     * Load a single relationship for an entity
+     */
+    private loadSingleRelationship;
+    /**
+     * Batch load a single relationship for multiple entities
+     */
+    private batchLoadSingleRelationship;
+    /**
+     * Get primary key condition for queries
+     */
+    private getPrimaryKeyCondition;
+    /**
+     * Get primary key value from entity
+     */
+    private getPrimaryKeyValue;
+    /**
+     * Get update data (exclude primary key)
+     */
+    private getUpdateData;
+    /**
+     * Convert string to PascalCase
+     */
+    private toPascalCase;
+}

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

@@ -0,0 +1,446 @@
+/// <reference types="./repository-factory.d.ts" />
+import { NoormError, RelationshipNotFoundError } from '../errors/NoormError.js';
+import { wrapKyselyError } from '../utils/errorHelpers.js';
+/**
+ * Repository factory that creates dynamic repository classes
+ */
+export class RepositoryFactory {
+    db;
+    config;
+    constructor(db, config = {}) {
+        this.db = db;
+        this.config = config;
+    }
+    /**
+     * Create a repository for the specified table
+     */
+    createRepository(table, relationships) {
+        const repository = {
+            // Basic CRUD operations
+            findById: async (id) => {
+                try {
+                    const result = 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
+                        .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
+                        .insertInto(table.name)
+                        .values(data)
+                        .returningAll()
+                        .executeTakeFirstOrThrow();
+                    return result;
+                }
+                catch (error) {
+                    throw wrapKyselyError(error, {
+                        table: table.name,
+                        operation: 'create',
+                        availableColumns: table.columns.map(c => c.name)
+                    });
+                }
+            },
+            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;
+                }
+                catch (error) {
+                    throw wrapKyselyError(error, {
+                        table: table.name,
+                        operation: 'update',
+                        availableColumns: table.columns.map(c => c.name)
+                    });
+                }
+            },
+            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)
+                    });
+                }
+            },
+            // 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;
+            },
+            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);
+            },
+            // Pagination helper
+            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);
+                    }
+                    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));
+                        }
+                        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)
+                    });
+                }
+            },
+            // 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;
+                };
+            }
+        }
+        // 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
+                    .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)
+                    .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)
+                    .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];
+                }
+                else {
+                    entityRelatedData = groupedData.get(entityValue) || [];
+                }
+                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];
+            }
+            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}`);
+    }
+    /**
+     * Get update data (exclude primary key)
+     */
+    getUpdateData(table, entity) {
+        const updateData = {};
+        for (const column of table.columns) {
+            if (!table.primaryKey?.includes(column.name)) {
+                updateData[column.name] = entity[column.name];
+            }
+        }
+        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, '');
+    }
+}