zibri 2.4.0 → 2.5.0

package/src/data-source/repository.ts

@@ -1,4 +1,4 @@
-import { Repository as TORepository, FindOptionsWhere, EntityManager, QueryFailedError as TOQueryFailedError, DeepPartial as ToDeepPartial } from 'typeorm';
+import { Repository as TORepository, FindOptionsWhere, EntityManager, QueryFailedError as TOQueryFailedError, DeepPartial as ToDeepPartial, FindOptionsOrder, FindOptionsRelations } from 'typeorm';
 
 import { BaseEntity } from '../entity/base-entity.model';
 import { LoggerInterface } from '../logging/logger.interface';
@@ -18,12 +18,16 @@ import { FindByIdOptions } from './models/options/find-by-id-options.model';
 import { FindOneOptions } from './models/options/find-one-options.model';
 import { UpdateAllOptions } from './models/options/update-all-options.model';
 import { UpdateByIdOptions } from './models/options/update-by-id-options.model';
-import { whereFilterToFindOptionsWhere } from './models/where/where-filter-to-find-options-where.function';
 import { Where } from './models/where/where-filter.model';
 import { QueryFailedError } from './query-failed.error';
 import { Transaction } from './transaction/transaction.model';
+import { EntityMetadata } from '../entity/decorators/entity.decorator';
 import { NotFoundError } from '../error-handling/errors/not-found.error';
 import { ModelRegistry } from '../global/model-registry/model.registry';
