zibri 2.3.0 → 2.4.1

package/src/data-source/repository.ts

@@ -1,18 +1,13 @@
-import { Repository as TORepository, FindOptionsWhere, EntityManager, QueryFailedError as TOQueryFailedError } from 'typeorm';
+import { Repository as TORepository, FindOptionsWhere, EntityManager, QueryFailedError as TOQueryFailedError, DeepPartial as ToDeepPartial, FindOptionsOrder, FindOptionsRelations } from 'typeorm';
 
-import { QueryFailedError } from './query-failed.error';
 import { BaseEntity } from '../entity/base-entity.model';
-import { Transaction } from './transaction/transaction.model';
-import { PropertyMetadata } from '../entity/decorators/property.decorator';
-import { ArrayPropertyMetadata } from '../entity/models/array-property-metadata.model';
-import { Relation } from '../entity/models/relation.enum';
 import { LoggerInterface } from '../logging/logger.interface';
 import { PaginationResult } from '../open-api/pagination-result.model';
 import { DeepPartial } from '../types/deep-partial.type';
 import { Newable } from '../types/newable.type';
-import { MetadataUtilities } from '../utilities/metadata.utilities';
-import { whereFilterToFindOptionsWhere } from './models/where/where-filter-to-find-options-where.function';
-import { NotFoundError } from '../error-handling/errors/not-found.error';
+import { DataSourceInterface } from './data-sources/data-source.interface';
+import { BeforeReturnHook } from './hooks/before-return';
+import { BeforeSaveHook } from './hooks/before-save';
 import { CreateAllOptions } from './models/options/create-all-options.model';
 import { CreateOptions } from './models/options/create-options.model';
 import { DeleteAllOptions } from './models/options/delete-all-options.model';
