@forklaunch/implementation-iam-base 0.5.8 → 0.6.0

package/lib/services/index.d.ts

@@ -1,4 +1,4 @@
-import { InstanceTypeRecord, IdDto, IdsDto } from '@forklaunch/common';
+import { IdDto, IdsDto } from '@forklaunch/common';
 import {
   OpenTelemetryCollector,
   MetricsDefinition,
@@ -11,255 +11,100 @@ import {
   UserService
 } from '@forklaunch/interfaces-iam/interfaces';
 import {
-  InternalMapper,
-  ResponseMapperConstructor,
-  RequestMapperConstructor
-} from '@forklaunch/internal';
-import { AnySchemaValidator } from '@forklaunch/validator';
-import { EntityManager } from '@mikro-orm/core';
-import {
-  OrganizationDto,
   CreateOrganizationDto,
   UpdateOrganizationDto,
-  PermissionDto,
   CreatePermissionDto,
   UpdatePermissionDto,
-  UpdateRoleDto,
-  RoleDto,
   CreateRoleDto,
-  UserDto,
+  RoleDto,
+  UpdateRoleDto,
   CreateUserDto,
   UpdateUserDto
 } from '@forklaunch/interfaces-iam/types';
-import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
-
-type OrganizationDtos<OrganizationStatus> = {
-  OrganizationMapper: OrganizationDto<OrganizationStatus>;
-  CreateOrganizationMapper: CreateOrganizationDto;
-  UpdateOrganizationMapper: UpdateOrganizationDto;
-};
-type PermissionDtos = {
-  PermissionMapper: PermissionDto;
-  CreatePermissionMapper: CreatePermissionDto;
-  UpdatePermissionMapper: UpdatePermissionDto;
-  RoleEntityMapper: UpdateRoleDto;
-};
-type RoleDtos = {
-  RoleMapper: RoleDto;
-  CreateRoleMapper: CreateRoleDto;
-  UpdateRoleMapper: UpdateRoleDto;
-};
-type UserDtos = {
-  UserMapper: UserDto;
-  CreateUserMapper: CreateUserDto;
-  UpdateUserMapper: UpdateUserDto;
-};
-
-type OrganizationEntities<OrganizationStatus> = {
-  OrganizationMapper: MapNestedDtoArraysToCollections<
-    OrganizationDto<OrganizationStatus>,
-    'users'
-  >;
-  CreateOrganizationMapper: MapNestedDtoArraysToCollections<
-    OrganizationDto<OrganizationStatus>,
-    'users'
-  >;
-  UpdateOrganizationMapper: MapNestedDtoArraysToCollections<
-    OrganizationDto<OrganizationStatus>,
-    'users'
-  >;
-};
-type PermissionEntities = {
-  PermissionMapper: PermissionDto;
-  CreatePermissionMapper: PermissionDto;
-  UpdatePermissionMapper: PermissionDto;
-  RoleEntityMapper: MapNestedDtoArraysToCollections<
-    UpdateRoleDto,
-    'permissions'
-  >;
-};
-type RoleEntities = {
-  RoleMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-  CreateRoleMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-  UpdateRoleMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-};
-type UserEntities = {
-  UserMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-  CreateUserMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-  UpdateUserMapper: MapNestedDtoArraysToCollections<UserDto, 'roles'>;
-};
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+import {
+  OrganizationEntities,
+  OrganizationDtos,
+  OrganizationMappers,
+  PermissionEntities,
+  PermissionDtos,
+  PermissionMappers,
+  RoleEntities,
+  RoleDtos,
+  RoleMappers,
+  UserEntities,
+  UserDtos,
+  UserMappers
+} from '../domain/types/index.js';
+import '@forklaunch/core/services';
 
 declare class BaseOrganizationService<
   SchemaValidator extends AnySchemaValidator,
-  OrganizationStatus,
-  MapperEntities extends OrganizationEntities<OrganizationStatus>,
-  MapperDtos extends
+  OrganizationStatus = unknown,
+  MapperEntities extends
+    OrganizationEntities<OrganizationStatus> = OrganizationEntities<OrganizationStatus>,
+  MapperDomains extends
     OrganizationDtos<OrganizationStatus> = OrganizationDtos<OrganizationStatus>
 > implements OrganizationService<OrganizationStatus>
 {
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   private evaluatedTelemetryOptions;
   em: EntityManager;
   protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
   protected schemaValidator: SchemaValidator;
-  protected mappers: {
-    OrganizationMapper: ResponseMapperConstructor<
-      SchemaValidator,
-      MapperDtos['OrganizationMapper'],
-      MapperEntities['OrganizationMapper']
-    >;
-    CreateOrganizationMapper: RequestMapperConstructor<
-      SchemaValidator,
-      MapperDtos['CreateOrganizationMapper'],
-      MapperEntities['CreateOrganizationMapper'],
-      (
-        dto: MapperDtos['CreateOrganizationMapper'],
-        em: EntityManager
-      ) => Promise<MapperEntities['CreateOrganizationMapper']>
-    >;
-    UpdateOrganizationMapper: RequestMapperConstructor<
-      SchemaValidator,
-      MapperDtos['UpdateOrganizationMapper'],
-      MapperEntities['UpdateOrganizationMapper'],
-      (
-        dto: MapperDtos['UpdateOrganizationMapper'],
-        em: EntityManager
-      ) => Promise<MapperEntities['UpdateOrganizationMapper']>
-    >;
-  };
+  protected mappers: OrganizationMappers<
+    OrganizationStatus,
+    MapperEntities,
+    MapperDomains
+  >;
   constructor(
     em: EntityManager,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    mappers: {
-      OrganizationMapper: ResponseMapperConstructor<
-        SchemaValidator,
-        MapperDtos['OrganizationMapper'],
-        MapperEntities['OrganizationMapper']
-      >;
-      CreateOrganizationMapper: RequestMapperConstructor<
-        SchemaValidator,
-        MapperDtos['CreateOrganizationMapper'],
-        MapperEntities['CreateOrganizationMapper'],
-        (
-          dto: MapperDtos['CreateOrganizationMapper'],
-          em: EntityManager
-        ) => Promise<MapperEntities['CreateOrganizationMapper']>
-      >;
-      UpdateOrganizationMapper: RequestMapperConstructor<
-        SchemaValidator,
-        MapperDtos['UpdateOrganizationMapper'],
-        MapperEntities['UpdateOrganizationMapper'],
-        (
-          dto: MapperDtos['UpdateOrganizationMapper'],
-          em: EntityManager
-        ) => Promise<MapperEntities['UpdateOrganizationMapper']>
-      >;
-    },
+    mappers: OrganizationMappers<
+      OrganizationStatus,
+      MapperEntities,
+      MapperDomains
+    >,
     options?: {
       telemetry?: TelemetryOptions;
     }
   );
   createOrganization(
-    organizationDto: MapperDtos['CreateOrganizationMapper'],
-    em?: EntityManager
-  ): Promise<MapperDtos['OrganizationMapper']>;
+    organizationDto: CreateOrganizationDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['OrganizationMapper']>;
   getOrganization(
     idDto: IdDto,
     em?: EntityManager
-  ): Promise<MapperDtos['OrganizationMapper']>;
+  ): Promise<MapperDomains['OrganizationMapper']>;
   updateOrganization(
-    organizationDto: MapperDtos['UpdateOrganizationMapper'],
-    em?: EntityManager
-  ): Promise<MapperDtos['OrganizationMapper']>;
+    organizationDto: UpdateOrganizationDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['OrganizationMapper']>;
   deleteOrganization(idDto: IdDto, em?: EntityManager): Promise<void>;
 }
 
 declare class BasePermissionService<
   SchemaValidator extends AnySchemaValidator,
