@forklaunch/implementation-iam-base 0.3.1 → 0.3.3

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

@@ -8,60 +8,24 @@ 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 {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
-import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
-import {
-  CreateRoleDto,
-  RoleDto,
-  UpdateRoleDto
-} from '@forklaunch/interfaces-iam/types';
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
 import { AnySchemaValidator } from '@forklaunch/validator';
+import { RoleDtos } from '../domain/types/iamDto.types';
+import { RoleEntities } from '../domain/types/iamEntities.types';
 
 export class BaseRoleService<
   SchemaValidator extends AnySchemaValidator,
-  Metrics extends MetricsDefinition = MetricsDefinition,
-  Dto extends {
-    RoleDtoMapper: RoleDto;
-    CreateRoleDtoMapper: CreateRoleDto;
-    UpdateRoleDtoMapper: UpdateRoleDto;
-  } = {
-    RoleDtoMapper: RoleDto;
-    CreateRoleDtoMapper: CreateRoleDto;
-    UpdateRoleDtoMapper: UpdateRoleDto;
-  },
-  Entities extends {
-    RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-    CreateRoleDtoMapper: MapNestedDtoArraysToCollections<
-      RoleDto,
-      'permissions'
-    >;
-    UpdateRoleDtoMapper: MapNestedDtoArraysToCollections<
-      RoleDto,
-      'permissions'
-    >;
-  } = {
-    RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-    CreateRoleDtoMapper: MapNestedDtoArraysToCollections<
-      RoleDto,
-      'permissions'
-    >;
-    UpdateRoleDtoMapper: MapNestedDtoArraysToCollections<
-      RoleDto,
-      'permissions'
-    >;
-  }
+  MapperEntities extends RoleEntities,
+  MapperDto extends RoleDtos = RoleDtos
 > implements RoleService
 {
-  #mappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mappers>,
-    Entities,
-    Dto
-  >;
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   private evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
@@ -70,30 +34,38 @@ export class BaseRoleService<
 
   constructor(
     public em: EntityManager,
-    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     protected schemaValidator: SchemaValidator,
     protected mappers: {
-      RoleDtoMapper: ResponseDtoMapperConstructor<
+      RoleMapper: ResponseMapperConstructor<
         SchemaValidator,
-        Dto['RoleDtoMapper'],
-        Entities['RoleDtoMapper']
+        MapperDto['RoleMapper'],
+        MapperEntities['RoleMapper']
       >;
-      CreateRoleDtoMapper: RequestDtoMapperConstructor<
+      CreateRoleMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['CreateRoleDtoMapper'],
-        Entities['CreateRoleDtoMapper']
+        MapperDto['CreateRoleMapper'],
+        MapperEntities['CreateRoleMapper'],
+        (
+          dto: MapperDto['CreateRoleMapper'],
+          em: EntityManager
+        ) => Promise<MapperEntities['CreateRoleMapper']>
       >;
-      UpdateRoleDtoMapper: RequestDtoMapperConstructor<
+      UpdateRoleMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['UpdateRoleDtoMapper'],
-        Entities['UpdateRoleDtoMapper']
+        MapperDto['UpdateRoleMapper'],
+        MapperEntities['UpdateRoleMapper'],
+        (
+          dto: MapperDto['UpdateRoleMapper'],
+          em: EntityManager
+        ) => Promise<MapperEntities['UpdateRoleMapper']>
       >;
     },
     options?: {
       telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
       : {
@@ -104,13 +76,13 @@ export class BaseRoleService<
   }
 
   async createRole(
-    roleDto: Dto['CreateRoleDtoMapper'],
+    roleDto: MapperDto['CreateRoleMapper'],
     em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper']> {
+  ): Promise<MapperDto['RoleMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating role', roleDto);
     }
-    const role = await this.#mappers.CreateRoleDtoMapper.deserializeDtoToEntity(
+    const role = await this._mappers.CreateRoleMapper.deserializeDtoToEntity(
       roleDto,
       em ?? this.em
     );
@@ -121,20 +93,20 @@ export class BaseRoleService<
       await this.em.persistAndFlush(role);
     }
 
-    return this.#mappers.RoleDtoMapper.serializeEntityToDto(role);
+    return this._mappers.RoleMapper.serializeEntityToDto(role);
   }
 
   async createBatchRoles(
-    roleDtos: Dto['CreateRoleDtoMapper'][],
+    roleDtos: MapperDto['CreateRoleMapper'][],
     em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper'][]> {
+  ): Promise<MapperDto['RoleMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating batch roles', roleDtos);
     }
 
     const roles = await Promise.all(
       roleDtos.map(async (roleDto) =>
-        this.#mappers.CreateRoleDtoMapper.deserializeDtoToEntity(
+        this._mappers.CreateRoleMapper.deserializeDtoToEntity(
           roleDto,
           em ?? this.em
         )
@@ -148,9 +120,7 @@ export class BaseRoleService<
     }
 
     return Promise.all(
-      roles.map((role) =>
-        this.#mappers.RoleDtoMapper.serializeEntityToDto(role)
-      )
+      roles.map((role) => this._mappers.RoleMapper.serializeEntityToDto(role))
     );
   }
 
