@forklaunch/implementation-iam-base 0.6.2 → 0.6.4

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

@@ -31,7 +31,6 @@ export class BaseUserService<
     tracing?: boolean;
   };
   public em: EntityManager;
-  protected passwordEncryptionPublicKeyPath: string;
   protected roleServiceFactory: () => RoleService;
   protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>;
   protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
@@ -40,7 +39,6 @@ export class BaseUserService<
 
   constructor(
     em: EntityManager,
-    passwordEncryptionPublicKeyPath: string,
     roleServiceFactory: () => RoleService,
     organizationServiceFactory: () => OrganizationService<OrganizationStatus>,
     openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
@@ -51,7 +49,6 @@ export class BaseUserService<
     }
   ) {
     this.em = em;
-    this.passwordEncryptionPublicKeyPath = passwordEncryptionPublicKeyPath;
     this.roleServiceFactory = roleServiceFactory;
     this.organizationServiceFactory = organizationServiceFactory;
     this.openTelemetryCollector = openTelemetryCollector;
@@ -222,40 +219,29 @@ export class BaseUserService<
     await (em ?? this.em).nativeDelete('User', idsDto);
   }
 
-  async verifyHasRole(idDto: IdDto, roleId: string): Promise<void> {
+  async surfaceRoles(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['UserMapper']['roles']> {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Verifying user has role', {
-        idDto,
-        roleId
+      this.openTelemetryCollector.info('Surfacing user roles', {
+        idDto
       });
     }
-    const user = await this.getUser(idDto);
-    if (
-      user.roles.filter((role) => {
-        return roleId == role.id;
-      }).length === 0
-    ) {
-      throw new Error(`User ${idDto.id} does not have role ${roleId}`);
-    }
+    const user = await this.getUser(idDto, em);
+    return user.roles;
   }
 
-  async verifyHasPermission(idDto: IdDto, permissionId: string): Promise<void> {
+  async surfacePermissions(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['UserMapper']['roles'][0]['permissions']> {
     if (this.evaluatedTelemetryOptions.logging) {
-      this.openTelemetryCollector.info('Verifying user has permission', {
-        idDto,
-        permissionId
+      this.openTelemetryCollector.info('Surfacing user permissions', {
+        idDto
       });
     }
-    const user = await this.getUser(idDto);
-    if (
-      user.roles
-        .map((role) => role.permissions.map((permission) => permission.id))
-        .flat()
-        .filter((id) => id == permissionId).length === 0
-    ) {
-      throw new Error(
-        `User ${idDto.id} does not have permission ${permissionId}`
-      );
-    }
+    const user = await this.getUser(idDto, em);
+    return user.roles.map((role) => role.permissions).flat();
   }
 }

package/lib/services/index.d.mts

@@ -1,94 +1,263 @@
 import { IdDto, IdsDto } from '@forklaunch/common';
-import { OpenTelemetryCollector, MetricsDefinition, TelemetryOptions } from '@forklaunch/core/http';
-import { OrganizationService, PermissionService, RoleService, UserService } from '@forklaunch/interfaces-iam/interfaces';
-import { CreateOrganizationDto, UpdateOrganizationDto, CreatePermissionDto, UpdatePermissionDto, CreateRoleDto, RoleDto, UpdateRoleDto, CreateUserDto, UpdateUserDto } from '@forklaunch/interfaces-iam/types';
+import {
+  OpenTelemetryCollector,
+  MetricsDefinition,
+  TelemetryOptions
+} from '@forklaunch/core/http';
+import {
+  OrganizationService,
+  PermissionService,
+  RoleService,
+  UserService
+} from '@forklaunch/interfaces-iam/interfaces';
+import {
+  CreateOrganizationDto,
+  UpdateOrganizationDto,
+  CreatePermissionDto,
+  UpdatePermissionDto,
+  CreateRoleDto,
+  RoleDto,
+  UpdateRoleDto,
+  CreateUserDto,
+  UpdateUserDto
+} from '@forklaunch/interfaces-iam/types';
 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.mjs';
+import {
+  OrganizationEntities,
+  OrganizationDtos,
+  OrganizationMappers,
+  PermissionEntities,
+  PermissionDtos,
+  PermissionMappers,
+  RoleEntities,
+  RoleDtos,
+  RoleMappers,
+  UserEntities,
+  UserDtos,
+  UserMappers
+} from '../domain/types/index.mjs';
 import '@forklaunch/core/services';
 
-declare class BaseOrganizationService<SchemaValidator extends AnySchemaValidator, OrganizationStatus = unknown, MapperEntities extends OrganizationEntities<OrganizationStatus> = OrganizationEntities<OrganizationStatus>, MapperDomains extends OrganizationDtos<OrganizationStatus> = OrganizationDtos<OrganizationStatus>> implements OrganizationService<OrganizationStatus> {
-    private evaluatedTelemetryOptions;
-    em: EntityManager;
-    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-    protected schemaValidator: SchemaValidator;
-    protected mappers: OrganizationMappers<OrganizationStatus, MapperEntities, MapperDomains>;
-    constructor(em: EntityManager, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: OrganizationMappers<OrganizationStatus, MapperEntities, MapperDomains>, options?: {
-        telemetry?: TelemetryOptions;
-    });
-    createOrganization(organizationDto: CreateOrganizationDto, em?: EntityManager, ...args: unknown[]): Promise<MapperDomains['OrganizationMapper']>;
-    getOrganization(idDto: IdDto, em?: EntityManager): Promise<MapperDomains['OrganizationMapper']>;
-    updateOrganization(organizationDto: UpdateOrganizationDto, em?: EntityManager, ...args: unknown[]): Promise<MapperDomains['OrganizationMapper']>;
-    deleteOrganization(idDto: IdDto, em?: EntityManager): Promise<void>;
+declare class BaseOrganizationService<
+  SchemaValidator extends AnySchemaValidator,
+  OrganizationStatus = unknown,
+  MapperEntities extends
+    OrganizationEntities<OrganizationStatus> = OrganizationEntities<OrganizationStatus>,
+  MapperDomains extends
+    OrganizationDtos<OrganizationStatus> = OrganizationDtos<OrganizationStatus>
+> implements OrganizationService<OrganizationStatus>
+{
+  private evaluatedTelemetryOptions;
+  em: EntityManager;
+  protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected schemaValidator: SchemaValidator;
+  protected mappers: OrganizationMappers<
+    OrganizationStatus,
+    MapperEntities,
+    MapperDomains
+  >;
+  constructor(
+    em: EntityManager,
+    openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    schemaValidator: SchemaValidator,
+    mappers: OrganizationMappers<
+      OrganizationStatus,
+      MapperEntities,
+      MapperDomains
+    >,
+    options?: {
+      telemetry?: TelemetryOptions;
+    }
+  );
+  createOrganization(
+    organizationDto: CreateOrganizationDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['OrganizationMapper']>;
+  getOrganization(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['OrganizationMapper']>;
+  updateOrganization(
+    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 = PermissionEntities, MapperDomains extends PermissionDtos = PermissionDtos> implements PermissionService {
-    private evaluatedTelemetryOptions;
-    em: EntityManager;
-    protected roleServiceFactory: () => RoleService;
-    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-    protected schemaValidator: SchemaValidator;
-    protected mappers: PermissionMappers<MapperEntities, MapperDomains>;
-    constructor(em: EntityManager, roleServiceFactory: () => RoleService, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: PermissionMappers<MapperEntities, MapperDomains>, options?: {
-        telemetry?: TelemetryOptions;
-    });
-    private updateRolesWithPermissions;
-    private removePermissionsFromRoles;
-    private getBatchRoles;
-    private createPermissionEntity;
-    private extractCreatePermissionEntityToEntityData;
-    createPermission(createPermissionEntity: CreatePermissionDto, em?: EntityManager, ...args: unknown[]): Promise<MapperDomains['PermissionMapper']>;
-    createBatchPermissions(permissionDtos: CreatePermissionDto[], em?: EntityManager): Promise<MapperDomains['PermissionMapper'][]>;
-    getPermission(idDto: IdDto, em?: EntityManager): Promise<MapperDomains['PermissionMapper']>;
-    getBatchPermissions(idsDto: IdsDto, em?: EntityManager): Promise<MapperDomains['PermissionMapper'][]>;
-    private updatePermissionDto;
-    updatePermission(permissionDto: UpdatePermissionDto, em?: EntityManager): Promise<MapperDomains['PermissionMapper']>;
-    updateBatchPermissions(permissionDtos: UpdatePermissionDto[], em?: EntityManager): Promise<MapperDomains['PermissionMapper'][]>;
-    deletePermission(idDto: IdDto, em?: EntityManager): Promise<void>;
-    deleteBatchPermissions(idsDto: IdsDto, em?: EntityManager): Promise<void>;
+declare class BasePermissionService<
+  SchemaValidator extends AnySchemaValidator,
+  MapperEntities extends PermissionEntities = PermissionEntities,
+  MapperDomains extends PermissionDtos = PermissionDtos
+> implements PermissionService
+{
+  private evaluatedTelemetryOptions;
+  em: EntityManager;
+  protected roleServiceFactory: () => RoleService;
+  protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected schemaValidator: SchemaValidator;
+  protected mappers: PermissionMappers<MapperEntities, MapperDomains>;
+  constructor(
+    em: EntityManager,
+    roleServiceFactory: () => RoleService,
+    openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    schemaValidator: SchemaValidator,
+    mappers: PermissionMappers<MapperEntities, MapperDomains>,
+    options?: {
+      telemetry?: TelemetryOptions;
+    }
+  );
+  private updateRolesWithPermissions;
+  private removePermissionsFromRoles;
+  private getBatchRoles;
+  private createPermissionEntity;
+  private extractCreatePermissionEntityToEntityData;
+  createPermission(
+    createPermissionEntity: CreatePermissionDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['PermissionMapper']>;
+  createBatchPermissions(
+    permissionDtos: CreatePermissionDto[],
+    em?: EntityManager
+  ): Promise<MapperDomains['PermissionMapper'][]>;
+  getPermission(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['PermissionMapper']>;
+  getBatchPermissions(
+    idsDto: IdsDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['PermissionMapper'][]>;
+  private updatePermissionDto;
+  updatePermission(
+    permissionDto: UpdatePermissionDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['PermissionMapper']>;
+  updateBatchPermissions(
+    permissionDtos: UpdatePermissionDto[],
+    em?: EntityManager
+  ): 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 = RoleEntities, MapperDomains extends RoleDtos = RoleDtos> implements RoleService {
-    private evaluatedTelemetryOptions;
-    em: EntityManager;
-    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-    protected schemaValidator: SchemaValidator;
-    protected mappers: RoleMappers<MapperEntities, MapperDomains>;
-    constructor(em: EntityManager, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: RoleMappers<MapperEntities, MapperDomains>, options?: {
-        telemetry?: TelemetryOptions;
-    });
-    createRole(roleDto: CreateRoleDto, em?: EntityManager, ...args: unknown[]): Promise<RoleDto>;
-    createBatchRoles(roleDtos: CreateRoleDto[], em?: EntityManager, ...args: unknown[]): Promise<RoleDto[]>;
-    getRole({ id }: IdDto, em?: EntityManager): Promise<RoleDto>;
-    getBatchRoles({ ids }: IdsDto, em?: EntityManager): Promise<RoleDto[]>;
-    updateRole(roleDto: UpdateRoleDto, em?: EntityManager, ...args: unknown[]): Promise<RoleDto>;
-    updateBatchRoles(roleDtos: UpdateRoleDto[], em?: EntityManager, ...args: unknown[]): Promise<RoleDto[]>;
-    deleteRole(idDto: IdDto, em?: EntityManager): Promise<void>;
-    deleteBatchRoles(idsDto: IdsDto, em?: EntityManager): Promise<void>;
+declare class BaseRoleService<
+  SchemaValidator extends AnySchemaValidator,
+  MapperEntities extends RoleEntities = RoleEntities,
+  MapperDomains extends RoleDtos = RoleDtos
+> implements RoleService
+{
+  private evaluatedTelemetryOptions;
+  em: EntityManager;
+  protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected schemaValidator: SchemaValidator;
+  protected mappers: RoleMappers<MapperEntities, MapperDomains>;
+  constructor(
+    em: EntityManager,
+    openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    schemaValidator: SchemaValidator,
+    mappers: RoleMappers<MapperEntities, MapperDomains>,
+    options?: {
+      telemetry?: TelemetryOptions;
+    }
+  );
+  createRole(
+    roleDto: CreateRoleDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto>;
+  createBatchRoles(
+    roleDtos: CreateRoleDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto[]>;
+  getRole({ id }: IdDto, em?: EntityManager): Promise<RoleDto>;
+  getBatchRoles({ ids }: IdsDto, em?: EntityManager): Promise<RoleDto[]>;
+  updateRole(
+    roleDto: UpdateRoleDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<RoleDto>;
+  updateBatchRoles(
+    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 = unknown, MapperEntities extends UserEntities = UserEntities, MapperDomains extends UserDtos = UserDtos> implements UserService {
-    private evaluatedTelemetryOptions;
-    em: EntityManager;
-    protected passwordEncryptionPublicKeyPath: string;
-    protected roleServiceFactory: () => RoleService;
-    protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>;
-    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
-    protected schemaValidator: SchemaValidator;
-    protected mappers: UserMappers<MapperEntities, MapperDomains>;
-    constructor(em: EntityManager, passwordEncryptionPublicKeyPath: string, roleServiceFactory: () => RoleService, organizationServiceFactory: () => OrganizationService<OrganizationStatus>, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: UserMappers<MapperEntities, MapperDomains>, options?: {
-        telemetry?: TelemetryOptions;
-    });
-    createUser(userDto: CreateUserDto, em?: EntityManager, ...args: unknown[]): Promise<MapperDomains['UserMapper']>;
-    createBatchUsers(userDtos: CreateUserDto[], em?: EntityManager, ...args: unknown[]): Promise<MapperDomains['UserMapper'][]>;
-    getUser(idDto: IdDto, em?: EntityManager): Promise<MapperDomains['UserMapper']>;
-    getBatchUsers(idsDto: IdsDto, em?: EntityManager): Promise<MapperDomains['UserMapper'][]>;
-    updateUser(userDto: UpdateUserDto, em?: EntityManager, ...args: unknown[]): Promise<MapperDomains['UserMapper']>;
-    updateBatchUsers(userDtos: UpdateUserDto[], 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>;
-    verifyHasPermission(idDto: IdDto, permissionId: string): Promise<void>;
+declare class BaseUserService<
+  SchemaValidator extends AnySchemaValidator,
+  OrganizationStatus = unknown,
+  MapperEntities extends UserEntities = UserEntities,
+  MapperDomains extends UserDtos = UserDtos
+> implements UserService
+{
+  private evaluatedTelemetryOptions;
+  em: EntityManager;
+  protected roleServiceFactory: () => RoleService;
+  protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>;
+  protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+  protected schemaValidator: SchemaValidator;
+  protected mappers: UserMappers<MapperEntities, MapperDomains>;
+  constructor(
+    em: EntityManager,
+    roleServiceFactory: () => RoleService,
+    organizationServiceFactory: () => OrganizationService<OrganizationStatus>,
+    openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>,
+    schemaValidator: SchemaValidator,
+    mappers: UserMappers<MapperEntities, MapperDomains>,
+    options?: {
+      telemetry?: TelemetryOptions;
+    }
+  );
+  createUser(
+    userDto: CreateUserDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper']>;
+  createBatchUsers(
+    userDtos: CreateUserDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper'][]>;
+  getUser(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['UserMapper']>;
+  getBatchUsers(
+    idsDto: IdsDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['UserMapper'][]>;
+  updateUser(
+    userDto: UpdateUserDto,
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper']>;
+  updateBatchUsers(
+    userDtos: UpdateUserDto[],
+    em?: EntityManager,
+    ...args: unknown[]
+  ): Promise<MapperDomains['UserMapper'][]>;
+  deleteUser(idDto: IdDto, em?: EntityManager): Promise<void>;
+  deleteBatchUsers(idsDto: IdsDto, em?: EntityManager): Promise<void>;
+  surfaceRoles(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['UserMapper']['roles']>;
+  surfacePermissions(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<MapperDomains['UserMapper']['roles'][0]['permissions']>;
 }
 
-export { BaseOrganizationService, BasePermissionService, BaseRoleService, BaseUserService };
+export {
+  BaseOrganizationService,
+  BasePermissionService,
+  BaseRoleService,
+  BaseUserService
+};