@forklaunch/implementation-iam-base 0.1.11 → 0.1.12

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

@@ -1,345 +0,0 @@
-import {
-  PermissionService,
-  RoleService
-} from '@forklaunch/interfaces-iam/interfaces';
-
-import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
-import {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
-import {
-  MetricsDefinition,
-  OpenTelemetryCollector
-} from '@forklaunch/core/http';
-import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
-import {
-  CreatePermissionDto,
-  PermissionDto,
-  RoleDto,
-  UpdatePermissionDto
-} from '@forklaunch/interfaces-iam/types';
-import { AnySchemaValidator } from '@forklaunch/validator';
-import { EntityManager } from '@mikro-orm/core';
-
-export class BasePermissionService<
-  SchemaValidator extends AnySchemaValidator,
-  Metrics extends MetricsDefinition = MetricsDefinition,
-  Dto extends {
-    PermissionDtoMapper: PermissionDto;
-    CreatePermissionDtoMapper: CreatePermissionDto;
-    UpdatePermissionDtoMapper: UpdatePermissionDto;
-    RoleDtoMapper: RoleDto;
-  } = {
-    PermissionDtoMapper: PermissionDto;
-    CreatePermissionDtoMapper: CreatePermissionDto;
-    UpdatePermissionDtoMapper: UpdatePermissionDto;
-    RoleDtoMapper: RoleDto;
-  },
-  Entities extends {
-    PermissionDtoMapper: PermissionDto;
-    CreatePermissionDtoMapper: PermissionDto;
-    UpdatePermissionDtoMapper: PermissionDto;
-    RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-  } = {
-    PermissionDtoMapper: PermissionDto;
-    CreatePermissionDtoMapper: PermissionDto;
-    UpdatePermissionDtoMapper: PermissionDto;
-    RoleDtoMapper: MapNestedDtoArraysToCollections<RoleDto, 'permissions'>;
-  }
-> implements PermissionService
-{
-  #mapperss: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mapperss>,
-    Entities,
-    Dto
-  >;
-
-  constructor(
-    public em: EntityManager,
-    protected roleServiceFactory: () => RoleService,
-    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
-    protected schemaValidator: SchemaValidator,
-    protected mapperss: {
-      PermissionDtoMapper: ResponseDtoMapperConstructor<
-        SchemaValidator,
-        Dto['PermissionDtoMapper'],
-        Entities['PermissionDtoMapper']
-      >;
-      CreatePermissionDtoMapper: RequestDtoMapperConstructor<
-        SchemaValidator,
-        Dto['CreatePermissionDtoMapper'],
-        Entities['CreatePermissionDtoMapper']
-      >;
-      UpdatePermissionDtoMapper: RequestDtoMapperConstructor<
-        SchemaValidator,
-        Dto['UpdatePermissionDtoMapper'],
-        Entities['UpdatePermissionDtoMapper']
-      >;
-      RoleDtoMapper: RequestDtoMapperConstructor<
-        SchemaValidator,
-        Dto['RoleDtoMapper'],
-        Entities['RoleDtoMapper']
-      >;
-    }
-  ) {
-    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
-  }
-
-  // start: global helper functions
-  private async updateRolesWithPermissions(
-    roles: Entities['RoleDtoMapper'][],
-    permissions: Entities['PermissionDtoMapper'][]
-  ): Promise<Entities['RoleDtoMapper'][]> {
-    return await Promise.all(
-      roles.map(async (role) => {
-        permissions.forEach((permission) => role.permissions.add(permission));
-        return role;
-      })
-    );
-  }
-
-  private async removePermissionsFromRoles(
-    roles: Entities['RoleDtoMapper'][],
-    permissions: Entities['PermissionDtoMapper'][]
-  ): Promise<Entities['RoleDtoMapper'][]> {
-    return await Promise.all(
-      roles.map(async (role) => {
-        permissions.forEach((permission) =>
-          role.permissions.remove(permission)
-        );
-        return role;
-      })
-    );
-  }
-
-  private async getBatchRoles(
-    roleIds?: IdsDto,
-    em?: EntityManager
-  ): Promise<Entities['RoleDtoMapper'][]> {
-    return roleIds
-      ? (await this.roleServiceFactory().getBatchRoles(roleIds, em)).map(
-          (role) => {
-            return (em ?? this.em).merge(
-              this.#mapperss.RoleDtoMapper.deserializeDtoToEntity(role)
-            );
-          }
-        )
-      : [];
-  }
-  // end: global helper functions
-
-  // start: createPermission helper functions
-  private async createPermissionDto({
-    permission,
-    addToRoles
-  }: {
-    permission: Entities['PermissionDtoMapper'];
-    addToRoles: Entities['RoleDtoMapper'][];
-  }): Promise<{
-    permission: Entities['PermissionDtoMapper'];
-    roles: Entities['RoleDtoMapper'][];
-  }> {
-    let roles: Entities['RoleDtoMapper'][] = [];
-    if (addToRoles) {
-      roles = await this.updateRolesWithPermissions(addToRoles, [permission]);
-    }
-
-    return { permission, roles };
-  }
-
-  private async extractCreatePermissionDtoToEntityData(
-    permissionDto: Dto['CreatePermissionDtoMapper'],
-    em?: EntityManager
-  ): Promise<{
-    permission: Entities['PermissionDtoMapper'];
-    addToRoles: Entities['RoleDtoMapper'][];
-  }> {
-    return {
-      permission: (em ?? this.em).merge(
-        this.#mapperss.CreatePermissionDtoMapper.deserializeDtoToEntity(
-          permissionDto
-        )
-      ),
-      addToRoles: permissionDto.addToRolesIds
-        ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
-        : []
-    };
-  }
-  // end: createPermission helper functions
-
-  async createPermission(
-    createPermissionDto: Dto['CreatePermissionDtoMapper'],
-    em?: EntityManager
-  ): Promise<Dto['PermissionDtoMapper']> {
-    const { permission, roles } = await this.createPermissionDto(
-      await this.extractCreatePermissionDtoToEntityData(createPermissionDto, em)
-    );
-    await (em ?? this.em).transactional(async (innerEm) => {
-      await innerEm.persist([permission, ...roles]);
-    });
-    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
-  }
-
-  async createBatchPermissions(
-    permissionDtos: Dto['CreatePermissionDtoMapper'][],
-    em?: EntityManager
-  ): Promise<Dto['PermissionDtoMapper'][]> {
-    const rolesCache: Record<string, Entities['RoleDtoMapper']> = {};
-    const permissions: Entities['PermissionDtoMapper'][] = [];
-    await (em ?? this.em).transactional(async (em) => {
-      permissionDtos.map(async (createPermissionDto) => {
-        const { permission, roles } = await this.createPermissionDto(
-          await this.extractCreatePermissionDtoToEntityData(
-            createPermissionDto,
-            em
-          )
-        );
-        roles.forEach((role) => {
-          if (
-            rolesCache[role.id] &&
-            role.permissions !== rolesCache[role.id].permissions
-          ) {
-            role.permissions.getItems().forEach((permission) => {
-              if (!rolesCache[role.id].permissions.contains(permission)) {
-                rolesCache[role.id].permissions.add(permission);
-              }
-            });
-          } else {
-            rolesCache[role.id] = role;
-          }
-        });
-        permissions.push(permission);
-      });
-      await (em ?? this.em).persist([
-        ...permissions,
-        ...Object.values(rolesCache)
-      ]);
-    });
-
-    return permissions.map((permission) =>
-      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
-    );
-  }
-
-  async getPermission(
-    idDto: IdDto,
-    em?: EntityManager
-  ): Promise<Dto['PermissionDtoMapper']> {
-    const permission = await (em ?? this.em).findOneOrFail('Permission', idDto);
-    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(
-      permission as Entities['PermissionDtoMapper']
-    );
-  }
-
-  async getBatchPermissions(
-    idsDto: IdsDto,
-    em?: EntityManager
-  ): Promise<Dto['PermissionDtoMapper'][]> {
-    return (await (em ?? this.em).find('Permission', idsDto)).map(
-      (permission) =>
-        this.#mapperss.PermissionDtoMapper.serializeEntityToDto(
-          permission as Entities['PermissionDtoMapper']
-        )
-    );
-  }
-
-  // start: updatePermission helper functions
-  private updatePermissionDto = async (
-    permissionDto: Dto['UpdatePermissionDtoMapper'],
-    em?: EntityManager
-  ): Promise<{
-    permission: Entities['PermissionDtoMapper'];
-    roles: Entities['RoleDtoMapper'][];
-  }> => {
-    const permission =
-      this.#mapperss.UpdatePermissionDtoMapper.deserializeDtoToEntity(
-        permissionDto
-      );
-    const addToRoles = permissionDto.addToRolesIds
-      ? await this.getBatchRoles({ ids: permissionDto.addToRolesIds }, em)
-      : [];
-    const removeFromRoles = permissionDto.removeFromRolesIds
-      ? await this.getBatchRoles({ ids: permissionDto.removeFromRolesIds }, em)
-      : [];
-
-    let roles: Entities['RoleDtoMapper'][] = [];
-
-    roles = roles.concat(
-      await this.updateRolesWithPermissions(addToRoles, [permission])
-    );
-    roles = roles.concat(
-      await this.removePermissionsFromRoles(removeFromRoles, [permission])
-    );
-
-    return {
-      permission,
-      roles
-    };
-  };
-  // end: updatePermission helper functions
-
-  async updatePermission(
-    permissionDto: Dto['UpdatePermissionDtoMapper'],
-    em?: EntityManager
-  ): Promise<Dto['PermissionDtoMapper']> {
-    const { permission, roles } = await this.updatePermissionDto(permissionDto);
-    await (em ?? this.em).upsertMany([permission, ...roles]);
-    if (!em) {
-      this.em.flush();
-    }
-    return this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission);
-  }
-
-  async updateBatchPermissions(
-    permissionDtos: Dto['UpdatePermissionDtoMapper'][],
-    em?: EntityManager
-  ): Promise<Dto['PermissionDtoMapper'][]> {
-    const rolesCache: Record<string, Entities['RoleDtoMapper']> = {};
-    const permissions: Entities['PermissionDtoMapper'][] = [];
-    await (em ?? this.em).transactional(async (em) => {
-      permissionDtos.map(async (updatePermissionDto) => {
-        const { permission, roles } =
-          await this.updatePermissionDto(updatePermissionDto);
-        roles.forEach((role) => {
-          if (
-            rolesCache[role.id] &&
-            role.permissions !== rolesCache[role.id].permissions
-          ) {
-            role.permissions.getItems().forEach((permission) => {
-              if (!rolesCache[role.id].permissions.contains(permission)) {
-                rolesCache[role.id].permissions.add(permission);
-              }
-            });
-          } else {
-            rolesCache[role.id] = role;
-          }
-        });
-        permissions.push(permission);
-      });
-      await (em ?? this.em).persist([
-        ...permissions,
-        ...Object.values(rolesCache)
-      ]);
-    });
-
-    return permissions.map((permission) =>
-      this.#mapperss.PermissionDtoMapper.serializeEntityToDto(permission)
-    );
-  }
-
-  async deletePermission(idDto: IdDto, em?: EntityManager): Promise<void> {
-    await (em ?? this.em).nativeDelete('Permission', idDto);
-  }
-
-  async deleteBatchPermissions(
-    idsDto: IdsDto,
-    em?: EntityManager
-  ): Promise<void> {
-    await (em ?? this.em).nativeDelete('Permission', {
-      id: { $in: idsDto.ids }
-    });
-  }
-}

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