@@ -163,8 +133,8 @@ export class BaseRoleService<
       populate: ['id', '*']
     });
 
-    return this.#mappers.RoleDtoMapper.serializeEntityToDto(
-      role as Entities['RoleDtoMapper']
+    return this._mappers.RoleMapper.serializeEntityToDto(
+      role as MapperEntities['RoleMapper']
     );
   }
 
@@ -185,22 +155,22 @@ export class BaseRoleService<
           }
         )
       ).map((role) =>
-        this.#mappers.RoleDtoMapper.serializeEntityToDto(
-          role as Entities['RoleDtoMapper']
+        this._mappers.RoleMapper.serializeEntityToDto(
+          role as MapperEntities['RoleMapper']
         )
       )
     );
   }
 
   async updateRole(
-    roleDto: Dto['UpdateRoleDtoMapper'],
+    roleDto: MapperDto['UpdateRoleMapper'],
     em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper']> {
+  ): Promise<MapperDto['RoleMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating role', roleDto);
     }
 
-    const role = await this.#mappers.UpdateRoleDtoMapper.deserializeDtoToEntity(
+    const role = await this._mappers.UpdateRoleMapper.deserializeDtoToEntity(
       roleDto,
       em ?? this.em
     );
@@ -211,20 +181,20 @@ export class BaseRoleService<
       await this.em.persistAndFlush(role);
     }
 
