@forklaunch/implementation-iam-base 0.5.8 → 0.6.0

package/lib/eject/services/role.service.ts

@@ -7,25 +7,23 @@ import {
 import { RoleService } from '@forklaunch/interfaces-iam/interfaces';
 import { EntityManager } from '@mikro-orm/core';
 
-import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
-import { RoleDto } from '@forklaunch/interfaces-iam/types';
+import { IdDto, IdsDto } from '@forklaunch/common';
 import {
-  InternalMapper,
-  RequestMapperConstructor,
-  ResponseMapperConstructor,
-  transformIntoInternalMapper
-} from '@forklaunch/internal';
+  CreateRoleDto,
+  RoleDto,
+  UpdateRoleDto
+} from '@forklaunch/interfaces-iam/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { RoleDtos } from '../domain/types/iamDto.types';
 import { RoleEntities } from '../domain/types/iamEntities.types';
+import { RoleMappers } from '../domain/types/role.mapper.types';
 
 export class BaseRoleService<
   SchemaValidator extends AnySchemaValidator,
-  MapperEntities extends RoleEntities,
-  MapperDto extends RoleDtos = RoleDtos
+  MapperEntities extends RoleEntities = RoleEntities,
+  MapperDomains extends RoleDtos = RoleDtos
 > implements RoleService
 {
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   private evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
@@ -34,61 +32,13 @@ export class BaseRoleService<
   public em: EntityManager;
   protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
   protected schemaValidator: SchemaValidator;
-  protected mappers: {
-    RoleMapper: ResponseMapperConstructor<
-      SchemaValidator,
-      MapperDto['RoleMapper'],
-      MapperEntities['RoleMapper']
-    >;
-    CreateRoleMapper: RequestMapperConstructor<
-      SchemaValidator,
-      MapperDto['CreateRoleMapper'],
-      MapperEntities['CreateRoleMapper'],
-      (
-        dto: MapperDto['CreateRoleMapper'],
-        em: EntityManager
-      ) => Promise<MapperEntities['CreateRoleMapper']>
-    >;
-    UpdateRoleMapper: RequestMapperConstructor<
-      SchemaValidator,
-      MapperDto['UpdateRoleMapper'],
-      MapperEntities['UpdateRoleMapper'],
-      (
-        dto: MapperDto['UpdateRoleMapper'],
-        em: EntityManager
-      ) => Promise<MapperEntities['UpdateRoleMapper']>
-    >;
-  };
+  protected mappers: RoleMappers<MapperEntities, MapperDomains>;
 
   constructor(
     em: EntityManager,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    mappers: {
-      RoleMapper: ResponseMapperConstructor<
-        SchemaValidator,
-        MapperDto['RoleMapper'],
-        MapperEntities['RoleMapper']
-      >;
-      CreateRoleMapper: RequestMapperConstructor<
-        SchemaValidator,
-        MapperDto['CreateRoleMapper'],
-        MapperEntities['CreateRoleMapper'],
-        (
-          dto: MapperDto['CreateRoleMapper'],
-          em: EntityManager
-        ) => Promise<MapperEntities['CreateRoleMapper']>
-      >;
-      UpdateRoleMapper: RequestMapperConstructor<
-        SchemaValidator,
-        MapperDto['UpdateRoleMapper'],
-        MapperEntities['UpdateRoleMapper'],
-        (
-          dto: MapperDto['UpdateRoleMapper'],
-          em: EntityManager
-        ) => Promise<MapperEntities['UpdateRoleMapper']>
-      >;
-    },
+    mappers: RoleMappers<MapperEntities, MapperDomains>,
     options?: {
       telemetry?: TelemetryOptions;
     }
@@ -97,7 +47,6 @@ export class BaseRoleService<
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
       : {
@@ -108,15 +57,17 @@ export class BaseRoleService<
   }
 
   async createRole(
-    roleDto: MapperDto['CreateRoleMapper'],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper']> {
+    roleDto: CreateRoleDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating role', roleDto);
     }
-    const role = await this._mappers.CreateRoleMapper.deserializeDtoToEntity(
+    const role = await this.mappers.CreateRoleMapper.toEntity(
       roleDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
 
     if (em) {
@@ -125,23 +76,21 @@ export class BaseRoleService<
       await this.em.persistAndFlush(role);
     }
 
-    return this._mappers.RoleMapper.serializeEntityToDto(role);
+    return this.mappers.RoleMapper.toDto(role);
   }
 
   async createBatchRoles(
-    roleDtos: MapperDto['CreateRoleMapper'][],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper'][]> {
+    roleDtos: CreateRoleDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto[]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating batch roles', roleDtos);
     }
 
     const roles = await Promise.all(
       roleDtos.map(async (roleDto) =>
-        this._mappers.CreateRoleMapper.deserializeDtoToEntity(
-          roleDto,
-          em ?? this.em
-        )
+        this.mappers.CreateRoleMapper.toEntity(roleDto, em ?? this.em, ...args)
       )
     );
 
@@ -152,7 +101,7 @@ export class BaseRoleService<
     }
 
     return Promise.all(
-      roles.map((role) => this._mappers.RoleMapper.serializeEntityToDto(role))
+      roles.map((role) => this.mappers.RoleMapper.toDto(role))
     );
   }
 
@@ -165,9 +114,7 @@ export class BaseRoleService<
       populate: ['id', '*']
     });
 