@@ -1,179 +0,0 @@
-import {
-  MetricsDefinition,
-  OpenTelemetryCollector
-} from '@forklaunch/core/http';
-import { RoleService } from '@forklaunch/interfaces-iam/interfaces';
-import { EntityManager } from '@mikro-orm/core';
-
-import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
-import {
-  InternalDtoMapper,
-  RequestDtoMapperConstructor,
-  ResponseDtoMapperConstructor,
-  transformIntoInternalDtoMapper
-} from '@forklaunch/core/mappers';
-import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
-import {
-  CreateRoleDto,
-  RoleDto,
-  UpdateRoleDto
-} from '@forklaunch/interfaces-iam/types';
-import { AnySchemaValidator } from '@forklaunch/validator';
-
-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'
-    >;
-  }
-> implements RoleService
-{
-  #mapperss: InternalDtoMapper<
-    InstanceTypeRecord<typeof this.mapperss>,
-    Entities,
-    Dto
-  >;
-
-  constructor(
-    public em: EntityManager,
-    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
-    protected schemaValidator: SchemaValidator,
-    protected mapperss: {
-      RoleDtoMapper: ResponseDtoMapperConstructor<
-        SchemaValidator,
-        Dto['RoleDtoMapper'],
-        Entities['RoleDtoMapper']
-      >;
-      CreateRoleDtoMapper: RequestDtoMapperConstructor<
-        SchemaValidator,
-        Dto['CreateRoleDtoMapper'],
-        Entities['CreateRoleDtoMapper']
-      >;
-      UpdateRoleDtoMapper: RequestDtoMapperConstructor<
-        SchemaValidator,
-        Dto['UpdateRoleDtoMapper'],
-        Entities['UpdateRoleDtoMapper']
-      >;
-    }
-  ) {
-    this.#mapperss = transformIntoInternalDtoMapper(mapperss, schemaValidator);
-  }
-
-  async createRole(
-    roleDto: Dto['CreateRoleDtoMapper'],
-    em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper']> {
-    // TODO: Think about removing static method here, since we need specific args
-    const role =
-      this.#mapperss.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto);
-    await (em ?? this.em).transactional((em) => em.persist(role));
-    return this.#mapperss.RoleDtoMapper.serializeEntityToDto(
-      role as Entities['RoleDtoMapper']
-    );
-  }
-
-  async createBatchRoles(
-    roleDtos: Dto['CreateRoleDtoMapper'][],
-    em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper'][]> {
-    const roles = await Promise.all(
-      roleDtos.map(async (roleDto) =>
-        this.#mapperss.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto)
-      )
-    );
-    await (em ?? this.em).transactional((em) => em.persist(roles));
-    return roles.map((role) =>
-      this.#mapperss.RoleDtoMapper.serializeEntityToDto(
-        role as Entities['RoleDtoMapper']
-      )
-    );
-  }
-
-  async getRole(idDto: IdDto, em?: EntityManager): Promise<RoleDto> {
-    const role = await (em ?? this.em).findOneOrFail('Role', idDto, {
-      populate: ['id', '*']
-    });
-    return this.#mapperss.RoleDtoMapper.serializeEntityToDto(
-      role as Entities['RoleDtoMapper']
-    );
-  }
-
-  async getBatchRoles(idsDto: IdsDto, em?: EntityManager): Promise<RoleDto[]> {
-    return (
-      await (em ?? this.em).find('Role', idsDto, {
-        populate: ['id', '*']
-      })
-    ).map((role) =>
-      this.#mapperss.RoleDtoMapper.serializeEntityToDto(
-        role as Entities['RoleDtoMapper']
-      )
-    );
-  }
-
-  async updateRole(
-    roleDto: Dto['UpdateRoleDtoMapper'],
-    em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper']> {
-    let role = this.#mapperss.UpdateRoleDtoMapper.deserializeDtoToEntity(
-      roleDto
-    ) as Entities['RoleDtoMapper'];
-    await (em ?? this.em).transactional(async (em) => {
-      role = (await em.upsert('Role', role)) as Entities['RoleDtoMapper'];
-    });
-    return this.#mapperss.RoleDtoMapper.serializeEntityToDto(role);
-  }
-
-  async updateBatchRoles(
-    roleDtos: Dto['UpdateRoleDtoMapper'][],
-    em?: EntityManager
-  ): Promise<Dto['RoleDtoMapper'][]> {
-    let roles = await Promise.all(
-      roleDtos.map(async (roleDto) =>
-        this.#mapperss.UpdateRoleDtoMapper.deserializeDtoToEntity(roleDto)
-      )
-    );
-    await (em ?? this.em).transactional(async (em) => {
-      roles = await em.upsertMany('Role', roles);
-    });
-    return roles.map((role) =>
-      this.#mapperss.RoleDtoMapper.serializeEntityToDto(
-        role as Entities['RoleDtoMapper']
-      )
-    );
-  }
-
-  async deleteRole(idDto: IdDto, em?: EntityManager): Promise<void> {
-    await (em ?? this.em).nativeDelete('Role', idDto);
-  }
-
-  async deleteBatchRoles(idsDto: IdsDto, em?: EntityManager): Promise<void> {
-    await (em ?? this.em).nativeDelete('Role', { id: { $in: idsDto.ids } });
-  }
-}