feat: Make assemblers convert* methods async (#216)

BREAKING CHANGE: All `convert*` methods are now async. `convertAsyncTo*`
methods are dropped in favor of async `convertTo`.

Fixes #215

Author: TriPSs

packages/core/__tests__/assemblers/abstract.assembler.spec.ts

@@ -93,44 +93,16 @@ describe('ClassTransformerAssembler', () => {
   })
 
   describe('convertToDTOs', () => {
-    it('should call the convertToDTO implementation', () => {
+    it('should call the convertToDTO implementation', async () => {
       const assembler = new TestAssembler()
-      expect(assembler.convertToDTOs([testEntity])).toEqual([testDTO])
-    })
-  })
-
-  describe('convertAsyncToDTO', () => {
-    it('should call the convertToDTO implementation with the resolved value', () => {
-      const assembler = new TestAssembler()
-      return expect(assembler.convertAsyncToDTO(Promise.resolve(testEntity))).resolves.toEqual(testDTO)
-    })
-  })
-
-  describe('convertAsyncToDTOs', () => {
-    it('should call the convertToDTO implementation with the resolved value', () => {
-      const assembler = new TestAssembler()
-      return expect(assembler.convertAsyncToDTOs(Promise.resolve([testEntity]))).resolves.toEqual([testDTO])
+      expect(await assembler.convertToDTOs([testEntity])).toEqual([testDTO])
     })
   })
 
   describe('convertToEntities', () => {
-    it('should call the convertToEntity implementation', () => {
-      const assembler = new TestAssembler()
-      expect(assembler.convertToEntities([testDTO])).toEqual([testEntity])
-    })
-  })
-
-  describe('convertAsyncToEntity', () => {
-    it('should call the convertToEntity implementation with the resolved value', () => {
-      const assembler = new TestAssembler()
-      return expect(assembler.convertAsyncToEntity(Promise.resolve(testDTO))).resolves.toEqual(testEntity)
-    })
-  })
-
-  describe('convertAsyncToEntities', () => {
-    it('should call the convertToEntity implementation with the resolved value', () => {
+    it('should call the convertToEntity implementation', async () => {
       const assembler = new TestAssembler()
-      return expect(assembler.convertAsyncToEntities(Promise.resolve([testDTO]))).resolves.toEqual([testEntity])
+      expect(await assembler.convertToEntities([testDTO])).toEqual([testEntity])
     })
   })
 })

packages/core/src/assemblers/abstract.assembler.ts

@@ -34,49 +34,29 @@ export abstract class AbstractAssembler<DTO, Entity, C = DeepPartial<DTO>, CE =
     this.EntityClass = EntityClas
   }
 
-  abstract convertToDTO(entity: Entity): DTO
+  public abstract convertToDTO(entity: Entity): Promise<DTO> | DTO
 
-  abstract convertToEntity(dto: DTO): Entity
+  public abstract convertToEntity(dto: DTO): Promise<Entity> | Entity
 
-  abstract convertQuery(query: Query<DTO>): Query<Entity>
+  public abstract convertQuery(query: Query<DTO>): Query<Entity>
 
-  abstract convertAggregateQuery(aggregate: AggregateQuery<DTO>): AggregateQuery<Entity>
+  public abstract convertAggregateQuery(aggregate: AggregateQuery<DTO>): AggregateQuery<Entity>
 
-  abstract convertAggregateResponse(aggregate: AggregateResponse<Entity>): AggregateResponse<DTO>
+  public abstract convertAggregateResponse(aggregate: AggregateResponse<Entity>): AggregateResponse<DTO>
 
-  abstract convertToCreateEntity(create: C): CE
+  public abstract convertToCreateEntity(create: C): Promise<CE> | CE
 
-  abstract convertToUpdateEntity(update: U): UE
+  public abstract convertToUpdateEntity(update: U): Promise<UE> | UE
 
-  convertToDTOs(entities: Entity[]): DTO[] {
-    return entities.map((e) => this.convertToDTO(e))
+  public convertToDTOs(entities: Entity[]): Promise<DTO[]> {
+    return Promise.all(entities.map((e) => this.convertToDTO(e)))
   }
 
-  convertToEntities(dtos: DTO[]): Entity[] {
-    return dtos.map((dto) => this.convertToEntity(dto))
+  public convertToEntities(dtos: DTO[]): Promise<Entity[]> {
+    return Promise.all(dtos.map((dto) => this.convertToEntity(dto)))
   }
 
-  convertToCreateEntities(createDtos: C[]): CE[] {
-    return createDtos.map((c) => this.convertToCreateEntity(c))
-  }
-
-  async convertAsyncToDTO(entity: Promise<Entity>): Promise<DTO> {
-    const e = await entity
-    return this.convertToDTO(e)
-  }
-
-  async convertAsyncToDTOs(entities: Promise<Entity[]>): Promise<DTO[]> {
-    const es = await entities
-    return this.convertToDTOs(es)
-  }
-
-  async convertAsyncToEntity(dto: Promise<DTO>): Promise<Entity> {
-    const d = await dto
-    return this.convertToEntity(d)
-  }
-
-  async convertAsyncToEntities(dtos: Promise<DTO[]>): Promise<Entity[]> {
-    const ds = await dtos
-    return this.convertToEntities(ds)
+  public convertToCreateEntities(createDtos: C[]): Promise<CE[]> {
+    return Promise.all(createDtos.map((c) => this.convertToCreateEntity(c)))
   }
 }

packages/core/src/assemblers/assembler.ts

@@ -14,13 +14,13 @@ export interface Assembler<
    * Convert an entity to a DTO
    * @param entity - the entity to convert
    */
-  convertToDTO(entity: Entity): DTO
+  convertToDTO(entity: Entity): Promise<DTO> | DTO
 
   /**
    * Convert a DTO to an entity.
    * @param dto - The dto to convert.
    */
-  convertToEntity(dto: DTO): Entity
+  convertToEntity(dto: DTO): Promise<Entity> | Entity
 
   /**
    * Convert a DTO query to an entity query.
@@ -44,55 +44,31 @@ export interface Assembler<
    * Convert a create dto input to the equivalent create entity type
    * @param createDTO
    */
-  convertToCreateEntity(createDTO: CreateDTO): CreateEntity
+  convertToCreateEntity(createDTO: CreateDTO): Promise<CreateEntity> | CreateEntity
 
   /**
    * Convert a update dto input to the equivalent update entity type
    * @param createDTO
    */
-  convertToUpdateEntity(createDTO: UpdateDTO): UpdateEntity
+  convertToUpdateEntity(createDTO: UpdateDTO): Promise<UpdateEntity> | UpdateEntity
 
   /**
    * Convert an array of entities to a an of DTOs
    * @param entities - the entities to convert.
    */
-  convertToDTOs(entities: Entity[]): DTO[]
+  convertToDTOs(entities: Entity[]): Promise<DTO[]>
 
   /**
    * Convert an array of DTOs to an array of entities.
    * @param dtos - the dtos to convert.
    */
-  convertToEntities(dtos: DTO[]): Entity[]
-
-  /**
-   * Convert an entity to a DTO.
-   * @param entity - the promise that should resolve with the entity.
-   */
-  convertAsyncToDTO(entity: Promise<Entity>): Promise<DTO>
-
-  /**
-   * Convert an array of entities to an array of DTOs.
-   * @param entities - the promise that should resolve with the entity array.
-   */
-  convertAsyncToDTOs(entities: Promise<Entity[]>): Promise<DTO[]>
-
-  /**
-   * Convert a DTO to an entity.
-   * @param dto - the promise that should resolve with the DTO.
-   */
-  convertAsyncToEntity(dto: Promise<DTO>): Promise<Entity>
-
-  /**
-   * Convert an array of DTOs to an array of entities.
-   * @param dtos - the promise that should resolve with the dtos.
-   */
-  convertAsyncToEntities(dtos: Promise<DTO[]>): Promise<Entity[]>
+  convertToEntities(dtos: DTO[]): Promise<Entity[]>
 
   /**
    * Convert an array of create DTOs to an array of create entities
    * @param createDtos
    */
-  convertToCreateEntities(createDtos: CreateDTO[]): CreateEntity[]
+  convertToCreateEntities(createDtos: CreateDTO[]): Promise<CreateEntity[]>
 }
 
 const assemblerReflector = new ValueReflector(ASSEMBLER_CLASSES_KEY)

packages/core/src/services/assembler-query.service.ts

@@ -28,35 +28,35 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     readonly queryService: QueryService<Entity, CE, UE>
   ) {}
 
-  public addRelations<Relation>(
+  public async addRelations<Relation>(
     relationName: string,
     id: string | number,
     relationIds: (string | number)[],
     opts?: ModifyRelationOptions<DTO, Relation>
   ): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(
-      this.queryService.addRelations(relationName, id, relationIds, this.convertModifyRelationsOptions(opts))
+    return this.assembler.convertToDTO(
+      await this.queryService.addRelations(relationName, id, relationIds, this.convertModifyRelationsOptions(opts))
     )
   }
 
-  public createMany(items: C[]): Promise<DTO[]> {
+  public async createMany(items: C[]): Promise<DTO[]> {
     const { assembler } = this
-    const converted = assembler.convertToCreateEntities(items)
-    return this.assembler.convertAsyncToDTOs(this.queryService.createMany(converted))
+    const converted = await assembler.convertToCreateEntities(items)
+    return this.assembler.convertToDTOs(await this.queryService.createMany(converted))
   }
 
-  public createOne(item: C): Promise<DTO> {
-    const c = this.assembler.convertToCreateEntity(item)
-    return this.assembler.convertAsyncToDTO(this.queryService.createOne(c))
+  public async createOne(item: C): Promise<DTO> {
+    const c = await this.assembler.convertToCreateEntity(item)
+    return this.assembler.convertToDTO(await this.queryService.createOne(c))
   }
 
   public async deleteMany(filter: Filter<DTO>): Promise<DeleteManyResponse> {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     return this.queryService.deleteMany(this.assembler.convertQuery({ filter }).filter)
   }
 
-  public deleteOne(id: number | string, opts?: DeleteOneOptions<DTO>): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(this.queryService.deleteOne(id, this.convertFilterable(opts)))
+  public async deleteOne(id: number | string, opts?: DeleteOneOptions<DTO>): Promise<DTO> {
+    return this.assembler.convertToDTO(await this.queryService.deleteOne(id, this.convertFilterable(opts)))
   }
 
   public async findById(id: string | number, opts?: FindByIdOptions<DTO>): Promise<DTO | undefined> {
@@ -67,12 +67,12 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     return this.assembler.convertToDTO(entity)
   }
 
-  public getById(id: string | number, opts?: GetByIdOptions<DTO>): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(this.queryService.getById(id, this.convertFilterable(opts)))
+  public async getById(id: string | number, opts?: GetByIdOptions<DTO>): Promise<DTO> {
+    return this.assembler.convertToDTO(await this.queryService.getById(id, this.convertFilterable(opts)))
   }
 
-  public query(query: Query<DTO>, opts?: QueryOptions<DTO>): Promise<DTO[]> {
-    return this.assembler.convertAsyncToDTOs(this.queryService.query(this.assembler.convertQuery(query), opts as never))
+  public async query(query: Query<DTO>, opts?: QueryOptions<DTO>): Promise<DTO[]> {
+    return this.assembler.convertToDTOs(await this.queryService.query(this.assembler.convertQuery(query), opts as never))
   }
 
   public async aggregate(
@@ -128,7 +128,7 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     query: Query<Relation>
   ): Promise<Relation[] | Map<DTO, Relation[]>> {
     if (Array.isArray(dto)) {
-      const entities = this.assembler.convertToEntities(dto)
+      const entities = await this.assembler.convertToEntities(dto)
       const relationMap = await this.queryService.queryRelations(RelationClass, relationName, entities, query)
 
       return entities.reduce((map, e, index) => {
@@ -140,7 +140,7 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
       }, new Map<DTO, Relation[]>())
     }
 
-    return this.queryService.queryRelations(RelationClass, relationName, this.assembler.convertToEntity(dto), query)
+    return this.queryService.queryRelations(RelationClass, relationName, await this.assembler.convertToEntity(dto), query)
   }
 
   public countRelations<Relation>(
@@ -164,15 +164,15 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     filter: Filter<Relation>
   ): Promise<number | Map<DTO, number>> {
     if (Array.isArray(dto)) {
-      const entities = this.assembler.convertToEntities(dto)
+      const entities = await this.assembler.convertToEntities(dto)
       const relationMap = await this.queryService.countRelations(RelationClass, relationName, entities, filter)
       return entities.reduce((map, e, index) => {
         const entry = relationMap.get(e) ?? 0
         map.set(dto[index], entry)
         return map
       }, new Map<DTO, number>())
     }
-    return this.queryService.countRelations(RelationClass, relationName, this.assembler.convertToEntity(dto), filter)
+    return this.queryService.countRelations(RelationClass, relationName, await this.assembler.convertToEntity(dto), filter)
   }
 
   /**
@@ -210,71 +210,71 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     opts?: FindRelationOptions<Relation>
   ): Promise<(Relation | undefined) | Map<DTO, Relation | undefined>> {
     if (Array.isArray(dto)) {
-      const entities = this.assembler.convertToEntities(dto)
+      const entities = await this.assembler.convertToEntities(dto)
       const relationMap = await this.queryService.findRelation(RelationClass, relationName, entities, opts)
       return entities.reduce((map, e, index) => {
         map.set(dto[index], relationMap.get(e))
         return map
       }, new Map<DTO, Relation | undefined>())
     }
-    return this.queryService.findRelation(RelationClass, relationName, this.assembler.convertToEntity(dto))
+    return this.queryService.findRelation(RelationClass, relationName, await this.assembler.convertToEntity(dto))
   }
 
-  public removeRelation<Relation>(
+  public async removeRelation<Relation>(
     relationName: string,
     id: string | number,
     relationId: string | number,
     opts?: ModifyRelationOptions<DTO, Relation>
   ): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(
-      this.queryService.removeRelation(relationName, id, relationId, this.convertModifyRelationsOptions(opts))
+    return this.assembler.convertToDTO(
+      await this.queryService.removeRelation(relationName, id, relationId, this.convertModifyRelationsOptions(opts))
     )
   }
 
-  public removeRelations<Relation>(
+  public async removeRelations<Relation>(
     relationName: string,
     id: string | number,
     relationIds: (string | number)[],
     opts?: ModifyRelationOptions<DTO, Relation>
   ): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(
-      this.queryService.removeRelations(relationName, id, relationIds, this.convertModifyRelationsOptions(opts))
+    return this.assembler.convertToDTO(
+      await this.queryService.removeRelations(relationName, id, relationIds, this.convertModifyRelationsOptions(opts))
     )
   }
 
-  public setRelations<Relation>(
+  public async setRelations<Relation>(
     relationName: string,
     id: string | number,
     relationIds: (string | number)[],
     opts?: ModifyRelationOptions<DTO, Relation>
   ): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(
-      this.queryService.setRelations(relationName, id, relationIds, this.convertModifyRelationsOptions(opts))
+    return this.assembler.convertToDTO(
+      await this.queryService.setRelations(relationName, id, relationIds, this.convertModifyRelationsOptions(opts))
     )
   }
 
-  public setRelation<Relation>(
+  public async setRelation<Relation>(
     relationName: string,
     id: string | number,
     relationId: string | number,
     opts?: ModifyRelationOptions<DTO, Relation>
   ): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(
-      this.queryService.setRelation(relationName, id, relationId, this.convertModifyRelationsOptions(opts))
+    return this.assembler.convertToDTO(
+      await this.queryService.setRelation(relationName, id, relationId, this.convertModifyRelationsOptions(opts))
     )
   }
 
-  public updateMany(update: U, filter: Filter<DTO>): Promise<UpdateManyResponse> {
+  public async updateMany(update: U, filter: Filter<DTO>): Promise<UpdateManyResponse> {
     return this.queryService.updateMany(
-      this.assembler.convertToUpdateEntity(update),
+      await this.assembler.convertToUpdateEntity(update),
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       this.assembler.convertQuery({ filter }).filter
     )
   }
 
-  public updateOne(id: string | number, update: U, opts?: UpdateOneOptions<DTO>): Promise<DTO> {
-    return this.assembler.convertAsyncToDTO(
-      this.queryService.updateOne(id, this.assembler.convertToUpdateEntity(update), this.convertFilterable(opts))
+  public async updateOne(id: string | number, update: U, opts?: UpdateOneOptions<DTO>): Promise<DTO> {
+    return this.assembler.convertToDTO(
+      await this.queryService.updateOne(id, await this.assembler.convertToUpdateEntity(update), this.convertFilterable(opts))
     )
   }
 
@@ -300,7 +300,7 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     aggregate: AggregateQuery<Relation>
   ): Promise<AggregateResponse<Relation>[] | Map<DTO, AggregateResponse<Relation>[]>> {
     if (Array.isArray(dto)) {
-      const entities = this.assembler.convertToEntities(dto)
+      const entities = await this.assembler.convertToEntities(dto)
       const relationMap = await this.queryService.aggregateRelations(RelationClass, relationName, entities, filter, aggregate)
       return entities.reduce((map, e, index) => {
         const entry = relationMap.get(e) ?? []
@@ -311,7 +311,7 @@ export class AssemblerQueryService<DTO, Entity, C = DeepPartial<DTO>, CE = DeepP
     return this.queryService.aggregateRelations(
       RelationClass,
       relationName,
-      this.assembler.convertToEntity(dto),
+      await this.assembler.convertToEntity(dto),
       filter,
       aggregate
     )