@hexabot-ai/api 3.0.0-alpha.3 → 3.1.1-alpha.0

package/src/utils/generics/base-orm.repository.ts

@@ -5,11 +5,7 @@
  */
 
 import { Inject, NotFoundException } from '@nestjs/common';
-import {
-  EventEmitter2,
-  IHookEntities,
-  TNormalizedEvents,
-} from '@nestjs/event-emitter';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import { instanceToPlain, plainToInstance } from 'class-transformer';
 import camelCase from 'lodash/camelCase';
 import set from 'lodash/set';
@@ -26,24 +22,26 @@ import {
   Repository,
   UpdateEvent,
 } from 'typeorm';
+import { DeleteResult } from 'typeorm/driver/mongodb/typings';
 
+import {
+  invokeOrmHooks,
+  OrmHookName,
+} from '@/database/decorators/orm-event-hooks.decorator';
 import { BaseOrmEntity } from '@/database/entities/base.entity';
 import { LoggerService } from '@/logger/logger.service';
 import { flatten } from '@/utils/helpers/flatten';
 
 import {
   DtoAction,
-  DtoActionConfig,
-  DtoTransformer,
-  DtoTransformerConfig,
-  InferActionDto,
-  InferTransformDto,
+  InferCreateDto,
+  InferEntityDto,
+  InferFull,
+  InferPlain,
+  InferUpdateDto,
+  TEntityDto,
 } from '../types/dto.types';
-
-export type DeleteResult = {
-  acknowledged: boolean;
-  deletedCount: number;
-};
+import { EmitEventProps } from '../types/entity-event.types';
 
 export enum EHook {
   preCreateValidate = 'preCreateValidate',
@@ -73,21 +71,32 @@ export type FindAllOptions<EntityType> = Omit<
 };
 
 export abstract class BaseOrmRepository<
