zibri 2.4.0 → 2.4.1

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

@@ -1,60 +1,297 @@
-import { beforeAll, afterAll, describe, it, expect } from '@jest/globals';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
+import { type Relation } from 'typeorm';
 
 import { Repository } from './repository';
 import { createTestDataSource, defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
-import { StartedTestServer, startTestServer } from '../__testing__/test-server/start-test-server.function';
+import { startTestServer, StartedTestServer } from '../__testing__/test-server/start-test-server.function';
 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 { OmitStrict } from '../types/omit-strict.type';
+
+// ==================== ENTITIES ====================
+
+@Entity()
+class Company extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.oneToMany({ target: () => User, inverseSide: 'company' })
+    employees!: User[];
+}
+
+@Entity()
+class Profile extends BaseEntity {
+    @Property.string()
+    bio!: string;
+
+    @Property.hasOne({ target: () => User, inverseSide: 'profile' })
+    user!: Relation<User>;
+}
 
 @Entity()
-class VisitStats extends BaseEntity {
-    @Property.number()
-    count!: number;
+class Tag extends BaseEntity {
+    @Property.string()
+    name!: string;
 
-    @Property.number()
-    countFirstVisit!: number;
+    @Property.manyToMany({ target: () => Post, inverseSide: 'tags', joinTable: false })
+    posts!: Post[];
+}
 
+@Entity()
+class Group extends BaseEntity {
     @Property.string()
-    targetSite!: string;
+    name!: string;
 
-    @Property.string({ required: false })
-    referrer: string | undefined;
+    @Property.manyToMany({ target: () => User, inverseSide: 'groups', joinTable: false })
+    members!: User[];
+}
 
+@Entity()
+class Post extends BaseEntity {
     @Property.string()
-    domain!: string;
+    title!: string;
+
+    @Property.manyToOne({ target: () => User, inverseSide: 'posts', joinColumn: 'userId' })
+    author!: Relation<User>;
+
+    @Property.oneToMany({ target: () => Comment, inverseSide: 'post' })
+    comments!: Relation<Comment>;
+
+    @Property.string({ format: 'uuid' })
+    userId!: string;
+
+    @Property.manyToMany({ target: () => Tag, inverseSide: 'posts', joinTable: true })
+    tags!: Tag[];
+}
+
+@Entity()
+class Comment extends BaseEntity {
+    @Property.string()
+    text!: string;
+
+    @Property.manyToOne({ target: () => Post, inverseSide: 'comments', joinColumn: 'postId' })
+    post!: Post;
+
+    @Property.string({ format: 'uuid' })
+    postId!: string;
+}
+
+@Entity()
+class User extends BaseEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.manyToOne({ target: () => Company, inverseSide: 'employees', joinColumn: 'companyId' })
+    company!: Company;
+
+    @Property.string({ format: 'uuid', required: false })
+    companyId!: string;
+
+    @Property.oneToMany({ target: () => Post, inverseSide: 'author' })
+    posts!: Post[];
+
+    @Property.belongsToOne({ target: () => Profile, inverseSide: 'user', joinColumn: 'profileId' })
+    profile!: Profile;
+
+    @Property.string({ format: 'uuid', required: false })
+    profileId!: string;
 
-    @Property.date()
-    date!: Date;
+    @Property.manyToMany({ target: () => Group, inverseSide: 'members', joinTable: true })
+    groups!: Group[];
 }
 
