noormme 1.0.0

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

@@ -0,0 +1,449 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryFactory = void 0;
+const NoormError_js_1 = require("../errors/NoormError.js");
+const errorHelpers_js_1 = require("../utils/errorHelpers.js");
+/**
+ * Repository factory that creates dynamic repository classes
+ */
+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 (0, errorHelpers_js_1.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 (0, errorHelpers_js_1.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 (0, errorHelpers_js_1.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 (0, errorHelpers_js_1.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 (0, errorHelpers_js_1.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 NoormError_js_1.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 NoormError_js_1.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 (0, errorHelpers_js_1.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_js_1.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 NoormError_js_1.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_js_1.NoormError) {
+                        throw error;
+                    }
+                    throw (0, errorHelpers_js_1.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, '');
+    }
+}
+exports.RepositoryFactory = RepositoryFactory;

package/dist/cjs/schema/builders/alter-column-builder.d.ts

@@ -0,0 +1,53 @@
+import { AlterColumnNode } from '../../operation-node/alter-column-node.js';
+import { OperationNodeSource } from '../../operation-node/operation-node-source.js';
+import { DataTypeExpression } from '../../parser/data-type-parser.js';
+import { DefaultValueExpression } from '../../parser/default-value-parser.js';
+export declare class AlterColumnBuilder {
+    #private;
+    constructor(column: string);
+    setDataType(dataType: DataTypeExpression): AlteredColumnBuilder;
+    setDefault(value: DefaultValueExpression): AlteredColumnBuilder;
+    dropDefault(): AlteredColumnBuilder;
+    setNotNull(): AlteredColumnBuilder;
+    dropNotNull(): AlteredColumnBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+}
+/**
+ * Allows us to force consumers to do exactly one alteration to a column.
+ *
+ * One cannot do no alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .execute() // Property 'execute' does not exist on type 'AlteredColumnBuilder'.
+ * ```
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac) // Type 'AlterColumnBuilder' is not assignable to type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * One cannot do multiple alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac.dropNotNull().setNotNull()) // Property 'setNotNull' does not exist on type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+export declare class AlteredColumnBuilder implements OperationNodeSource {
+    #private;
+    constructor(alterColumnNode: AlterColumnNode);
+    toOperationNode(): AlterColumnNode;
+}
+export type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder;

package/dist/cjs/schema/builders/alter-column-builder.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlteredColumnBuilder = exports.AlterColumnBuilder = void 0;
+const alter_column_node_js_1 = require("../../operation-node/alter-column-node.js");
+const data_type_parser_js_1 = require("../../parser/data-type-parser.js");
+const default_value_parser_js_1 = require("../../parser/default-value-parser.js");
+class AlterColumnBuilder {
+    #column;
+    constructor(column) {
+        this.#column = column;
+    }
+    setDataType(dataType) {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.create(this.#column, 'dataType', (0, data_type_parser_js_1.parseDataTypeExpression)(dataType)));
+    }
+    setDefault(value) {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.create(this.#column, 'setDefault', (0, default_value_parser_js_1.parseDefaultValueExpression)(value)));
+    }
+    dropDefault() {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.create(this.#column, 'dropDefault', true));
+    }
+    setNotNull() {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.create(this.#column, 'setNotNull', true));
+    }
+    dropNotNull() {
+        return new AlteredColumnBuilder(alter_column_node_js_1.AlterColumnNode.create(this.#column, 'dropNotNull', true));
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+}
+exports.AlterColumnBuilder = AlterColumnBuilder;
+/**
+ * Allows us to force consumers to do exactly one alteration to a column.
+ *
+ * One cannot do no alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .execute() // Property 'execute' does not exist on type 'AlteredColumnBuilder'.
+ * ```
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac) // Type 'AlterColumnBuilder' is not assignable to type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * One cannot do multiple alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac.dropNotNull().setNotNull()) // Property 'setNotNull' does not exist on type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+class AlteredColumnBuilder {
+    #alterColumnNode;
+    constructor(alterColumnNode) {
+        this.#alterColumnNode = alterColumnNode;
+    }
+    toOperationNode() {
+        return this.#alterColumnNode;
+    }
+}
+exports.AlteredColumnBuilder = AlteredColumnBuilder;

package/dist/cjs/schema/builders/alter-table-add-foreign-key-constraint-builder.d.ts

@@ -0,0 +1,32 @@
+import { AlterTableNode } from '../../operation-node/alter-table-node.js';
+import { OperationNodeSource } from '../../operation-node/operation-node-source.js';
+import { OnModifyForeignAction } from '../../operation-node/references-node.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { QueryExecutor } from '../../query-executor/query-executor.js';
+import { Compilable } from '../../util/compilable.js';
+import { QueryId } from '../../util/query-id.js';
+import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
+export declare class AlterTableAddForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<AlterTableAddForeignKeyConstraintBuilder>, OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
+    onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    deferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    notDeferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyDeferred(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyImmediate(): AlterTableAddForeignKeyConstraintBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableAddForeignKeyConstraintBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+    readonly constraintBuilder: ForeignKeyConstraintBuilder;
+}

package/dist/cjs/schema/builders/alter-table-add-foreign-key-constraint-builder.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterTableAddForeignKeyConstraintBuilder = void 0;
+const add_constraint_node_js_1 = require("../../operation-node/add-constraint-node.js");
+const alter_table_node_js_1 = require("../../operation-node/alter-table-node.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
+class AlterTableAddForeignKeyConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    onDelete(onDelete) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete),
+        });
+    }
+    onUpdate(onUpdate) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
+        });
+    }
+    deferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.deferrable(),
+        });
+    }
+    notDeferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.notDeferrable(),
+        });
+    }
+    initiallyDeferred() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyDeferred(),
+        });
+    }
+    initiallyImmediate() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyImmediate(),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+            addConstraint: add_constraint_node_js_1.AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),
+        }), this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile());
+    }
+}
+exports.AlterTableAddForeignKeyConstraintBuilder = AlterTableAddForeignKeyConstraintBuilder;