-  Entity extends BaseOrmEntity,
-  TransformerDto extends DtoTransformerConfig,
-  ActionDto extends DtoActionConfig,
+  Entity extends BaseOrmEntity<TEntityDto<Entity>>,
 > implements EntitySubscriberInterface<Entity>
 {
   private readonly dataSource: DataSource;
 
+  private readonly joinRelationMap: Record<string, string>;
+
   protected constructor(
     protected readonly repository: Repository<Entity>,
     protected readonly populateRelations: string[] = [],
-    protected readonly transformers: TransformerDto,
   ) {
     this.dataSource = repository.manager.connection;
-    this.registerEntityManagerProvider();
     this.registerAsSubscriber();
+    this.joinRelationMap = Object.fromEntries(
+      this.repository.metadata.relationIds.map((rid) => [
+        rid.relation.propertyName,
+        rid.propertyName,
+      ]),
+    );
+  }
+
+  private async invokeEntityHooks(
+    hook: OrmHookName,
+    event: InsertEvent<Entity> | UpdateEvent<Entity> | RemoveEvent<Entity>,
+  ): Promise<void> {
+    await invokeOrmHooks(event.entity, hook, event);
   }
 
   getPopulateRelations(): readonly string[] {
@@ -114,20 +123,30 @@ export abstract class BaseOrmRepository<
   @Inject(LoggerService)
   protected readonly logger: LoggerService;
 
-  public getTransformer<D extends DtoTransformer>(t: D) {
-    return (entity: Entity): InferTransformDto<D, TransformerDto> => {
-      return plainToInstance(this.transformers[t] as any, entity, {
-        exposeUnsetFields: false,
-      });
-    };
+  private attachJoinColumnsToDto<Action extends DtoAction>(
+    data: InferEntityDto<Action, Entity>,
+  ): InferEntityDto<Action, Entity> {
+    if (!data) return {} as InferEntityDto<Action, Entity>;
+
+    const result = { ...data };
+
+    for (const [key, value] of Object.entries(data)) {
+      const joinColumn = this.joinRelationMap[key];
+      if (joinColumn) {
+        result[joinColumn] = value;
+      }
+    }
+
+    return result;
   }
 
-  public actionDtoToEntity(
-    data: InferActionDto<DtoAction, ActionDto>,
+  public actionDtoToEntity<Action extends DtoAction>(
+    data: InferEntityDto<Action, Entity>,
   ): DeepPartial<Entity> {
+    const entityDto = this.attachJoinColumnsToDto(data);
     const e = plainToInstance(
       this.repository.target as new (...args: any[]) => Entity,
-      instanceToPlain(data),
+      instanceToPlain(entityDto),
     );
 
     return Object.assign(e) as DeepPartial<Entity>;
@@ -135,10 +154,10 @@ export abstract class BaseOrmRepository<
 
   async findAll(
     options: FindAllOptions<Entity> = {} as FindAllOptions<Entity>,
-  ): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]> {
+  ): Promise<InferPlain<Entity>[]> {
     const entities = await this.findAllEntities(options);
 
-    return entities.map(this.getTransformer(DtoTransformer.PlainCls));
+    return entities.map((e) => e.toPlainCls());
   }
 
   private async findAllEntities(
@@ -149,20 +168,20 @@ export abstract class BaseOrmRepository<
 
   async findAllAndPopulate(
     options: FindAllOptions<Entity> = {} as FindAllOptions<Entity>,
-  ): Promise<InferTransformDto<DtoTransformer.FullCls, TransformerDto>[]> {
+  ): Promise<InferFull<Entity>[]> {
     const populatedEntities = await this.repository.find(
       this.withPopulateRelations(options as FindManyOptions<Entity>, true),
     );
 
-    return populatedEntities.map(this.getTransformer(DtoTransformer.FullCls));
+    return populatedEntities.map((e) => e.toFullCls());
   }
 
   async find(
     options: FindManyOptions<Entity> = {} as FindManyOptions<Entity>,
-  ): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]> {
+  ): Promise<InferPlain<Entity>[]> {
     const entities = await this.findEntities(options);
 
-    return entities.map(this.getTransformer(DtoTransformer.PlainCls));
+    return entities.map((e) => e.toPlainCls());
   }
 
   private async findEntities(
@@ -201,10 +220,10 @@ export abstract class BaseOrmRepository<
 
   async findAndPopulate(
     options: FindManyOptions<Entity> = {} as FindManyOptions<Entity>,
-  ): Promise<InferTransformDto<DtoTransformer.FullCls, TransformerDto>[]> {
+  ): Promise<InferFull<Entity>[]> {
     const entities = await this.findEntities(options, true);
 
-    return entities.map(this.getTransformer(DtoTransformer.FullCls));
+    return entities.map((e) => e.toFullCls());
   }
 
   async count(
@@ -215,13 +234,10 @@ export abstract class BaseOrmRepository<
 
   async findOne(
     idOrOptions: string | FindOneOptions<Entity>,
-  ): Promise<InferTransformDto<
-    DtoTransformer.PlainCls,
-    TransformerDto
-  > | null> {
+  ): Promise<InferPlain<Entity> | null> {
     const entity = await this.findOneEntity(idOrOptions);
 
-    return entity ? this.getTransformer(DtoTransformer.PlainCls)(entity) : null;
+    return entity ? entity.toPlainCls() : null;
   }
 
   private async findOneEntity(
@@ -246,39 +262,67 @@ export abstract class BaseOrmRepository<
 
   async findOneAndPopulate(
     idOrOptions: string | FindOneOptions<Entity>,
-  ): Promise<InferTransformDto<DtoTransformer.FullCls, TransformerDto> | null> {
+  ): Promise<InferFull<Entity> | null> {
     const entity = await this.findOneEntity(idOrOptions, true);
 
-    return entity ? this.getTransformer(DtoTransformer.FullCls)(entity) : null;
+    return entity ? entity.toFullCls() : null;
   }
 
-  async create(
-    payload: InferActionDto<DtoAction.Create, ActionDto>,
-  ): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>> {
+  async create(payload: InferCreateDto<Entity>): Promise<InferPlain<Entity>> {
     const entity = this.repository.create(this.actionDtoToEntity(payload));
-    const created = await this.repository.save(entity);
+    await this.emitEvent<EHook.preCreate>({
+      action: EHook.preCreate,
+      entity,
+      payload,
+    });
+
+    const createdEntity = await this.repository.save(entity);
+
+    await this.emitEvent<EHook.postCreate>({
+      action: EHook.postCreate,
+      entity: createdEntity,
+      payload,
+    });
 
-    return this.getTransformer(DtoTransformer.PlainCls)(created);
+    return createdEntity.toPlainCls();
   }
 
   async createMany(
-    payloads: InferActionDto<DtoAction.Create, ActionDto>[],
-  ): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]> {
+    payloads: InferCreateDto<Entity>[],
+  ): Promise<InferPlain<Entity>[]> {
     const entities = this.repository.create(
       payloads.map((payload) => this.actionDtoToEntity(payload)),
     );
+
+    for (let index = 0; index < entities.length; index++) {
+      await this.emitEvent<EHook.preCreate>({
+        action: EHook.preCreate,
+        entity: entities[index],
+        payload: payloads[index],
+      });
+    }
+
     const created = await this.repository.save(entities);
 
-    return created.map(this.getTransformer(DtoTransformer.PlainCls));
+    for (let index = 0; index < created.length; index++) {
+      await this.emitEvent<EHook.postCreate>({
+        entity: created[index],
+        action: EHook.postCreate,
+        payload: payloads[index],
+      });
+    }
+
+    return created.map((e) => e.toPlainCls());
   }
 
   async updateOne(
     idOrOptions: string | FindOneOptions<Entity>,
-    payload: InferActionDto<DtoAction.Update, ActionDto>,
+    payload: InferUpdateDto<Entity>,
     options?: UpdateOneOptions,
-  ): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>> {
+  ): Promise<InferPlain<Entity>> {
     const entity = await this.findOneEntity(idOrOptions);
-    if (entity) {
+    const databaseEntity = await this.findOneEntity(idOrOptions);
+    if (entity && databaseEntity) {
       const updates = this.actionDtoToEntity(payload);
       if (options?.shouldFlatten && updates && typeof updates === 'object') {
         const flattenedUpdates = flatten(
@@ -291,20 +335,45 @@ export abstract class BaseOrmRepository<
       } else {
         Object.assign(entity, updates);
       }
-      const updated = await this.repository.save(entity);
-      if (updated) {
-        return this.getTransformer(DtoTransformer.PlainCls)(updated);
-      } else {
-        throw new NotFoundException(
-          'Unable to execute updateOne() - No updates',
+      // Read all fields from the update data.
+      const entries = Object.entries(payload ?? {});
+      // Find relation keys that are many-to-many.
+      const manyToManyKeys = this.repository.metadata.relations
+        .filter((relation) => relation.isManyToMany)
+        .map((relation) => relation.propertyName);
+      // Check if update data has only many-to-many list fields.
+      const hasOnlyManyToManyProperties =
+        entries.length > 0 &&
+        entries.every(
+          ([key, val]) => manyToManyKeys.includes(key) && Array.isArray(val),
         );
+
+      // If only many-to-many fields changed, set update time to trigger afterUpdate event
+      if (hasOnlyManyToManyProperties) {
+        entity.updatedAt = new Date();
       }
+
+      await this.emitEvent<EHook.preUpdate>({
+        action: EHook.preUpdate,
+        entity,
+        payload,
+        databaseEntity,
+      });
+
+      const updatedEntity = await this.repository.save(entity);
+
+      await this.emitEvent<EHook.postUpdate>({
+        action: EHook.postUpdate,
+        entity: updatedEntity,
+        payload,
+        databaseEntity,
+      });
+
+      return updatedEntity.toPlainCls();
     }
 
     if (options?.upsert) {
-      return await this.create(
-        payload as unknown as InferActionDto<DtoAction.Create, ActionDto>,
-      );
+      return await this.create(payload as unknown as InferCreateDto<Entity>);
     } else {
       throw new NotFoundException('Unable to execute updateOne() - No updates');
     }
@@ -312,8 +381,8 @@ export abstract class BaseOrmRepository<
 
   async updateMany(
     options: FindManyOptions<Entity> = {} as FindManyOptions<Entity>,
-    payload: InferActionDto<DtoAction.Update, ActionDto>,
-  ): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>[]> {
+    payload: InferUpdateDto<Entity>,
+  ): Promise<InferPlain<Entity>[]> {
     const entities = await this.findEntities(options);
 
     if (!entities.length) {
@@ -321,24 +390,43 @@ export abstract class BaseOrmRepository<
     }
 
     const changes = this.actionDtoToEntity(payload);
+    const databaseEntities: Entity[] = [];
 
     for (let index = 0; index < entities.length; index++) {
+      databaseEntities.push(
+        this.repository.create(entities[index] as DeepPartial<Entity>),
+      );
       Object.assign(entities[index], changes);
+
+      await this.emitEvent<EHook.preUpdate>({
+        action: EHook.preUpdate,
+        entity: entities[index],
+        payload,
+        databaseEntity: databaseEntities[index],
+      });
     }
 
     const updatedEntities = await this.repository.save(entities);
-    const toDto = this.getTransformer(DtoTransformer.PlainCls);
 
-    return updatedEntities.map(toDto);
+    for (let index = 0; index < updatedEntities.length; index++) {
+      await this.emitEvent<EHook.postUpdate>({
+        action: EHook.postUpdate,
+        entity: updatedEntities[index],
+        payload,
+        databaseEntity: databaseEntities[index],
+      });
+    }
+
+    return updatedEntities.map((e) => e.toPlainCls());
   }
 
   async findOneOrCreate(
     idOrOptions: string | FindOneOptions<Entity>,
-    payload: InferActionDto<DtoAction.Create, ActionDto>,
-  ): Promise<InferTransformDto<DtoTransformer.PlainCls, TransformerDto>> {
+    payload: InferCreateDto<Entity>,
+  ): Promise<InferPlain<Entity>> {
     const existing = await this.findOneEntity(idOrOptions);
     if (existing) {
-      return this.getTransformer(DtoTransformer.PlainCls)(existing);
+      return existing.toPlainCls();
     }
 
     return await this.create(payload);
@@ -359,10 +447,36 @@ export abstract class BaseOrmRepository<
       return { acknowledged: true, deletedCount: 0 };
     }
 
-    await this.repository.remove(deletable);
+    const deletableSnapshots = deletable.map((entity) =>
+      this.repository.create(entity as DeepPartial<Entity>),
+    );
+
+    for (let index = 0; index < deletable.length; index++) {
+      await this.emitEvent<EHook.preDelete>({
+        action: EHook.preDelete,
+        payload: options,
+        databaseEntity: deletableSnapshots[index],
+      });
+    }
+
+    const deletedEntities = await this.repository.remove(deletable);
+
+    for (let index = 0; index < deletedEntities.length; index++) {
+      if (!deletedEntities[index].id && deletableSnapshots[index]?.id) {
+        deletedEntities[index].id = deletableSnapshots[index].id;
+      }
+
+      await this.emitEvent<EHook.postDelete>({
+        action: EHook.postDelete,
+        entity: deletedEntities[index],
+        payload: options,
+        databaseEntity: deletedEntities[index],
+      });
+    }
+
     const result: DeleteResult = {
       acknowledged: true,
-      deletedCount: deletable.length,
+      deletedCount: deletedEntities.length,
     };
 
     return result;
@@ -377,13 +491,32 @@ export abstract class BaseOrmRepository<
       return { acknowledged: true, deletedCount: 0 };
     }
 
-    await this.repository.remove(entity);
-    const result: DeleteResult = {
+    const databaseEntity = this.repository.create(
+      entity as DeepPartial<Entity>,
+    );
+
+    await this.emitEvent<EHook.preDelete>({
+      action: EHook.preDelete,
+      payload: idOrOptions,
+      databaseEntity,
+    });
+
+    const deletedEntity = await this.repository.remove(entity);
+    if (!deletedEntity.id && databaseEntity.id) {
+      deletedEntity.id = databaseEntity.id;
+    }
+
+    await this.emitEvent<EHook.postDelete>({
+      action: EHook.postDelete,
+      entity,
+      payload: idOrOptions,
+      databaseEntity: deletedEntity,
+    });
+
+    return {
       acknowledged: true,
       deletedCount: 1,
-    };
-
-    return result;
+    } satisfies DeleteResult;
   }
 
   private isBuiltin(entity: Entity): boolean {
@@ -404,40 +537,20 @@ export abstract class BaseOrmRepository<
     }
   }
 
-  private registerEntityManagerProvider(): void {
-    const target = this.repository.target;
-    if (typeof target !== 'function') {
-      return;
-    }
-
-    const entityConstructor = target as unknown as typeof BaseOrmEntity;
-    if (typeof entityConstructor.registerEntityManagerProvider !== 'function') {
-      return;
-    }
-
-    entityConstructor.registerEntityManagerProvider(
-      () => this.repository.manager,
-    );
-  }
-
-  protected getEventName(
-    metadata: EntityMetadata,
-    suffix: EHook,
-  ): `hook:${IHookEntities}:${TNormalizedEvents}` {
-    const entityName =
-      camelCase((metadata.name ?? 'entity').replace(/OrmEntity$/, '')) ||
-      'entity';
-
-    return `hook:${entityName}:${suffix}` as `hook:${IHookEntities}:${TNormalizedEvents}`;
+  protected getEntityName(metadata: EntityMetadata) {
+    return camelCase((metadata.name ?? 'entity').replace(/OrmEntity$/, ''));
   }
 
-  protected async emitHook(
-    suffix: EHook,
-    event: OrmLifecycleEvent<Entity>,
-  ): Promise<void> {
+  protected async emitEvent<H extends EHook, E extends BaseOrmEntity = Entity>(
+    data: EmitEventProps<E, H>,
+  ) {
     if (!this.eventEmitter) return;
-    const eventName = this.getEventName(event.metadata, suffix);
-    await this.eventEmitter.emitAsync(eventName, event);
+    const entityName = this.getEntityName(this.repository.metadata);
+
+    await this.eventEmitter.emitAsync(`hook:${entityName}:${data.action}`, {
+      ...data,
+      entityName,
+    });
   }
 
   protected async onBeforeInsert(_event: InsertEvent<Entity>): Promise<void> {}
@@ -454,36 +567,31 @@ export abstract class BaseOrmRepository<
 
   async beforeInsert(event: InsertEvent<Entity>): Promise<void> {
     await this.onBeforeInsert(event);
-    await this.emitHook(EHook.preCreate, event);
+    await this.invokeEntityHooks('beforeInsert', event);
   }
 
   async afterInsert(event: InsertEvent<Entity>): Promise<void> {
     await this.onAfterInsert(event);
-    await this.emitHook(EHook.postCreate, event);
+    await this.invokeEntityHooks('afterInsert', event);
   }
 
   async beforeUpdate(event: UpdateEvent<Entity>): Promise<void> {
     await this.onBeforeUpdate(event);
-    await this.emitHook(EHook.preUpdate, event);
+    await this.invokeEntityHooks('beforeUpdate', event);
   }
 
   async afterUpdate(event: UpdateEvent<Entity>): Promise<void> {
     await this.onAfterUpdate(event);
-    await this.emitHook(EHook.postUpdate, event);
+    await this.invokeEntityHooks('afterUpdate', event);
   }
 
   async beforeRemove(event: RemoveEvent<Entity>): Promise<void> {
     await this.onBeforeRemove(event);
-    await this.emitHook(EHook.preDelete, event);
+    await this.invokeEntityHooks('beforeRemove', event);
   }
 
   async afterRemove(event: RemoveEvent<Entity>): Promise<void> {
     await this.onAfterRemove(event);
-    await this.emitHook(EHook.postDelete, event);
+    await this.invokeEntityHooks('afterRemove', event);
   }
 }
-
-type OrmLifecycleEvent<Entity extends BaseOrmEntity> =
-  | InsertEvent<Entity>
-  | UpdateEvent<Entity>
-  | RemoveEvent<Entity>;

package/src/utils/generics/base-orm.seeder.ts

@@ -8,30 +8,20 @@ import { FindManyOptions } from 'typeorm';
 
 import { BaseOrmEntity } from '@/database/entities/base.entity';
 
-import {
-  DtoAction,
-  DtoActionConfig,
-  DtoTransformerConfig,
-  InferActionDto,
-} from '../types/dto.types';
+import { InferCreateDto, InferPlain, TEntityDto } from '../types/dto.types';
 
 import { BaseOrmRepository, FindAllOptions } from './base-orm.repository';
 
 export abstract class BaseOrmSeeder<
-  Entity extends BaseOrmEntity,
-  TransformerDto extends DtoTransformerConfig,
-  ActionDto extends DtoActionConfig,
-  OrmRepository extends BaseOrmRepository<
-    Entity,
-    TransformerDto,
-    ActionDto
-  > = BaseOrmRepository<Entity, TransformerDto, ActionDto>,
+  Entity extends BaseOrmEntity<TEntityDto<Entity>>,
 > {
-  protected constructor(protected readonly repository: OrmRepository) {}
+  protected constructor(
+    protected readonly repository: BaseOrmRepository<Entity>,
+  ) {}
 
   async findAll(
     options: FindAllOptions<Entity> = {} as FindAllOptions<Entity>,
-  ) {
+  ): Promise<InferPlain<Entity>[]> {
     return await this.repository.findAll(options);
   }
 
@@ -41,9 +31,7 @@ export abstract class BaseOrmSeeder<
     return count === 0;
   }
 
-  async seed(
-    models: InferActionDto<DtoAction.Create, ActionDto>[],
-  ): Promise<boolean> {
+  async seed(models: InferCreateDto<Entity>[]): Promise<boolean> {
     if (await this.isEmpty()) {
       await this.repository.createMany(models);