@forklaunch/implementation-iam-base 0.3.0 → 0.3.2

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 '../types/iamDto.types';
+import { UserEntities } from '../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))
     );
   }
 

package/lib/eject/types/iamDto.types.ts

@@ -0,0 +1,43 @@
+import {
+  CreateOrganizationDto,
+  CreatePermissionDto,
+  CreateRoleDto,
+  CreateUserDto,
+  OrganizationDto,
+  PermissionDto,
+  RoleDto,
+  UpdateOrganizationDto,
+  UpdatePermissionDto,
+  UpdateRoleDto,
+  UpdateUserDto,
+  UserDto
+} from '@forklaunch/interfaces-iam/types';
+
+// organization
+export type OrganizationDtos<OrganizationStatus> = {
+  OrganizationMapper: OrganizationDto<OrganizationStatus>;
+  CreateOrganizationMapper: CreateOrganizationDto;
+  UpdateOrganizationMapper: UpdateOrganizationDto;
+};
+
+// permission
+export type PermissionDtos = {
+  PermissionMapper: PermissionDto;
+  CreatePermissionMapper: CreatePermissionDto;
+  UpdatePermissionMapper: UpdatePermissionDto;
+  RoleEntityMapper: UpdateRoleDto;
+};
+
+// role
+export type RoleDtos = {
+  RoleMapper: RoleDto;
+  CreateRoleMapper: CreateRoleDto;
+  UpdateRoleMapper: UpdateRoleDto;
+};
+
+// user
+export type UserDtos = {
+  UserMapper: UserDto;
+  CreateUserMapper: CreateUserDto;
+  UpdateUserMapper: UpdateUserDto;
+};

package/lib/eject/types/iamEntities.types.ts

@@ -0,0 +1,49 @@
+import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
+import {
+  OrganizationDto,
+  PermissionDto,
+  RoleDto,
+  UpdateRoleDto,
+  UserDto
+} from '@forklaunch/interfaces-iam/types';
+
+// organization
+export type OrganizationEntities<OrganizationStatus> = {
+  OrganizationMapper: MapNestedDtoArraysToCollections<
+    OrganizationDto<OrganizationStatus>,
+    'users'
+  >;
+  CreateOrganizationMapper: MapNestedDtoArraysToCollections<
+    OrganizationDto<OrganizationStatus>,
+    'users'
+  >;
+  UpdateOrganizationMapper: MapNestedDtoArraysToCollections<
+    OrganizationDto<OrganizationStatus>,
+    'users'
+  >;
+};
+
+// permission
+export type PermissionEntities = {
+  PermissionMapper: PermissionDto;
+  CreatePermissionMapper: PermissionDto;
+  UpdatePermissionMapper: PermissionDto;
+  RoleEntityMapper: MapNestedDtoArraysToCollections<
+    UpdateRoleDto,
+    'permissions'
+  >;
+};
+
+// role
+export type RoleEntities = {
+  RoleMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
+  CreateRoleMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
+  UpdateRoleMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
+};
+
+// user
+export type UserEntities = {
+  UserMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+  CreateUserMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+  UpdateUserMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
+};