+import { MetadataUtilities } from '../utilities/metadata.utilities';
+import { type TypeOrmBaseDataSource } from './data-sources/typeorm-base-data-source.model';
+import { DataSourceOptions } from './models/data-source-options.model';
+import { EntityMetadataMissingError } from '../entity/entity-metadata-missing.error';
 
 /**
  * A repository that handles data source related things for its entity.
@@ -35,6 +39,13 @@ export class Repository<
 > {
     private readonly typeOrmRepository: TORepository<T>;
 
+    private readonly _dataSource: TypeOrmBaseDataSource<DataSourceOptions>;
+
+    /**
+     * The metadata of entity that this repository manages.
+     */
+    protected readonly entityMetadata: EntityMetadata;
+
     // eslint-disable-next-line jsdoc/require-returns
     /**
      * The data source that this repository is connected to.
@@ -47,12 +58,21 @@ export class Repository<
         protected readonly entityClass: Newable<T>,
         repo: TORepository<T> | Repository<T>,
         protected readonly logger: LoggerInterface,
-        private readonly _dataSource: DataSourceInterface,
+        dataSource: DataSourceInterface,
         private readonly beforeSave: BeforeSaveHook<T, CreateData, UpdateData>,
         private readonly beforeReturn: BeforeReturnHook<T>
     ) {
         this.typeOrmRepository = repo instanceof Repository ? repo.typeOrmRepository : repo;
         ModelRegistry.get(this.entityClass);
+        const metadata: EntityMetadata | undefined = MetadataUtilities.getEntityMetadata(this.entityClass);
+        if (!metadata) {
+            throw new EntityMetadataMissingError(this.entityClass);
+        }
+        if (!('whereFilterToFindOptionsWhere' in dataSource)) {
+            throw new Error('Zibri\'s default repositories only work with TypeOrmBaseDataSource');
+        }
+        this._dataSource = dataSource as TypeOrmBaseDataSource<DataSourceOptions>;
+        this.entityMetadata = metadata;
     }
 
     private getManager(transaction: Transaction | undefined): EntityManager {
@@ -63,7 +83,7 @@ export class Repository<
         if (!where) {
             return undefined;
         }
-        return whereFilterToFindOptionsWhere(where, this.entityClass);
+        return this._dataSource.whereFilterToFindOptionsWhere(where, this.entityClass);
     }
 
     /**
@@ -156,13 +176,21 @@ export class Repository<
         required: B = true as B
     ): Promise<B extends false ? T | undefined : T> {
         const where: FindOptionsWhere<T> | FindOptionsWhere<T>[] | undefined = this.resolveFindOptionsWhere(options.where);
+        // eslint-disable-next-line typescript/no-explicit-any
+        const relations: (keyof T)[] | FindOptionsRelations<any> | undefined = options.relations ?? this.entityMetadata.defaultRelations;
 
         const manager: EntityManager = this.getManager(options?.transaction);
         let res: T | null;
         try {
             res = await manager.findOne(
                 this.entityClass,
-                { ...options, relations: options.relations as string[], where, transaction: undefined }
+                {
+                    order: this.entityMetadata.defaultOrder as FindOptionsOrder<T> | undefined,
+                    ...options,
+                    relations: relations as FindOptionsRelations<T> | string[] | undefined,
+                    where,
+                    transaction: undefined
+                }
             );
         }
         catch (error) {
@@ -189,10 +217,19 @@ export class Repository<
     async findAll(options?: FindAllOptions<T>): Promise<T[]> {
         const manager: EntityManager = this.getManager(options?.transaction);
         const where: FindOptionsWhere<T> | FindOptionsWhere<T>[] | undefined = this.resolveFindOptionsWhere(options?.where);
+        // eslint-disable-next-line typescript/no-explicit-any
+        const relations: (keyof T)[] | FindOptionsRelations<any> | undefined = options?.relations ?? this.entityMetadata.defaultRelations;
+
         try {
             const res: T[] = await manager.find(
                 this.entityClass,
-                { ...options, where, relations: options?.relations as string[], transaction: undefined }
+                {
+                    order: this.entityMetadata.defaultOrder as FindOptionsOrder<T> | undefined,
+                    ...options,
+                    where,
+                    relations: relations as FindOptionsRelations<T> | string[] | undefined,
+                    transaction: undefined
+                }
             );
             await Promise.all(res.map(r => this.beforeReturn(r, this.entityClass)));
             return res;
@@ -244,18 +281,16 @@ export class Repository<
      * @returns The updated entity.
      */
     async updateById(id: T['id'], data: UpdateData, options?: UpdateByIdOptions): Promise<T> {
-        if (data.id != undefined && options?.allowId != true) {
+        if (data.id != undefined) {
             await this.logger.warn('Found an id on the update data, it will be ignored.');
-            delete data.id;
         }
         const manager: EntityManager = this.getManager(options?.transaction);
         data.id = id;
         await this.beforeSave(data, false, this.entityClass);
 
         try {
-            const res: T = await manager.save(this.entityClass, data as ToDeepPartial<T>);
-            await this.beforeReturn(res, this.entityClass);
-            return res;
+            await manager.save(this.entityClass, data as ToDeepPartial<T>, { reload: false });
+            return await this.findById(id, options);
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -277,7 +312,7 @@ export class Repository<
         data: UpdateData,
         options?: UpdateAllOptions
     ): Promise<T[]> {
-        if (data.id != undefined && options?.allowId != true) {
+        if (data.id != undefined) {
             await this.logger.warn('Found an id on the update data, it will be ignored.');
             delete data.id;
         }
@@ -287,9 +322,8 @@ export class Repository<
         const manager: EntityManager = this.getManager(options?.transaction);
 
         try {
-            const res: T[] = await manager.save(this.entityClass, toUpdate as ToDeepPartial<T>[]);
-            await Promise.all(res.map(r => this.beforeReturn(r, this.entityClass)));
-            return res;
+            await manager.save(this.entityClass, toUpdate as ToDeepPartial<T>[]);
+            return await this.findAll({ where, ...options });
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -330,7 +364,7 @@ export class Repository<
      */
     async deleteAll(
         where: Where<T>,
-        options?: DeleteAllOptions<T>
+        options?: DeleteAllOptions
     ): Promise<T[]> {
         const toDelete: T[] = await this.findAll({ where, ...options });
         await Promise.all(toDelete.map(r => this.beforeSave(r, false, this.entityClass)));

package/src/data-source/transaction/transaction.test.ts

@@ -10,7 +10,7 @@ import { Entity } from '../../entity/decorators/entity.decorator';
 import { Property } from '../../entity/decorators/property.decorator';
 import { Newable } from '../../types/newable.type';
 import { DataSourceInterface } from '../data-sources/data-source.interface';
-import { PostgresDataSource } from '../data-sources/postgres-data-source.model';
+import { PostgresDataSource } from '../data-sources/postgres-typeorm-data-source.model';
 
 @Entity()
 class Item {

package/src/data-source/where-filter.test.ts

@@ -0,0 +1,489 @@
+/* eslint-disable unicorn/no-null */
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
+
+import { createTestDataSource, defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
+import { startTestServer, StartedTestServer } from '../__testing__/test-server/start-test-server.function';
+import { WhereFilter } from '../data-source/models/where/where-filter.model';
+import { Repository } from '../data-source/repository';
+import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
+import { inject } from '../di/inject.function';
+import { BaseEntity } from '../entity/base-entity.model';
+import { Entity } from '../entity/decorators/entity.decorator';
+import { Property } from '../entity/decorators/property.decorator';
+import { DeepPartial } from '../types/deep-partial.type';
+
+// ---------- Test entities ----------
+
+@Entity()
+class Category extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.oneToMany({ target: () => Product, inverseSide: 'category' })
+    products!: Product[];
+}
+
+@Entity()
+class Review extends BaseEntity { // used as an object type for array-of-objects
+    @Property.number()
+    rating!: number;
+
+    @Property.string()
+    comment!: string;
+}
+
+class Metadata { // plain object embedded inside Product
+    @Property.string()
+    color!: string;
+
+    @Property.number()
+    weight!: number;
+}
+
+@Entity()
+class Product extends BaseEntity {
+    @Property.string({ required: false })
+    name: string | undefined | null;
+
+    @Property.number({ required: false })
+    price: number | undefined | null;
+
+    @Property.boolean({ required: false })
+    inStock: boolean | undefined | null;
+
+    @Property.date({ default: () => new Date(), required: false })
+    createdAt: Date | undefined | null;
+
+    @Property.array({ items: { type: 'string' }, required: false })
+    tags: string[] | undefined | null;
+
+    @Property.object({ cls: () => Metadata, required: false })
+    metadata: Metadata | undefined | null;
+
+    @Property.manyToOne({ target: () => Category, inverseSide: 'products', joinColumn: 'categoryId' })
+    category!: Category;
+
+    @Property.string({ format: 'uuid' })
+    categoryId!: string;
+
+    @Property.array({ items: { type: 'object', cls: () => Review }, required: false })
+    reviews: Review[] | undefined | null;
+}
+
+let server: StartedTestServer;
+let productRepo: Repository<Product>;
+let categoryRepo: Repository<Category>;
+
+beforeAll(async () => {
+    server = await startTestServer({
+        dataSources: [
+            createTestDataSource({
+                entities: [...defaultTestServerEntities, Product, Category, Review]
+            })
+        ]
+    });
+    productRepo = inject(repositoryTokenFor(Product));
+    categoryRepo = inject(repositoryTokenFor(Category));
+}, 15000);
+
+afterAll(async () => {
+    await server.shutdown();
+});
+
+beforeEach(async () => {
+    await productRepo.deleteAll({});
+    await categoryRepo.deleteAll({});
+});
+
+// ---------- Helper to create test data ----------
+async function seedProducts(...products: DeepPartial<Product>[]): Promise<Product[]> {
+    for (const p of products) {
+        if (p.category) {
+            const cat: Category = await categoryRepo.create(p.category);
+            p.categoryId = cat.id;
+        }
+    }
+    const defaultCategory: Category = (await categoryRepo.findAllPaginated(1, 1)).items.at(0) ?? await categoryRepo.create({ name: 'default' });
+    return Promise.all(products.map(p => productRepo.create({ tags: [], reviews: [], inStock: true, categoryId: defaultCategory.id, ...p })));
+}
+
+// ---------- Tests ----------
+describe('Where filters', () => {
+
+    // =================== STRING ===================
+    describe('string', () => {
+        let prodA: Product;
+        let prodB: Product;
+
+        beforeEach(async () => {
+            [prodA, prodB] = await seedProducts(
+                { name: 'Alpha', price: 10 },
+                { name: 'Beta', price: 20 }
+            );
+        });
+
+        it('equals', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { name: 'Alpha' } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+
+        it('not', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { name: { not: 'Alpha' } } });
+            expect(res.map(p => p.id).sort()).toEqual([prodB.id].sort());
+        });
+
+        it('oneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { name: { oneOf: ['Alpha', 'Beta'] } } });
+            expect(res.map(p => p.id).sort()).toEqual([prodA.id, prodB.id].sort());
+        });
+
+        it('notOneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { name: { notOneOf: ['Alpha'] } } });
+            expect(res.map(p => p.id)).toEqual([prodB.id]);
+        });
+
+        it('like', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { name: { like: 'Al%' } } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+
+        it('iLike', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { name: { iLike: 'al%' } } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+
+        it('fuzzyLike', async () => {
+            // eslint-disable-next-line cspell/spellchecker
+            // "Alpha" and "Beta" are seeded. A fuzzy search for "Alpah" (typo) should still match.
+            const res: Product[] = await productRepo.findAll({
+                // eslint-disable-next-line cspell/spellchecker
+                where: { name: { fuzzyLike: { value: 'Alpah', minSimilarity: 30 } } }
+            });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+
+        it('fuzzyLike with low similarity returns nothing', async () => {
+            const res: Product[] = await productRepo.findAll({
+                where: { name: { fuzzyLike: { value: 'Zzzz', minSimilarity: 90 } } }
+            });
+            expect(res).toHaveLength(0);
+        });
+
+        it('null', async () => {
+            await productRepo.updateById(prodA.id, { name: null }); // set to null
+            const res: Product[] = await productRepo.findAll({ where: { name: null } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+    });
+
+    // =================== NUMBER ===================
+    describe('number', () => {
+        let cheap: Product;
+        let mid: Product;
+        let expensive: Product;
+
+        beforeEach(async () => {
+            [cheap, mid, expensive] = await seedProducts(
+                { name: 'c', price: 10 },
+                { name: 'm', price: 50 },
+                { name: 'e', price: 100 }
+            );
+        });
+
+        it('equals', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: 50 } });
+            expect(res.map(p => p.id)).toEqual([mid.id]);
+        });
+
+        it('not', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: { not: 50 } } });
+            expect(res.map(p => p.id).sort()).toEqual([cheap.id, expensive.id].sort());
+        });
+
+        it('oneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: { oneOf: [10, 100] } } });
+            expect(res.map(p => p.id).sort()).toEqual([cheap.id, expensive.id].sort());
+        });
+
+        it('notOneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: { notOneOf: [10, 100] } } });
+            expect(res.map(p => p.id)).toEqual([mid.id]);
+        });
+
+        it('greaterThan', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: { greaterThan: 50 } } });
+            expect(res.map(p => p.id)).toEqual([expensive.id]);
+        });
+
+        it('greaterThanEquals', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: { greaterThanEquals: 50 } } });
+            expect(res.map(p => p.id).sort()).toEqual([mid.id, expensive.id].sort());
+        });
+
+        it('lesserThan', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: { lesserThan: 50 } } });
+            expect(res.map(p => p.id)).toEqual([cheap.id]);
+        });
+
+        it('lesserThanEquals', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { price: { lesserThanEquals: 50 } } });
+            expect(res.map(p => p.id).sort()).toEqual([cheap.id, mid.id].sort());
+        });
+
+        it('null', async () => {
+            await productRepo.updateById(cheap.id, { price: null });
+            const res: Product[] = await productRepo.findAll({ where: { price: null } });
+            expect(res.map(p => p.id)).toEqual([cheap.id]);
+        });
+    });
+
+    // =================== BOOLEAN ===================
+    describe('boolean', () => {
+        let inStock: Product;
+        let outOfStock: Product;
+
+        beforeEach(async () => {
+            [inStock, outOfStock] = await seedProducts(
+                { name: 'a', price: 1, inStock: true },
+                { name: 'b', price: 2, inStock: false }
+            );
+        });
+
+        it('true', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { inStock: true } });
+            expect(res.map(p => p.id)).toEqual([inStock.id]);
+        });
+
+        it('false', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { inStock: false } });
+            expect(res.map(p => p.id)).toEqual([outOfStock.id]);
+        });
+
+        it('null', async () => {
+            await productRepo.updateById(inStock.id, { inStock: null });
+            const res: Product[] = await productRepo.findAll({ where: { inStock: null } });
+            expect(res.map(p => p.id)).toEqual([inStock.id]);
+        });
+    });
+
+    // =================== DATE ===================
+    describe('date', () => {
+        let early: Product;
+        let late: Product;
+        const earlyCreatedAt: Date = new Date('2025-01-01');
+        const lateCreatedAt: Date = new Date('2026-01-01');
+
+        beforeEach(async () => {
+            [early, late] = await seedProducts(
+                { name: 'early', price: 1, createdAt: earlyCreatedAt },
+                { name: 'late', price: 2, createdAt: lateCreatedAt }
+            );
+        });
+
+        it('equals', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { createdAt: early.createdAt } });
+            expect(res.map(p => p.id)).toEqual([early.id]);
+        });
+
+        it('not', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { createdAt: { not: early.createdAt } } });
+            expect(res.map(p => p.id)).toEqual([late.id]);
+        });
+
+        it('oneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { createdAt: { oneOf: [earlyCreatedAt, lateCreatedAt] } } });
+            expect(res.map(p => p.id).sort()).toEqual([early.id, late.id].sort());
+        });
+
+        it('notOneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { createdAt: { notOneOf: [earlyCreatedAt] } } });
+            expect(res.map(p => p.id)).toEqual([late.id]);
+        });
+
+        it('after', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { createdAt: { after: earlyCreatedAt } } });
+            expect(res.map(p => p.id)).toEqual([late.id]);
+        });
+
+        it('before', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { createdAt: { before: lateCreatedAt } } });
+            expect(res.map(p => p.id)).toEqual([early.id]);
+        });
+
+        it('null', async () => {
+            await productRepo.updateById(early.id, { createdAt: null });
+            const res: Product[] = await productRepo.findAll({ where: { createdAt: null } });
+            expect(res.map(p => p.id)).toEqual([early.id]);
+        });
+    });
+
+    // =================== ARRAY (of strings) ===================
+    describe('array (string)', () => {
+        let prodA: Product;
+
+        beforeEach(async () => {
+            [prodA] = await seedProducts(
+                { name: 'a', price: 1, tags: ['tag1', 'tag2'] },
+                { name: 'b', price: 2, tags: ['tag3'] }
+            );
+        });
+
+        it('equals (exact array)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { tags: ['tag1', 'tag2'] } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+
+        it('includes (contains all specified items)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { tags: { includes: ['tag1'] } } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+
+        it('isIncludedIn (all items of the property are subset of given list)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { tags: { isIncludedIn: ['tag1', 'tag2', 'extra'] } } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]); // prodA's tags are subset
+            // prodB has ['tag3'] which is not subset of ['tag1','tag2','extra'] -> not returned
+        });
+
+        it('null', async () => {
+            await productRepo.updateById(prodA.id, { tags: null });
+            const res: Product[] = await productRepo.findAll({ where: { tags: null } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+    });
+
+    // =================== OBJECT (embedded) ===================
+    describe('object (Metadata)', () => {
+        let prodRed: Product;
+        let prodBlue: Product;
+
+        beforeEach(async () => {
+            [prodRed, prodBlue] = await seedProducts(
+                { name: 'red', price: 1, metadata: { color: 'red', weight: 100 } },
+                { name: 'blue', price: 2, metadata: { color: 'blue', weight: 200 } }
+            );
+        });
+
+        it('equals (exact match)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { metadata: { is: { color: 'red', weight: 100 } } } });
+            expect(res.map(p => p.id)).toEqual([prodRed.id]);
+        });
+
+        it('where (nested filter)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { metadata: { where: { color: 'red' } } } });
+            // Should treat the nested where as filtering on the JSON's properties
+            // That depends on how TypeORM handles JSON columns; we assume the framework maps it correctly.
+            // In a strict behavioral test, we just validate the result.
+            expect(res.map(p => p.id)).toEqual([prodRed.id]);
+        });
+
+        it('not', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { metadata: { not: { color: 'red', weight: 100 } } } });
+            expect(res.map(p => p.id)).toEqual([prodBlue.id]);
+        });
+
+        it('oneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { metadata: { oneOf: [{ color: 'red', weight: 100 }, { color: 'blue', weight: 200 }] } } });
+            expect(res.map(p => p.id).sort()).toEqual([prodRed.id, prodBlue.id].sort());
+        });
+
+        it('notOneOf', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { metadata: { notOneOf: [{ color: 'red', weight: 100 }] } } });
+            expect(res.map(p => p.id)).toEqual([prodBlue.id]);
+        });
+
+        it('null', async () => {
+            await productRepo.updateById(prodRed.id, { metadata: null });
+            const res: Product[] = await productRepo.findAll({ where: { metadata: { is: null } } });
+            expect(res.map(p => p.id)).toEqual([prodRed.id]);
+        });
+    });
+
+    // =================== RELATION (Category) ===================
+    describe('relation (Category)', () => {
+        let catFood: Category;
+        let catToys: Category;
+        let prodFood: Product;
+
+        beforeEach(async () => {
+            catFood = await categoryRepo.create({ name: 'Food' });
+            catToys = await categoryRepo.create({ name: 'Toys' });
+            [prodFood] = await seedProducts(
+                { name: 'Kibble', price: 5, category: catFood },
+                { name: 'Ball', price: 3, category: catToys }
+            );
+        });
+
+        it('filter by relation property (where on nested object)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { category: { where: { name: 'Food' } } } });
+            expect(res.map(p => p.id)).toEqual([prodFood.id]);
+        });
+
+        it('filter by relation id (equals with id)', async () => {
+            // `equals` on a relation should filter by the primary key of the related entity
+            const res: Product[] = await productRepo.findAll({ where: { category: { is: catFood } } });
+            expect(res.map(p => p.id)).toEqual([prodFood.id]);
+        });
+    });
+
+    // =================== ARRAY OF OBJECTS (Review[]) ===================
+    describe('array of objects', () => {
+        let prodA: Product;
+        let prodB: Product;
+
+        beforeEach(async () => {
+            [prodA, prodB] = await seedProducts(
+                { name: 'a', price: 1, reviews: [{ rating: 5, comment: 'Great' }, { rating: 4, comment: 'Good' }] },
+                { name: 'b', price: 2, reviews: [{ rating: 2, comment: 'Bad' }] }
+            );
+        });
+
+        it('includes (contains all specified objects)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { reviews: { where: [{ rating: 5, comment: 'Great' }] } } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+
+        it('isIncludedIn (all items of the array are subset of given list)', async () => {
+            const res: Product[] = await productRepo.findAll({ where: { reviews: { where: [{ rating: 5, comment: 'Great' }, { rating: 4, comment: 'Good' }, { rating: 2, comment: 'Bad' }] } } });
+            expect(res.map(p => p.id).sort()).toEqual([prodA.id, prodB.id].sort());
+        });
+
+        it('null', async () => {
+            await productRepo.updateById(prodA.id, { reviews: null });
+            const res: Product[] = await productRepo.findAll({ where: { reviews: null } });
+            expect(res.map(p => p.id)).toEqual([prodA.id]);
+        });
+    });
+
+    // =================== OR (array of filters) ===================
+    describe('OR combination', () => {
+        let prodA: Product;
+        let prodB: Product;
+        let prodC: Product;
+
+        beforeEach(async () => {
+            [prodA, prodB, prodC] = await seedProducts(
+                { name: 'A', price: 1 },
+                { name: 'B', price: 2 },
+                { name: 'C', price: 3 }
+            );
+        });
+
+        it('returns entities matching any of the filters', async () => {
+            const filters: WhereFilter<Product>[] = [
+                { name: 'A' },
+                { price: 3 }
+            ];
+            const res: Product[] = await productRepo.findAll({ where: filters });
+            expect(res.map(p => p.id).sort()).toEqual([prodA.id, prodC.id].sort());
+        });
+
+        it('multiple complex filters', async () => {
+            const filters: WhereFilter<Product>[] = [
+                { name: { like: 'A' }, price: 1 },
+                { name: { like: 'B' }, price: { greaterThan: 1 } }
+            ];
+            const res: Product[] = await productRepo.findAll({ where: filters });
+            expect(res.map(p => p.id).sort()).toEqual([prodA.id, prodB.id].sort());
+        });
+    });
+});

package/src/di/decorators/inject-repository.decorator.ts

@@ -1,3 +1,4 @@
+import { RepositoryTypeForEntity } from '../../data-source/data-sources/data-source.interface';
 import { Repository } from '../../data-source/repository';
 import { BaseEntity } from '../../entity/base-entity.model';
 import { Newable } from '../../types/newable.type';
@@ -12,10 +13,10 @@ const allRepositoryTokens: Record<string, DiToken<Repository<BaseEntity>>> = {};
  * @param entity - The entity class to resolve the repository token for.
  * @returns The DI token.
  */
-export function repositoryTokenFor<T extends Newable<BaseEntity>>(entity: T): DiToken<Repository<InstanceType<T>>> {
+export function repositoryTokenFor<T extends Newable<BaseEntity>>(entity: T): DiToken<RepositoryTypeForEntity<InstanceType<T>>> {
     const key: string = `Repository<${entity.name}>`;
     allRepositoryTokens[key] ??= new InjectionToken(key);
-    return allRepositoryTokens[key] as unknown as DiToken<Repository<InstanceType<T>>>;
+    return allRepositoryTokens[key] as DiToken<RepositoryTypeForEntity<InstanceType<T>>>;
 }
 
 /**