@carno.js/orm 0.2.3

package/dist/query/sql-subquery-builder.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlSubqueryBuilder = void 0;
+class SqlSubqueryBuilder {
+    constructor(entityStorage, getConditionBuilder) {
+        this.entityStorage = entityStorage;
+        this.getConditionBuilder = getConditionBuilder;
+        this.aliasCounter = 1;
+    }
+    buildExistsSubquery(relationship, filters, outerAlias, negate, outerModel) {
+        const prefix = negate ? 'NOT EXISTS' : 'EXISTS';
+        const subquery = this.buildSubquery(relationship, filters, outerAlias, outerModel);
+        return `${prefix} (${subquery})`;
+    }
+    buildSubquery(relationship, filters, outerAlias, outerModel) {
+        const subqueryAlias = this.generateAlias();
+        const tableName = this.resolveTableName(relationship);
+        const whereClause = this.buildWhereClause(relationship, filters, outerAlias, subqueryAlias, outerModel);
+        return `SELECT 1 FROM ${tableName} ${subqueryAlias} WHERE ${whereClause}`;
+    }
+    buildWhereClause(relationship, filters, outerAlias, subqueryAlias, outerModel) {
+        const correlation = this.buildCorrelation(relationship, outerAlias, subqueryAlias, outerModel);
+        const filterSql = this.buildFilterConditions(filters, subqueryAlias, relationship);
+        return this.combineConditions(correlation, filterSql);
+    }
+    buildCorrelation(relationship, outerAlias, subqueryAlias, outerModel) {
+        const fkKey = this.getFkKey(relationship);
+        const outerPkKey = this.getOuterPrimaryKey(relationship, outerModel);
+        const relatedPkKey = this.getRelatedPrimaryKey(relationship);
+        if (relationship.relation === 'one-to-many') {
+            return `${subqueryAlias}."${fkKey}" = ${outerAlias}."${outerPkKey}"`;
+        }
+        const outerFk = relationship.columnName;
+        return `${outerAlias}."${outerFk}" = ${subqueryAlias}."${relatedPkKey}"`;
+    }
+    getOuterPrimaryKey(relationship, outerModel) {
+        if (!outerModel) {
+            return 'id';
+        }
+        const entity = this.entityStorage.get(outerModel);
+        if (!entity) {
+            return 'id';
+        }
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+    buildFilterConditions(filters, alias, relationship) {
+        if (!filters || Object.keys(filters).length === 0) {
+            return '';
+        }
+        const conditionBuilder = this.getConditionBuilder();
+        const entity = relationship.entity();
+        return conditionBuilder.build(filters, alias, entity);
+    }
+    combineConditions(correlation, filterSql) {
+        if (!filterSql) {
+            return correlation;
+        }
+        return `${correlation} AND ${filterSql}`;
+    }
+    resolveTableName(relationship) {
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            const name = relationship.entity().name.toLowerCase();
+            return `public.${name}`;
+        }
+        const schema = entity.schema || 'public';
+        const tableName = entity.tableName || relationship.entity().name.toLowerCase();
+        return `${schema}."${tableName}"`;
+    }
+    generateAlias() {
+        const alias = `sq${this.aliasCounter}`;
+        this.aliasCounter++;
+        return alias;
+    }
+    getFkKey(relationship) {
+        if (typeof relationship.fkKey === 'undefined') {
+            return 'id';
+        }
+        if (typeof relationship.fkKey === 'string') {
+            return relationship.fkKey;
+        }
+        const match = /\.(?<propriedade>[\w]+)/.exec(relationship.fkKey.toString());
+        const propertyKey = match ? match.groups.propriedade : '';
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            throw new Error(`Entity not found in storage for relationship. ` +
+                `Make sure the entity ${relationship.entity().name} is decorated with @Entity()`);
+        }
+        const property = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
+        if (property) {
+            return property.options.columnName;
+        }
+        const relation = entity.relations.find((rel) => rel.propertyKey === propertyKey);
+        if (relation && relation.columnName) {
+            return relation.columnName;
+        }
+        throw new Error(`Property or relation "${propertyKey}" not found in entity "${entity.tableName}". ` +
+            `Available properties: ${Object.keys(entity.properties).join(', ')}. ` +
+            `Available relations: ${entity.relations.map((r) => r.propertyKey).join(', ')}`);
+    }
+    getRelatedPrimaryKey(relationship) {
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            return 'id';
+        }
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+}
+exports.SqlSubqueryBuilder = SqlSubqueryBuilder;

package/dist/repository/Repository.d.ts