-    return this._mappers.RoleMapper.serializeEntityToDto(
-      role as MapperEntities['RoleMapper']
-    );
+    return this.mappers.RoleMapper.toDto(role as MapperEntities['RoleMapper']);
   }
 
   async getBatchRoles({ ids }: IdsDto, em?: EntityManager): Promise<RoleDto[]> {
@@ -187,24 +134,24 @@ export class BaseRoleService<
           }
         )
       ).map((role) =>
-        this._mappers.RoleMapper.serializeEntityToDto(
-          role as MapperEntities['RoleMapper']
-        )
+        this.mappers.RoleMapper.toDto(role as MapperEntities['RoleMapper'])
       )
     );
   }
 
   async updateRole(
-    roleDto: MapperDto['UpdateRoleMapper'],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper']> {
+    roleDto: UpdateRoleDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating role', roleDto);
     }
 
-    const role = await this._mappers.UpdateRoleMapper.deserializeDtoToEntity(
+    const role = await this.mappers.UpdateRoleMapper.toEntity(
       roleDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
 
     if (em) {
@@ -213,23 +160,21 @@ export class BaseRoleService<
       await this.em.persistAndFlush(role);
     }
 
-    return this._mappers.RoleMapper.serializeEntityToDto(role);
+    return this.mappers.RoleMapper.toDto(role);
   }
 
   async updateBatchRoles(
-    roleDtos: MapperDto['UpdateRoleMapper'][],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper'][]> {
+    roleDtos: UpdateRoleDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto[]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating batch roles', roleDtos);
     }
 
     const roles = await Promise.all(
       roleDtos.map(async (roleDto) =>
-        this._mappers.UpdateRoleMapper.deserializeDtoToEntity(
-          roleDto,
-          em ?? this.em
-        )
+        this.mappers.UpdateRoleMapper.toEntity(roleDto, em ?? this.em, ...args)
       )
     );
 
@@ -240,9 +185,7 @@ export class BaseRoleService<
     }
     return Promise.all(
       roles.map((role) =>
-        this._mappers.RoleMapper.serializeEntityToDto(
-          role as MapperEntities['RoleMapper']
-        )
+        this.mappers.RoleMapper.toDto(role as MapperEntities['RoleMapper'])
       )
     );
   }

package/lib/eject/services/user.service.ts

@@ -4,33 +4,27 @@ import {
   UserService
 } from '@forklaunch/interfaces-iam/interfaces';
 