-describe('repository', () => {
-    let server: StartedTestServer;
+// ==================== TEST SUITE ====================
 
-    beforeAll(async () => {
-        server = await startTestServer({
-            dataSources: [createTestDataSource({ entities: [...defaultTestServerEntities, VisitStats] })]
+let server: StartedTestServer;
+let userRepo: Repository<User>;
+let companyRepo: Repository<Company>;
+let profileRepo: Repository<Profile>;
+let postRepo: Repository<Post>;
+let tagRepo: Repository<Tag>;
+let groupRepo: Repository<Group>;
+let commentRepo: Repository<Comment>;
+
+beforeAll(async () => {
+    server = await startTestServer({
+        dataSources: [createTestDataSource({ entities: [...defaultTestServerEntities, Company, Profile, Tag, Group, Post, Comment, User] })]
+    });
+    userRepo = inject(repositoryTokenFor(User));
+    companyRepo = inject(repositoryTokenFor(Company));
+    profileRepo = inject(repositoryTokenFor(Profile));
+    postRepo = inject(repositoryTokenFor(Post));
+    tagRepo = inject(repositoryTokenFor(Tag));
+    groupRepo = inject(repositoryTokenFor(Group));
+    commentRepo = inject(repositoryTokenFor(Comment));
+}, 15000);
+
+afterAll(async () => {
+    await server.shutdown();
+});
+
+beforeEach(async () => {
+    // Clean all data in reverse dependency order
+    await commentRepo.deleteAll({});
+    await postRepo.deleteAll({});
+    await tagRepo.deleteAll({});
+    await userRepo.deleteAll({});
+    await groupRepo.deleteAll({});
+    await profileRepo.deleteAll({});
+    await companyRepo.deleteAll({});
+});
+
+// ==================== TESTS ====================
+
+describe('Repository – create with relations', () => {
+    it('create with many-to-one (company)', async () => {
+        const company: Company = await companyRepo.create({ name: 'Acme' });
+        const user: User = await userRepo.create({
+            name: 'Alice',
+            company: company,
+            companyId: company.id
         });
-    }, 15000);
-
-    afterAll(async () => {
-        await server?.shutdown();
-    });
-
-    it('create', async () => {
-        const repo: Repository<VisitStats> = inject(repositoryTokenFor(VisitStats));
-        const visitStats: OmitStrict<VisitStats, 'id'> = {
-            count: 1,
-            countFirstVisit: 0,
-            targetSite: '/test',
-            referrer: 'google.de',
-            date: new Date(),
-            domain: 'localhost'
-        };
-        await repo.create(visitStats);
-        expect((await repo.findAll()).length).toBe(1);
+        const fetched: User = await userRepo.findById(user.id);
+        expect(fetched.companyId).toBe(company.id);
+    });
+
+    it('create with one-to-many (posts)', async () => {
+        const user: User = await userRepo.create({ name: 'Bob' });
+        await postRepo.create({ title: 'Post 1', author: user, userId: user.id });
+        await postRepo.create({ title: 'Post 2', author: user, userId: user.id });
+        const fetchedUser: User = await userRepo.findById(user.id, { relations: ['posts'] });
+        expect(fetchedUser.posts).toHaveLength(2);
+    });
+
+    it('create with many-to-many (tags on post)', async () => {
+        const user: User = await userRepo.create({ name: 'Carol' });
+        const tag1: Tag = await tagRepo.create({ name: 'tech' });
+        const tag2: Tag = await tagRepo.create({ name: 'news' });
+        const post: Post = await postRepo.create({
+            title: 'Article',
+            author: user,
+            userId: user.id,
+            tags: [tag1, tag2] // many-to-many via relation array
+        });
+        const fetchedPost: Post = await postRepo.findById(post.id, { relations: ['tags'] });
+        expect(fetchedPost.tags).toHaveLength(2);
+    });
+
+    it('create with has-one (profile)', async () => {
+        const profile: Profile = await profileRepo.create({ bio: 'Hello' });
+        const user: User = await userRepo.create({
+            name: 'Dan',
+            profile: profile,
+            profileId: profile.id
+        });
+        const fetched: User = await userRepo.findById(user.id, { relations: ['profile'] });
+        expect(fetched.profile).toBeDefined();
+        expect(fetched.profile.bio).toBe('Hello');
+    });
+
+    it('create with nested relations', async () => {
+        // User -> Post -> Comment
+        const user: User = await userRepo.create({ name: 'Eve' });
+        const post: Post = await postRepo.create({ title: 'Nested', author: user, userId: user.id });
+        const comment: Comment = await commentRepo.create({ text: 'Nice!', post: post, postId: post.id });
+        const fetchedComment: Comment = await commentRepo.findById(comment.id, { relations: { post: { author: true } } });
+        expect(fetchedComment.post).toBeDefined();
+        expect(fetchedComment.post.author).toBeDefined();
+    });
+});
+
+describe('Repository – update relations', () => {
+    it('updateById – change many-to-one', async () => {
+        const company1: Company = await companyRepo.create({ name: 'A' });
+        const company2: Company = await companyRepo.create({ name: 'B' });
+        const user: User = await userRepo.create({ name: 'Frank', company: company1, companyId: company1.id });
+        await userRepo.updateById(user.id, { company: company2, companyId: company2.id });
+        const updated: User = await userRepo.findById(user.id);
+        expect(updated.companyId).toBe(company2.id);
+    });
+
+    it('updateById – modify many-to-many array', async () => {
+        const user: User = await userRepo.create({ name: 'Grace' });
+        const group1: Group = await groupRepo.create({ name: 'Admin' });
+        const group2: Group = await groupRepo.create({ name: 'Editor' });
+        // Set initial groups via create (known working path)
+        await userRepo.updateById(user.id, { groups: [group1] });
+        // Now update to add group2
+        await userRepo.updateById(user.id, { groups: [group1, group2] });
+        const fetched: User = await userRepo.findById(user.id, { relations: ['groups'] });
+        expect(fetched.groups).toHaveLength(2);
+    });
+
+    it('updateAll – change many-to-one for multiple entities', async () => {
+        const companyA: Company = await companyRepo.create({ name: 'Alpha' });
+        const companyB: Company = await companyRepo.create({ name: 'Beta' });
+        await userRepo.create({ name: 'User1', company: companyA, companyId: companyA.id });
+        await userRepo.create({ name: 'User2', company: companyA, companyId: companyA.id });
+        await userRepo.updateAll({ companyId: companyA.id }, { company: companyB, companyId: companyB.id });
+        const users: User[] = await userRepo.findAll({ where: { companyId: companyB.id } });
+        expect(users).toHaveLength(2);
+    });
+
+    it('updateAll – modify many-to-many arrays', async () => {
+        const group: Group = await groupRepo.create({ name: 'Everyone' });
+        const user1: User = await userRepo.create({ name: 'Huey' });
+        const user2: User = await userRepo.create({ name: 'Dewey' });
+        await userRepo.updateAll({ id: user1.id }, { groups: [group] });
+        await userRepo.updateAll({ id: user2.id }, { groups: [group] });
+        const fetched: User[] = await userRepo.findAll({ where: { groups: { includes: [group] } } });
+        expect(fetched).toHaveLength(2);
+    });
+});
+
+describe('Repository – delete with relations', () => {
+    it('deleteById – with cascade on one-to-many', async () => {
+        const user: User = await userRepo.create({ name: 'Ivy' });
+        const post: Post = await postRepo.create({ title: 'To be deleted', author: user, userId: user.id });
+        // Deleting post should not delete user, but we'll check cascade configuration later
+        await postRepo.deleteById(post.id);
+        const found: Post | undefined = await postRepo.findOne({ where: { id: post.id } }, false);
+        expect(found).toBeUndefined();
+        const userStill: User = await userRepo.findById(user.id);
+        expect(userStill).toBeDefined();
+    });
+
+    it('deleteAll – many-to-many relations are detached, not deleted', async () => {
+        const group: Group = await groupRepo.create({ name: 'Temp' });
+        const user: User = await userRepo.create({ name: 'Jack', groups: [group] });
+        await userRepo.deleteAll({ id: user.id });
+        const foundUser: User | undefined = await userRepo.findOne({ where: { id: user.id } }, false);
+        expect(foundUser).toBeUndefined();
+        const foundGroup: Group = await groupRepo.findById(group.id);
+        expect(foundGroup).toBeDefined(); // group not deleted
+    });
+});
+
+describe('Repository – querying relations', () => {
+    it('findById with nested relations', async () => {
+        const user: User = await userRepo.create({ name: 'Kate' });
+        const post: Post = await postRepo.create({ title: 'Post', author: user, userId: user.id });
+        const comment: Comment = await commentRepo.create({ text: 'Yep', post: post, postId: post.id });
+        const fetched: Comment = await commentRepo.findById(comment.id, { relations: { post: { author: true } } });
+        expect(fetched.post.title).toBe('Post');
+        expect(fetched.post.author.name).toBe('Kate');
+    });
+
+    it('findAll with where filter on relation property', async () => {
+        const company: Company = await companyRepo.create({ name: 'Target' });
+        const user: User = await userRepo.create({ name: 'Liam', company: company, companyId: company.id });
+        const results: User[] = await userRepo.findAll({ where: { company: { where: { name: 'Target' } } } });
+        expect(results.map(u => u.id)).toEqual([user.id]);
+    });
+});
+
+describe('Repository – combined operations', () => {
+    it('createAll with multiple entities and relations', async () => {
+        const company: Company = await companyRepo.create({ name: 'MultiCorp' });
+        const users: User[] = await userRepo.createAll([
+            { name: 'Moe', company: company, companyId: company.id },
+            { name: 'Larry', company: company, companyId: company.id },
+            { name: 'Curly', company: company, companyId: company.id }
+        ]);
+        expect(users).toHaveLength(3);
     });
 });

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 {