@@ -0,0 +1,121 @@
+import { BaseEntity } from '../domain/base-entity';
+import { SqlBuilder } from '../SqlBuilder';
+import { FilterQuery, FindOptions, ValueOrInstance } from '../driver/driver.interface';
+/**
+ * Generic Repository class for database operations.
+ * Provides type-safe methods for CRUD operations.
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * export class LessonRepository extends Repository<Lesson> {
+ *   constructor() {
+ *     super(Lesson);
+ *   }
+ *
+ *   async findByCourse(courseId: number): Promise<Lesson[]> {
+ *     return this.find({
+ *       where: { courseId },
+ *       order: { orderIndex: 'ASC' }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class Repository<T extends BaseEntity> {
+    protected readonly entityClass: {
+        new (): T;
+    } & typeof BaseEntity;
+    constructor(entityClass: {
+        new (): T;
+    } & typeof BaseEntity);
+    /**
+     * Creates a new query builder for the entity.
+     */
+    protected createQueryBuilder(): SqlBuilder<T>;
+    /**
+     * Finds entities matching the given criteria.
+     *
+     * @example
+     * ```TypeScript
+     * const lessons = await repository.find({
+     *   where: { courseId: 1, isPublished: true },
+     *   order: { orderIndex: 'ASC' },
+     *   limit: 10
+     * });
+     * ```
+     */
+    find<Hint extends string = never>(options: RepositoryFindOptions<T, Hint>): Promise<T[]>;
+    /**
+     * Finds a single entity matching the given criteria.
+     * Returns undefined if not found.
+     */
+    findOne<Hint extends string = never>(options: RepositoryFindOneOptions<T, Hint>): Promise<T | undefined>;
+    /**
+     * Finds a single entity matching the given criteria.
+     * Throws an error if not found.
+     */
+    findOneOrFail<Hint extends string = never>(options: RepositoryFindOneOptions<T, Hint>): Promise<T>;
+    /**
+     * Finds all entities with optional filtering.
+     */
+    findAll<Hint extends string = never>(options?: Omit<RepositoryFindOptions<T>, 'where'>): Promise<T[]>;
+    /**
+     * Finds an entity by its primary key.
+     */
+    findById<Hint extends string = never>(id: number | string, options?: Omit<RepositoryFindOneOptions<T, Hint>, 'where'>): Promise<T | undefined>;
+    /**
+     * Finds an entity by its primary key.
+     * Throws an error if not found.
+     */
+    findByIdOrFail<Hint extends string = never>(id: number | string, options?: Omit<RepositoryFindOneOptions<T, Hint>, 'where'>): Promise<T>;
+    /**
+     * Creates a new entity.
+     */
+    create(data: Partial<{
+        [K in keyof T]: ValueOrInstance<T[K]>;
+    }>): Promise<T>;
+    /**
+     * Updates entities matching the criteria.
+     */
+    update(where: FilterQuery<T>, data: Partial<{
+        [K in keyof T]: ValueOrInstance<T[K]>;
+    }>): Promise<void>;
+    /**
+     * Updates an entity by its primary key.
+     */
+    updateById(id: number | string, data: Partial<{
+        [K in keyof T]: ValueOrInstance<T[K]>;
+    }>): Promise<void>;
+    /**
+     * Deletes entities matching the criteria.
+     *
+     * @example
+     * ```typescript
+     * await repository.delete({ isActive: false });
+     * ```
+     */
+    delete(where: FilterQuery<T>): Promise<void>;
+    /**
+     * Deletes an entity by its primary key.
+     */
+    deleteById(id: number | string): Promise<void>;
+    /**
+     * Counts entities matching the criteria.
+     */
+    count(where?: FilterQuery<T>): Promise<number>;
+    /**
+     * Checks if any entity matches the criteria.
+     */
+    exists(where: FilterQuery<T>): Promise<boolean>;
+}
+/**
+ * Find options for repository queries.
+ */
+export type RepositoryFindOptions<T, Hint extends string = never> = FindOptions<T, Hint> & {
+    where?: FilterQuery<T>;
+};
+/**
+ * Find one options for repository queries.
+ */
+export type RepositoryFindOneOptions<T, Hint extends string = never> = Omit<RepositoryFindOptions<T, Hint>, 'limit' | 'offset'>;