-    return this.#mappers.RoleDtoMapper.serializeEntityToDto(role);
+    return this._mappers.RoleMapper.serializeEntityToDto(role);
   }
 
   async updateBatchRoles(
-    roleDtos: Dto['UpdateRoleDtoMapper'][],
+    roleDtos: MapperDto['UpdateRoleMapper'][],
     em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper'][]> {
+  ): Promise<MapperDto['RoleMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating batch roles', roleDtos);
     }
 
     const roles = await Promise.all(
       roleDtos.map(async (roleDto) =>
-        this.#mappers.UpdateRoleDtoMapper.deserializeDtoToEntity(
+        this._mappers.UpdateRoleMapper.deserializeDtoToEntity(
           roleDto,
           em ?? this.em
         )
@@ -238,8 +208,8 @@ export class BaseRoleService<
     }
     return Promise.all(
       roles.map((role) =>
-        this.#mappers.RoleDtoMapper.serializeEntityToDto(
-          role as Entities['RoleDtoMapper']
+        this._mappers.RoleMapper.serializeEntityToDto(
+          role as MapperEntities['RoleMapper']
         )
       )
     );

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

@@ -11,50 +11,26 @@ import {
   OpenTelemetryCollector,
   TelemetryOptions
 } from '@forklaunch/core/http';
+import { UpdateUserDto } from '@forklaunch/interfaces-iam/types';
 import {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
-import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
-import {
-  CreateUserDto,
-  UpdateUserDto,
-  UserDto
-} from '@forklaunch/interfaces-iam/types';
+  InternalMapper,
+  RequestMapperConstructor,
+  ResponseMapperConstructor,
+  transformIntoInternalMapper
+} from '@forklaunch/internal';
 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';
 
 export class BaseUserService<
   SchemaValidator extends AnySchemaValidator,
   OrganizationStatus,
-  Metrics extends MetricsDefinition = MetricsDefinition,
-  Dto extends {
-    UserDtoMapper: UserDto;
-    CreateUserDtoMapper: CreateUserDto;
-    UpdateUserDtoMapper: UpdateUserDto;
-  } = {
-    UserDtoMapper: UserDto;
-    CreateUserDtoMapper: CreateUserDto;
-    UpdateUserDtoMapper: UpdateUserDto;
-  },
-  Entities extends {
-    UserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-    CreateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-    UpdateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-  } = {
-    UserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-    CreateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-    UpdateUserDtoMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-  }
+  Entities extends UserEntities,
+  Dto extends UserDtos = UserDtos
 > implements UserService
 {
-  #mappers: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mappers>,
-    Entities,
-    Dto
-  >;
+  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   private evaluatedTelemetryOptions: {
     logging?: boolean;
     metrics?: boolean;
@@ -66,30 +42,38 @@ export class BaseUserService<
     protected passwordEncryptionPublicKeyPath: string,
     protected roleServiceFactory: () => RoleService,
     protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>,
-    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     protected schemaValidator: SchemaValidator,
     protected mappers: {
-      UserDtoMapper: ResponseDtoMapperConstructor<
+      UserMapper: ResponseMapperConstructor<
         SchemaValidator,
-        Dto['UserDtoMapper'],
-        Entities['UserDtoMapper']
+        Dto['UserMapper'],
+        Entities['UserMapper']
       >;
-      CreateUserDtoMapper: RequestDtoMapperConstructor<
+      CreateUserMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['CreateUserDtoMapper'],
-        Entities['CreateUserDtoMapper']
+        Dto['CreateUserMapper'],
+        Entities['CreateUserMapper'],
+        (
+          dto: Dto['CreateUserMapper'],
+          em: EntityManager
+        ) => Promise<Entities['CreateUserMapper']>
       >;
-      UpdateUserDtoMapper: RequestDtoMapperConstructor<
+      UpdateUserMapper: RequestMapperConstructor<
         SchemaValidator,
-        Dto['UpdateUserDtoMapper'],
-        Entities['UpdateUserDtoMapper']
+        Dto['UpdateUserMapper'],
+        Entities['UpdateUserMapper'],
+        (
+          dto: Dto['UpdateUserMapper'],
+          em: EntityManager
+        ) => Promise<Entities['UpdateUserMapper']>
       >;
     },
     readonly options?: {
       telemetry?: TelemetryOptions;
     }
   ) {
-    this.#mappers = transformIntoInternalDtoMapper(mappers, schemaValidator);
+    this._mappers = transformIntoInternalMapper(mappers, schemaValidator);
     this.evaluatedTelemetryOptions = options?.telemetry
       ? evaluateTelemetryOptions(options.telemetry).enabled
       : {
@@ -100,14 +84,14 @@ export class BaseUserService<
   }
 
   async createUser(
-    userDto: Dto['CreateUserDtoMapper'],
+    userDto: Dto['CreateUserMapper'],
     em?: EntityManager
-  ): Promise<Dto['UserDtoMapper']> {
+  ): Promise<Dto['UserMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating user', userDto);
     }
 
-    const user = await this.#mappers.CreateUserDtoMapper.deserializeDtoToEntity(
+    const user = await this._mappers.CreateUserMapper.deserializeDtoToEntity(
       userDto,
       em ?? this.em
     );
@@ -118,20 +102,20 @@ export class BaseUserService<
       await this.em.persistAndFlush(user);
     }
 
-    return this.#mappers.UserDtoMapper.serializeEntityToDto(user);
+    return this._mappers.UserMapper.serializeEntityToDto(user);
   }
 
   async createBatchUsers(
-    userDtos: Dto['CreateUserDtoMapper'][],
+    userDtos: Dto['CreateUserMapper'][],
     em?: EntityManager
-  ): Promise<Dto['UserDtoMapper'][]> {
+  ): Promise<Dto['UserMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Creating batch users', userDtos);
     }
 
     const users = await Promise.all(
       userDtos.map(async (createUserDto) =>
-        this.#mappers.CreateUserDtoMapper.deserializeDtoToEntity(
+        this._mappers.CreateUserMapper.deserializeDtoToEntity(
           createUserDto,
           em ?? this.em
         )
@@ -145,16 +129,11 @@ export class BaseUserService<
     }
 
     return Promise.all(
-      users.map((user) =>
-        this.#mappers.UserDtoMapper.serializeEntityToDto(user)
-      )
+      users.map((user) => this._mappers.UserMapper.serializeEntityToDto(user))
     );
   }
 