-import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import { IdDto, IdsDto } from '@forklaunch/common';
 import {
   evaluateTelemetryOptions,
   MetricsDefinition,
   OpenTelemetryCollector,
   TelemetryOptions
 } from '@forklaunch/core/http';
-import { UpdateUserDto } from '@forklaunch/interfaces-iam/types';
-import {
-  InternalMapper,
-  RequestMapperConstructor,
-  ResponseMapperConstructor,
-  transformIntoInternalMapper
-} from '@forklaunch/internal';
+import { CreateUserDto, UpdateUserDto } from '@forklaunch/interfaces-iam/types';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
 import { UserDtos } from '../domain/types/iamDto.types';
 import { UserEntities } from '../domain/types/iamEntities.types';
+import { UserMappers } from '../domain/types/user.mapper.types';
 
 export class BaseUserService<
   SchemaValidator extends AnySchemaValidator,
-  OrganizationStatus,
-  Entities extends UserEntities,
-  Dto extends UserDtos = UserDtos
+  OrganizationStatus = unknown,
+  MapperEntities extends UserEntities = UserEntities,
+  MapperDomains extends UserDtos = UserDtos
 > implements UserService
 {
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   private evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
@@ -42,31 +36,7 @@ export class BaseUserService<
   protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>;
   protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
   protected schemaValidator: SchemaValidator;
-  protected mappers: {
-    UserMapper: ResponseMapperConstructor<
-      SchemaValidator,
-      Dto['UserMapper'],
-      Entities['UserMapper']
-    >;
-    CreateUserMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['CreateUserMapper'],
-      Entities['CreateUserMapper'],
-      (
-        dto: Dto['CreateUserMapper'],
-        em: EntityManager
-      ) => Promise<Entities['CreateUserMapper']>
-    >;
-    UpdateUserMapper: RequestMapperConstructor<
-      SchemaValidator,
-      Dto['UpdateUserMapper'],
-      Entities['UpdateUserMapper'],
-      (
-        dto: Dto['UpdateUserMapper'],
-        em: EntityManager
-      ) => Promise<Entities['UpdateUserMapper']>
-    >;
-  };
+  protected mappers: UserMappers<MapperEntities, MapperDomains>;
 
   constructor(
     em: EntityManager,
@@ -75,32 +45,8 @@ export class BaseUserService<
     organizationServiceFactory: () => OrganizationService<OrganizationStatus>,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    mappers: {
-      UserMapper: ResponseMapperConstructor<
-        SchemaValidator,
-        Dto['UserMapper'],
-        Entities['UserMapper']
-      >;
-      CreateUserMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['CreateUserMapper'],
-        Entities['CreateUserMapper'],
-        (
-          dto: Dto['CreateUserMapper'],
-          em: EntityManager
-        ) => Promise<Entities['CreateUserMapper']>
-      >;
-      UpdateUserMapper: RequestMapperConstructor<
-        SchemaValidator,
-        Dto['UpdateUserMapper'],
-        Entities['UpdateUserMapper'],
-        (
-          dto: Dto['UpdateUserMapper'],
-          em: EntityManager
-        ) => Promise<Entities['UpdateUserMapper']>
-      >;
-    },
-    readonly options?: {
+    mappers: UserMappers<MapperEntities, MapperDomains>,
+    options?: {
       telemetry?: TelemetryOptions;
     }
   ) {
@@ -111,7 +57,6 @@ export class BaseUserService<
     this.openTelemetryCollector = openTelemetryCollector;
     this.schemaValidator = schemaValidator;
     this.mappers = mappers;
-    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
       : {
@@ -122,16 +67,18 @@ export class BaseUserService<
   }
 
   async createUser(
-    userDto: Dto['CreateUserMapper'],
-    em?: EntityManager
-  ): Promise<Dto['UserMapper']> {
+    userDto: CreateUserDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating user', userDto);
     }
 
-    const user = await this._mappers.CreateUserMapper.deserializeDtoToEntity(
+    const user = await this.mappers.CreateUserMapper.toEntity(
       userDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
 
     if (em) {
@@ -140,22 +87,24 @@ export class BaseUserService<
       await this.em.persistAndFlush(user);
     }
 
-    return this._mappers.UserMapper.serializeEntityToDto(user);
+    return this.mappers.UserMapper.toDto(user);
   }
 
   async createBatchUsers(
-    userDtos: Dto['CreateUserMapper'][],
-    em?: EntityManager
-  ): Promise<Dto['UserMapper'][]> {
+    userDtos: CreateUserDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating batch users', userDtos);
     }
 
     const users = await Promise.all(
       userDtos.map(async (createUserDto) =>
-        this._mappers.CreateUserMapper.deserializeDtoToEntity(
+        this.mappers.CreateUserMapper.toEntity(
           createUserDto,
-          em ?? this.em
+          em ?? this.em,
+          ...args
         )
       )
     );
@@ -167,11 +116,14 @@ export class BaseUserService<
     }
 
     return Promise.all(
-      users.map((user) => this._mappers.UserMapper.serializeEntityToDto(user))
+      users.map((user) => this.mappers.UserMapper.toDto(user))
     );
   }
 
-  async getUser(idDto: IdDto, em?: EntityManager): Promise<Dto['UserMapper']> {
+  async getUser(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['UserMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting user', idDto);
     }
@@ -180,15 +132,13 @@ export class BaseUserService<
       populate: ['id', '*']
     });
 
-    return this._mappers.UserMapper.serializeEntityToDto(
-      user as Entities['UserMapper']
-    );
+    return this.mappers.UserMapper.toDto(user as MapperEntities['UserMapper']);
   }
 
   async getBatchUsers(
     idsDto: IdsDto,
     em?: EntityManager
-  ): Promise<Dto['UserMapper'][]> {
+  ): Promise<MapperDomains['UserMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting batch users', idsDto);
     }