package/dist/repository/Repository.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = void 0;
+/**
+ * Generic Repository class for database operations.
+ * Provides type-safe methods for CRUD operations.
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * export class LessonRepository extends Repository<Lesson> {
+ *   constructor() {
+ *     super(Lesson);
+ *   }
+ *
+ *   async findByCourse(courseId: number): Promise<Lesson[]> {
+ *     return this.find({
+ *       where: { courseId },
+ *       order: { orderIndex: 'ASC' }
+ *     });
+ *   }
+ * }
+ * ```
+ */
+class Repository {
+    constructor(entityClass) {
+        this.entityClass = entityClass;
+    }
+    /**
+     * Creates a new query builder for the entity.
+     */
+    createQueryBuilder() {
+        return this.entityClass.createQueryBuilder();
+    }
+    /**
+     * Finds entities matching the given criteria.
+     *
+     * @example
+     * ```TypeScript
+     * const lessons = await repository.find({
+     *   where: { courseId: 1, isPublished: true },
+     *   order: { orderIndex: 'ASC' },
+     *   limit: 10
+     * });
+     * ```
+     */
+    async find(options) {
+        const { where, orderBy, limit, offset, fields, load, loadStrategy, cache } = options;
+        return this.entityClass.find(where || {}, {
+            orderBy: orderBy,
+            limit,
+            offset,
+            fields: fields,
+            load: load,
+            loadStrategy,
+            cache,
+        });
+    }
+    /**
+     * Finds a single entity matching the given criteria.
+     * Returns undefined if not found.
+     */
+    async findOne(options) {
+        const { where, orderBy, fields, load, loadStrategy, cache } = options;
+        return this.entityClass.findOne(where || {}, {
+            orderBy: orderBy,
+            fields: fields,
+            load: load,
+            loadStrategy,
+            cache,
+        });
+    }
+    /**
+     * Finds a single entity matching the given criteria.
+     * Throws an error if not found.
+     */
+    async findOneOrFail(options) {
+        const { where, orderBy, fields, load, loadStrategy, cache } = options;
+        return this.entityClass.findOneOrFail(where || {}, {
+            orderBy: orderBy,
+            fields: fields,
+            load: load,
+            loadStrategy,
+            cache,
+        });
+    }
+    /**
+     * Finds all entities with optional filtering.
+     */
+    async findAll(options) {
+        const { orderBy, limit, offset, fields, load, loadStrategy, cache } = options || {};
+        return this.entityClass.findAll({
+            orderBy: orderBy,
+            limit,
+            offset,
+            fields: fields,
+            load: load,
+            loadStrategy,
+            cache,
+        });
+    }
+    /**
+     * Finds an entity by its primary key.
+     */
+    async findById(id, options) {
+        return this.findOne({ where: { id }, ...options });
+    }
+    /**
+     * Finds an entity by its primary key.
+     * Throws an error if not found.
+     */
+    async findByIdOrFail(id, options) {
+        return this.findOneOrFail({ where: { id }, ...options });
+    }
+    /**
+     * Creates a new entity.
+     */
+    async create(data) {
+        return this.entityClass.create(data);
+    }
+    /**
+     * Updates entities matching the criteria.
+     */
+    async update(where, data) {
+        await this.createQueryBuilder()
+            .update(data)
+            .where(where)
+            .execute();
+    }
+    /**
+     * Updates an entity by its primary key.
+     */
+    async updateById(id, data) {
+        await this.update({ id }, data);
+    }
+    /**
+     * Deletes entities matching the criteria.
+     *
+     * @example
+     * ```typescript
+     * await repository.delete({ isActive: false });
+     * ```
+     */
+    async delete(where) {
+        await this.createQueryBuilder()
+            .delete()
+            .where(where)
+            .execute();
+    }
+    /**
+     * Deletes an entity by its primary key.
+     */
+    async deleteById(id) {
+        await this.delete({ id });
+    }
+    /**
+     * Counts entities matching the criteria.
+     */
+    async count(where) {
+        return this.createQueryBuilder()
+            .count()
+            .setStrategy('joined')
+            .where(where || {})
+            .executeCount();
+    }
+    /**
+     * Checks if any entity matches the criteria.
+     */
+    async exists(where) {
+        const count = await this.count(where);
+        return count > 0;
+    }
+}
+exports.Repository = Repository;

package/dist/testing/index.d.ts

@@ -0,0 +1 @@
+export * from './with-database';

package/dist/testing/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./with-database"), exports);

package/dist/testing/with-database.d.ts

@@ -0,0 +1,20 @@
+import { LoggerService } from '@carno.js/core';
+import { Orm } from '../orm';
+import { BunPgDriver } from '../driver/bun-pg.driver';
+import { ConnectionSettings } from '../driver/driver.interface';
+export type DatabaseTestContext = {
+    orm: Orm<BunPgDriver>;
+    executeSql: (sql: string) => Promise<{
+        rows: unknown[];
+    }>;
+};
+export type DatabaseTestOptions = {
+    schema?: string;
+    entityFile?: string;
+    logger?: LoggerService;
+    connection?: Partial<ConnectionSettings<BunPgDriver>>;
+};
+type DatabaseTestRoutine = (context: DatabaseTestContext) => Promise<void>;
+export declare function withDatabase(tables: string[], routine: DatabaseTestRoutine, options?: DatabaseTestOptions): Promise<void>;
+export declare function withDatabase(routine: DatabaseTestRoutine, options?: DatabaseTestOptions, tables?: string[]): Promise<void>;
+export {};