@@ -24,6 +19,15 @@ 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 { 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,12 +39,40 @@ 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.
+     */
+    get dataSource(): DataSourceInterface {
+        return this._dataSource;
+    }
+
     constructor(
         protected readonly entityClass: Newable<T>,
         repo: TORepository<T> | Repository<T>,
-        protected readonly logger: LoggerInterface
+        protected readonly logger: LoggerInterface,
+        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 {
@@ -51,95 +83,7 @@ export class Repository<
         if (!where) {
             return undefined;
         }
-        return whereFilterToFindOptionsWhere(where, this.entityClass);
-    }
-
-    private async setDefaultValues<Data, EntityClass>(data: Data, entityClass: Newable<EntityClass>): Promise<void> {
-        const props: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(entityClass);
-        for (const key in props) {
-            const property: PropertyMetadata = props[key];
-
-            if (data[key as keyof Data] !== undefined) {
-                switch (property.type) {
-                    case 'string':
-                    case 'number':
-                    case 'boolean':
-                    case 'date':
-                    case 'file':
-                    case 'unknown': {
-                        break;
-                    }
-                    case Relation.MANY_TO_ONE:
-                    case Relation.ONE_TO_ONE: {
-                        await this.setDefaultValues(data[key as keyof Data], property.target());
-                        break;
-                    }
-                    case 'object': {
-                        await this.setDefaultValues(data[key as keyof Data], property.cls());
-                        break;
-                    }
-                    case 'array': {
-                        await this.setDefaultValuesForArray(data[key as keyof Data] as unknown[], property);
-                        break;
-                    }
-                    case Relation.MANY_TO_MANY:
-                    case Relation.ONE_TO_MANY: {
-                        await this.setDefaultValuesForArray(data[key as keyof Data] as unknown[], {
-                            ...property,
-                            type: 'array',
-                            totalMaxSize: '50mb',
-                            items: {
-                                type: 'object',
-                                cls: property.target,
-                                description: undefined,
-                                allowAdditionalProperties: false,
-                                excludeFromChangeSets: property.excludeFromChangeSets,
-                                required: property.required
-                            }
-                        });
-                        break;
-                    }
-                }
-                continue;
-            }
-
-            if (!('default' in property) || property.default == undefined) {
-                continue;
-            }
-
-            if (
-                typeof property.default === 'string'
-                || typeof property.default === 'number'
-                || typeof property.default === 'boolean'
-                || property.default instanceof Date
-            ) {
-                data[key as keyof Data] = property.default as Data[keyof Data];
-                continue;
-            }
-            data[key as keyof Data] = await property.default(data) as Data[keyof Data];
-        }
-    }
-
-    private async setDefaultValuesForArray(values: unknown[], property: ArrayPropertyMetadata): Promise<void> {
-        for (const item of values) {
-            switch (property.items.type) {
-                case 'string':
-                case 'number':
-                case 'boolean':
-                case 'date':
-                case 'file':
-                case 'unknown': {
-                    break;
-                }
-                case 'object': {
-                    await this.setDefaultValues(item, property.items.cls());
-                    break;
-                }
-                case 'array': {
-                    await this.setDefaultValuesForArray(item as unknown[], property.items);
-                }
-            }
-        }
+        return this._dataSource.whereFilterToFindOptionsWhere(where, this.entityClass);
     }
 
     /**
@@ -153,10 +97,13 @@ export class Repository<
             await this.logger.warn('Found an id on the create data, it will be ignored.');
             delete data.id;
         }
-        await this.setDefaultValues(data, this.entityClass);
+        await this.beforeSave(data, true, this.entityClass);
+
         const manager: EntityManager = this.getManager(options?.transaction);
         try {
-            return await manager.save(this.entityClass, data);
+            const res: T = await manager.save(this.entityClass, data as ToDeepPartial<T>);
+            await this.beforeReturn(res, this.entityClass);
+            return res;
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -173,14 +120,17 @@ export class Repository<
      * @returns All newly created entities.
      */
     async createAll(data: CreateData[], options?: CreateAllOptions): Promise<T[]> {
-        let entitiesWithIdCount: number = 0;
-        for (const d of data) {
-            if (d.id != undefined && options?.allowId != true) {
-                delete d.id;
-                entitiesWithIdCount++;
-            }
-            await this.setDefaultValues(d, this.entityClass);
-        }
+        const entitiesWithIdCount: number = (await Promise.all(
+            data.map(async d => {
+                let hadId: boolean = false;
+                if (d.id != undefined && options?.allowId != true) {
+                    delete d.id;
+                    hadId = true;
+                }
+                await this.beforeSave(d, true, this.entityClass);
+                return hadId;
+            })
+        )).filter(Boolean).length;
         if (entitiesWithIdCount) {
             await this.logger.warn(
                 `Found an id on ${entitiesWithIdCount} out of ${data.length} entries of the create data. These ids will be ignored.`
@@ -189,7 +139,9 @@ export class Repository<
 
         const manager: EntityManager = this.getManager(options?.transaction);
         try {
-            return await manager.save(this.entityClass, data);
+            const res: T[] = await manager.save(this.entityClass, data as ToDeepPartial<T>[]);
+            await Promise.all(res.map(r => this.beforeReturn(r, this.entityClass)));
+            return res;
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -224,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) {
@@ -242,7 +202,11 @@ export class Repository<
         if (!res && required) {
             throw new NotFoundError(`Could not find ${this.entityClass.name}.`);
         }
-        return (res ?? undefined) as B extends false ? T | undefined : T;
+        if (!res) {
+            return undefined as B extends false ? T | undefined : T;
+        }
+        await this.beforeReturn(res, this.entityClass);
+        return res;
     }
 
     /**
@@ -253,11 +217,22 @@ 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 {
-            return await manager.find(
+            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;
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -306,15 +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);
-        const dataWithId: DeepPartial<T> = { id, ...data };
+        data.id = id;
+        await this.beforeSave(data, false, this.entityClass);
 
         try {
-            return await manager.save(this.entityClass, dataWithId);
+            await manager.save(this.entityClass, data as ToDeepPartial<T>, { reload: false });
+            return await this.findById(id, options);
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -336,16 +312,18 @@ 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;
         }
+        await this.beforeSave(data, false, this.entityClass);
         const toUpdate: DeepPartial<T>[] = (await this.findAll({ where, ...options })).map(t => ({ id: t.id, ...data }));
 
         const manager: EntityManager = this.getManager(options?.transaction);
 
         try {
-            return await manager.save(this.entityClass, toUpdate);
+            await manager.save(this.entityClass, toUpdate as ToDeepPartial<T>[]);
+            return await this.findAll({ where, ...options });
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -359,12 +337,16 @@ export class Repository<
      * Deletes an entity with the provided id.
      * @param id - The id of the entity to deleted.
      * @param options - Additional options, like a transaction.
+     * @returns The deleted entity.
      */
-    async deleteById(id: T['id'], options?: DeleteByIdOptions): Promise<void> {
+    async deleteById(id: T['id'], options?: DeleteByIdOptions): Promise<T> {
         const entityToDelete: T = await this.findById(id, options);
+        await this.beforeSave(entityToDelete, false, this.entityClass);
         const manager: EntityManager = this.getManager(options?.transaction);
         try {
-            await manager.remove(this.entityClass, entityToDelete);
+            const res: T = await manager.remove(this.entityClass, entityToDelete);
+            await this.beforeReturn(res, this.entityClass);
+            return res;
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {
@@ -378,16 +360,20 @@ export class Repository<
      * Deletes all entities that match the provided where filter.
      * @param where - The where filter to find the entities that should be deleted.
      * @param options - Additional options, like a transaction.
-     * @returns An array of all the updated entities.
+     * @returns An array of all the deleted entities.
      */
     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)));
+
         const manager: EntityManager = this.getManager(options?.transaction);
         try {
-            return await manager.remove(this.entityClass, toDelete);
+            const res: T[] = await manager.remove(this.entityClass, toDelete);
+            await Promise.all(res.map(r => this.beforeReturn(r, this.entityClass)));
+            return res;
         }
         catch (error) {
             if (error instanceof TOQueryFailedError) {

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 {