@@ -199,24 +149,24 @@ export class BaseUserService<
           populate: ['id', '*']
         })
       ).map((user) =>
-        this._mappers.UserMapper.serializeEntityToDto(
-          user as Entities['UserMapper']
-        )
+        this.mappers.UserMapper.toDto(user as MapperEntities['UserMapper'])
       )
     );
   }
 
   async updateUser(
-    userDto: Dto['UpdateUserMapper'],
-    em?: EntityManager
-  ): Promise<Dto['UserMapper']> {
+    userDto: UpdateUserDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating user', userDto);
     }
 
-    const user = await this._mappers.UpdateUserMapper.deserializeDtoToEntity(
+    const user = await this.mappers.UpdateUserMapper.toEntity(
       userDto,
-      em ?? this.em
+      em ?? this.em,
+      ...args
     );
 
     if (em) {
@@ -225,22 +175,24 @@ export class BaseUserService<
       await this.em.persistAndFlush(user);
     }
 
-    return this._mappers.UserMapper.serializeEntityToDto(user);
+    return this.mappers.UserMapper.toDto(user);
   }
 
   async updateBatchUsers(
     userDtos: UpdateUserDto[],
-    em?: EntityManager
-  ): Promise<Dto['UserMapper'][]> {
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating batch users', userDtos);
     }
 
     const users = await Promise.all(
       userDtos.map(async (updateUserDto) =>
-        this._mappers.UpdateUserMapper.deserializeDtoToEntity(
+        this.mappers.UpdateUserMapper.toEntity(
           updateUserDto,
-          em ?? this.em
+          em ?? this.em,
+          ...args
         )
       )
     );
@@ -252,7 +204,7 @@ export class BaseUserService<
     }
 
     return Promise.all(
-      users.map((user) => this._mappers.UserMapper.serializeEntityToDto(user))
+      users.map((user) => this.mappers.UserMapper.toDto(user))
     );
   }