-  MapperEntities extends PermissionEntities,
-  MapperDto extends PermissionDtos = PermissionDtos
+  MapperEntities extends PermissionEntities = PermissionEntities,
+  MapperDomains extends PermissionDtos = PermissionDtos
 > implements PermissionService
 {
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   private evaluatedTelemetryOptions;
   em: EntityManager;
   protected roleServiceFactory: () => RoleService;
   protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
   protected schemaValidator: SchemaValidator;
-  protected mappers: {
-    PermissionMapper: ResponseMapperConstructor<
-      SchemaValidator,
-      MapperDto['PermissionMapper'],
-      MapperEntities['PermissionMapper']
-    >;
-    CreatePermissionMapper: RequestMapperConstructor<
-      SchemaValidator,
-      MapperDto['CreatePermissionMapper'],
-      MapperEntities['CreatePermissionMapper'],
-      (
-        dto: MapperDto['CreatePermissionMapper'],
-        em: EntityManager
-      ) => Promise<MapperEntities['CreatePermissionMapper']>
-    >;
-    UpdatePermissionMapper: RequestMapperConstructor<
-      SchemaValidator,
-      MapperDto['UpdatePermissionMapper'],
-      MapperEntities['UpdatePermissionMapper'],
-      (
-        dto: MapperDto['UpdatePermissionMapper'],
-        em: EntityManager
-      ) => Promise<MapperEntities['UpdatePermissionMapper']>
-    >;
-    RoleEntityMapper: RequestMapperConstructor<
-      SchemaValidator,
-      MapperDto['RoleEntityMapper'],
-      MapperEntities['RoleEntityMapper'],
-      (
-        dto: MapperDto['RoleEntityMapper'],
-        em: EntityManager
-      ) => Promise<MapperEntities['RoleEntityMapper']>
-    >;
-  };
+  protected mappers: PermissionMappers<MapperEntities, MapperDomains>;
   constructor(
     em: EntityManager,
     roleServiceFactory: () => RoleService,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
     schemaValidator: SchemaValidator,
-    mappers: {
-      PermissionMapper: ResponseMapperConstructor<
-        SchemaValidator,
-        MapperDto['PermissionMapper'],
-        MapperEntities['PermissionMapper']
-      >;
-      CreatePermissionMapper: RequestMapperConstructor<
-        SchemaValidator,
-        MapperDto['CreatePermissionMapper'],
-        MapperEntities['CreatePermissionMapper'],
-        (
-          dto: MapperDto['CreatePermissionMapper'],
-          em: EntityManager
-        ) => Promise<MapperEntities['CreatePermissionMapper']>
-      >;
-      UpdatePermissionMapper: RequestMapperConstructor<
-        SchemaValidator,
-        MapperDto['UpdatePermissionMapper'],
-        MapperEntities['UpdatePermissionMapper'],
-        (
-          dto: MapperDto['UpdatePermissionMapper'],
-          em: EntityManager
-        ) => Promise<MapperEntities['UpdatePermissionMapper']>
-      >;
-      RoleEntityMapper: RequestMapperConstructor<
-        SchemaValidator,
-        MapperDto['RoleEntityMapper'],
-        MapperEntities['RoleEntityMapper'],
-        (
-          dto: MapperDto['RoleEntityMapper'],
-          em: EntityManager
-        ) => Promise<MapperEntities['RoleEntityMapper']>
-      >;
-    },
+    mappers: PermissionMappers<MapperEntities, MapperDomains>,
     options?: {
       telemetry?: TelemetryOptions;
     }
@@ -267,141 +112,91 @@ declare class BasePermissionService<
   private updateRolesWithPermissions;
   private removePermissionsFromRoles;
   private getBatchRoles;
-  private createPermissionDto;
-  private extractCreatePermissionDtoToEntityData;
+  private createPermissionEntity;
+  private extractCreatePermissionEntityToEntityData;
   createPermission(
-    createPermissionDto: MapperDto['CreatePermissionMapper'],
-    em?: EntityManager
-  ): Promise<MapperDto['PermissionMapper']>;
+    createPermissionEntity: CreatePermissionDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['PermissionMapper']>;
   createBatchPermissions(
-    permissionDtos: MapperDto['CreatePermissionMapper'][],
+    permissionDtos: CreatePermissionDto[],
     em?: EntityManager
-  ): Promise<MapperDto['PermissionMapper'][]>;
+  ): Promise<MapperDomains['PermissionMapper'][]>;
   getPermission(
     idDto: IdDto,
     em?: EntityManager
-  ): Promise<MapperDto['PermissionMapper']>;
+  ): Promise<MapperDomains['PermissionMapper']>;
   getBatchPermissions(
     idsDto: IdsDto,
     em?: EntityManager
-  ): Promise<MapperDto['PermissionMapper'][]>;
+  ): Promise<MapperDomains['PermissionMapper'][]>;
   private updatePermissionDto;
   updatePermission(
-    permissionDto: MapperDto['UpdatePermissionMapper'],
+    permissionDto: UpdatePermissionDto,
     em?: EntityManager
-  ): Promise<MapperDto['PermissionMapper']>;
+  ): Promise<MapperDomains['PermissionMapper']>;
   updateBatchPermissions(
-    permissionDtos: MapperDto['UpdatePermissionMapper'][],
+    permissionDtos: UpdatePermissionDto[],
     em?: EntityManager
-  ): Promise<MapperDto['PermissionMapper'][]>;
+  ): Promise<MapperDomains['PermissionMapper'][]>;
   deletePermission(idDto: IdDto, em?: EntityManager): Promise<void>;
   deleteBatchPermissions(idsDto: IdsDto, em?: EntityManager): Promise<void>;
 }
 
 declare 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;
   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;
     }
   );
   createRole(
-    roleDto: MapperDto['CreateRoleMapper'],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper']>;
+    roleDto: CreateRoleDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto>;
   createBatchRoles(
-    roleDtos: MapperDto['CreateRoleMapper'][],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper'][]>;
+    roleDtos: CreateRoleDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto[]>;
   getRole({ id }: IdDto, em?: EntityManager): Promise<RoleDto>;
   getBatchRoles({ ids }: IdsDto, em?: EntityManager): Promise<RoleDto[]>;
   updateRole(
-    roleDto: MapperDto['UpdateRoleMapper'],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper']>;
+    roleDto: UpdateRoleDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto>;
   updateBatchRoles(
-    roleDtos: MapperDto['UpdateRoleMapper'][],
-    em?: EntityManager
-  ): Promise<MapperDto['RoleMapper'][]>;
+    roleDtos: UpdateRoleDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto[]>;
   deleteRole(idDto: IdDto, em?: EntityManager): Promise<void>;
   deleteBatchRoles(idsDto: IdsDto, em?: EntityManager): Promise<void>;
 }
 
 declare 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
 {
-  readonly options?:
-    | {
-        telemetry?: TelemetryOptions;
-      }
-    | undefined;
-  protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
   private evaluatedTelemetryOptions;
   em: EntityManager;
   protected passwordEncryptionPublicKeyPath: string;
@@ -409,31 +204,7 @@ declare 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,
     passwordEncryptionPublicKeyPath: string,
@@ -441,58 +212,39 @@ declare 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']>
-      >;
-    },
-    options?:
-      | {
-          telemetry?: TelemetryOptions;
-        }
-      | undefined
+    mappers: UserMappers<MapperEntities, MapperDomains>,
+    options?: {
+      telemetry?: TelemetryOptions;
+    }
   );
   createUser(
-    userDto: Dto['CreateUserMapper'],
-    em?: EntityManager
-  ): Promise<Dto['UserMapper']>;
+    userDto: CreateUserDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper']>;
   createBatchUsers(
-    userDtos: Dto['CreateUserMapper'][],
+    userDtos: CreateUserDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper'][]>;
+  getUser(
+    idDto: IdDto,
     em?: EntityManager
-  ): Promise<Dto['UserMapper'][]>;
-  getUser(idDto: IdDto, em?: EntityManager): Promise<Dto['UserMapper']>;
+  ): Promise<MapperDomains['UserMapper']>;
   getBatchUsers(
     idsDto: IdsDto,
     em?: EntityManager
-  ): Promise<Dto['UserMapper'][]>;
+  ): Promise<MapperDomains['UserMapper'][]>;
   updateUser(
-    userDto: Dto['UpdateUserMapper'],
-    em?: EntityManager
-  ): Promise<Dto['UserMapper']>;
+    userDto: UpdateUserDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper']>;
   updateBatchUsers(
     userDtos: UpdateUserDto[],
-    em?: EntityManager
-  ): Promise<Dto['UserMapper'][]>;
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper'][]>;
   deleteUser(idDto: IdDto, em?: EntityManager): Promise<void>;
   deleteBatchUsers(idsDto: IdsDto, em?: EntityManager): Promise<void>;
   verifyHasRole(idDto: IdDto, roleId: string): Promise<void>;