-  async getUser(
-    idDto: IdDto,
-    em?: EntityManager
-  ): Promise<Dto['UserDtoMapper']> {
+  async getUser(idDto: IdDto, em?: EntityManager): Promise<Dto['UserMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting user', idDto);
     }
@@ -163,15 +142,15 @@ export class BaseUserService<
       populate: ['id', '*']
     });
 
-    return this.#mappers.UserDtoMapper.serializeEntityToDto(
-      user as Entities['UserDtoMapper']
+    return this._mappers.UserMapper.serializeEntityToDto(
+      user as Entities['UserMapper']
     );
   }
 
   async getBatchUsers(
     idsDto: IdsDto,
     em?: EntityManager
-  ): Promise<Dto['UserDtoMapper'][]> {
+  ): Promise<Dto['UserMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Getting batch users', idsDto);
     }
@@ -182,22 +161,22 @@ export class BaseUserService<
           populate: ['id', '*']
         })
       ).map((user) =>
-        this.#mappers.UserDtoMapper.serializeEntityToDto(
-          user as Entities['UserDtoMapper']
+        this._mappers.UserMapper.serializeEntityToDto(
+          user as Entities['UserMapper']
         )
       )
     );
   }
 
   async updateUser(
-    userDto: Dto['UpdateUserDtoMapper'],
+    userDto: Dto['UpdateUserMapper'],
     em?: EntityManager
-  ): Promise<Dto['UserDtoMapper']> {
+  ): Promise<Dto['UserMapper']> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating user', userDto);
     }
 
-    const user = await this.#mappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+    const user = await this._mappers.UpdateUserMapper.deserializeDtoToEntity(
       userDto,
       em ?? this.em
     );
@@ -208,20 +187,20 @@ export class BaseUserService<
       await this.em.persistAndFlush(user);
     }
 
-    return this.#mappers.UserDtoMapper.serializeEntityToDto(user);
+    return this._mappers.UserMapper.serializeEntityToDto(user);
   }
 
   async updateBatchUsers(
     userDtos: UpdateUserDto[],
     em?: EntityManager
-  ): Promise<Dto['UserDtoMapper'][]> {
+  ): Promise<Dto['UserMapper'][]> {
     if (this.evaluatedTelemetryOptions.logging) {
       this.openTelemetryCollector.info('Updating batch users', userDtos);
     }
 
     const users = await Promise.all(
       userDtos.map(async (updateUserDto) =>
-        this.#mappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+        this._mappers.UpdateUserMapper.deserializeDtoToEntity(
           updateUserDto,
           em ?? this.em
         )
@@ -235,9 +214,7 @@ export class BaseUserService<
     }
 
     return Promise.all(
-      users.map((user) =>
-        this.#mappers.UserDtoMapper.serializeEntityToDto(user)
-      )
+      users.map((user) => this._mappers.UserMapper.serializeEntityToDto(user))
     );
   }