@forklaunch/implementation-iam-base 0.1.0

package/services/role.service.ts

@@ -0,0 +1,182 @@
+import {
+  CreateRoleDto,
+  RoleDto,
+  RoleService,
+  UpdateRoleDto
+} from '@forklaunch/interfaces-iam';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector
+} from '@forklaunch/core/http';
+import { EntityManager } from '@mikro-orm/core';
+
+import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  InternalDtoMapper,
+  RequestDtoMapperConstructor,
+  ResponseDtoMapperConstructor,
+  transformIntoInternalDtoMapper
+} from '@forklaunch/core/dtoMapper';
+import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
+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
+{
+  #dtoMappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.dtoMappers>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    public em: EntityManager,
+    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected schemaValidator: SchemaValidator,
+    protected dtoMappers: {
+      RoleDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['RoleDtoMapper'],
+        Entities['RoleDtoMapper']
+      >;
+      CreateRoleDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateRoleDtoMapper'],
+        Entities['CreateRoleDtoMapper']
+      >;
+      UpdateRoleDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateRoleDtoMapper'],
+        Entities['UpdateRoleDtoMapper']
+      >;
+    }
+  ) {
+    this.#dtoMappers = transformIntoInternalDtoMapper(
+      dtoMappers,
+      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.#dtoMappers.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto);
+    await (em ?? this.em).transactional((em) => em.persist(role));
+    return this.#dtoMappers.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.#dtoMappers.CreateRoleDtoMapper.deserializeDtoToEntity(roleDto)
+      )
+    );
+    await (em ?? this.em).transactional((em) => em.persist(roles));
+    return roles.map((role) =>
+      this.#dtoMappers.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.#dtoMappers.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.#dtoMappers.RoleDtoMapper.serializeEntityToDto(
+        role as Entities['RoleDtoMapper']
+      )
+    );
+  }
+
+  async updateRole(
+    roleDto: Dto['UpdateRoleDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['RoleDtoMapper']> {
+    let role = this.#dtoMappers.UpdateRoleDtoMapper.deserializeDtoToEntity(
+      roleDto
+    ) as Entities['RoleDtoMapper'];
+    await (em ?? this.em).transactional(async (em) => {
+      role = (await em.upsert('Role', role)) as Entities['RoleDtoMapper'];
+    });
+    return this.#dtoMappers.RoleDtoMapper.serializeEntityToDto(role);
+  }
+
+  async updateBatchRoles(
+    roleDtos: Dto['UpdateRoleDtoMapper'][],
+    em?: EntityManager
+  ): Promise<Dto['RoleDtoMapper'][]> {
+    let roles = await Promise.all(
+      roleDtos.map(async (roleDto) =>
+        this.#dtoMappers.UpdateRoleDtoMapper.deserializeDtoToEntity(roleDto)
+      )
+    );
+    await (em ?? this.em).transactional(async (em) => {
+      roles = await em.upsertMany('Role', roles);
+    });
+    return roles.map((role) =>
+      this.#dtoMappers.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 } });
+  }
+}

package/services/user.service.ts

@@ -0,0 +1,225 @@
+import {
+  CreateUserDto,
+  RoleService,
+  UpdateUserDto,
+  UserDto,
+  UserService
+} from '@forklaunch/interfaces-iam';
+import {
+  MetricsDefinition,
+  OpenTelemetryCollector
+} from '@forklaunch/core/http';
+
+import { OrganizationService } from '@forklaunch/interfaces-iam';
+import { IdDto, IdsDto, InstanceTypeRecord } from '@forklaunch/common';
+import {
+  InternalDtoMapper,
+  RequestDtoMapperConstructor,
+  ResponseDtoMapperConstructor,
+  transformIntoInternalDtoMapper
+} from '@forklaunch/core/dtoMapper';
+import { MapNestedDtoArraysToCollections } from '@forklaunch/core/services';
+import { AnySchemaValidator } from '@forklaunch/validator';
+import { EntityManager } from '@mikro-orm/core';
+
+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'>;
+  }
+> implements UserService
+{
+  #dtoMappers: InternalDtoMapper<
+    InstanceTypeRecord<typeof this.dtoMappers>,
+    Entities,
+    Dto
+  >;
+
+  constructor(
+    public em: EntityManager,
+    protected passwordEncryptionPublicKeyPath: string,
+    protected roleServiceFactory: () => RoleService,
+    protected organizationServiceFactory: () => OrganizationService<OrganizationStatus>,
+    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>,
+    protected schemaValidator: SchemaValidator,
+    protected dtoMappers: {
+      UserDtoMapper: ResponseDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UserDtoMapper'],
+        Entities['UserDtoMapper']
+      >;
+      CreateUserDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['CreateUserDtoMapper'],
+        Entities['CreateUserDtoMapper'],
+        (
+          dto: never,
+          passwordEncryptionPublicKeyPath: string
+        ) => Entities['UpdateUserDtoMapper']
+      >;
+      UpdateUserDtoMapper: RequestDtoMapperConstructor<
+        SchemaValidator,
+        Dto['UpdateUserDtoMapper'],
+        Entities['UpdateUserDtoMapper'],
+        (
+          dto: never,
+          passwordEncryptionPublicKeyPath: string
+        ) => Entities['UpdateUserDtoMapper']
+      >;
+    }
+  ) {
+    this.#dtoMappers = transformIntoInternalDtoMapper(
+      dtoMappers,
+      schemaValidator
+    );
+  }
+
+  async createUser(
+    userDto: Dto['CreateUserDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper']> {
+    const user =
+      await this.#dtoMappers.CreateUserDtoMapper.deserializeDtoToEntity(
+        userDto,
+        this.passwordEncryptionPublicKeyPath
+      );
+    ((await em) ?? this.em).transactional(async (em) => {
+      await em.persist(user);
+    });
+    return this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user);
+  }
+
+  async createBatchUsers(
+    userDtos: Dto['CreateUserDtoMapper'][],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper'][]> {
+    const users = await Promise.all(
+      userDtos.map(async (createUserDto) =>
+        this.#dtoMappers.CreateUserDtoMapper.deserializeDtoToEntity(
+          createUserDto,
+          this.passwordEncryptionPublicKeyPath
+        )
+      )
+    );
+    await (em ?? this.em).transactional(async (em) => {
+      await em.persist(users);
+    });
+
+    return users.map((user) =>
+      this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user)
+    );
+  }
+
+  async getUser(
+    idDto: IdDto,
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper']> {
+    const user = await (em ?? this.em).findOneOrFail('User', idDto, {
+      populate: ['id', '*']
+    });
+    return this.#dtoMappers.UserDtoMapper.serializeEntityToDto(
+      user as Entities['UserDtoMapper']
+    );
+  }
+
+  async getBatchUsers(
+    idsDto: IdsDto,
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper'][]> {
+    return (
+      await (em ?? this.em).find('User', idsDto, {
+        populate: ['id', '*']
+      })
+    ).map((user) =>
+      this.#dtoMappers.UserDtoMapper.serializeEntityToDto(
+        user as Entities['UserDtoMapper']
+      )
+    );
+  }
+
+  async updateUser(
+    userDto: Dto['UpdateUserDtoMapper'],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper']> {
+    let user = this.#dtoMappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+      userDto,
+      this.passwordEncryptionPublicKeyPath
+    );
+    await (em ?? this.em).transactional(async (localEm) => {
+      user = await localEm.upsert(user);
+    });
+    return this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user);
+  }
+
+  async updateBatchUsers(
+    userDtos: UpdateUserDto[],
+    em?: EntityManager
+  ): Promise<Dto['UserDtoMapper'][]> {
+    let users = await Promise.all(
+      userDtos.map(async (updateUserDto) =>
+        this.#dtoMappers.UpdateUserDtoMapper.deserializeDtoToEntity(
+          updateUserDto,
+          this.passwordEncryptionPublicKeyPath
+        )
+      )
+    );
+    await (em ?? this.em).transactional(async (localEm) => {
+      users = await localEm.upsertMany(users);
+    });
+    return users.map((user) =>
+      this.#dtoMappers.UserDtoMapper.serializeEntityToDto(user)
+    );
+  }
+
+  async deleteUser(idDto: IdDto, em?: EntityManager): Promise<void> {
+    const entityManager = em || this.em;
+    await entityManager.nativeDelete('User', idDto);
+  }
+
+  async deleteBatchUsers(idsDto: IdsDto, em?: EntityManager): Promise<void> {
+    const entityManager = em || this.em;
+    await entityManager.nativeDelete('User', idsDto);
+  }
+
+  async verifyHasRole(idDto: IdDto, roleId: string): Promise<void> {
+    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}`);
+    }
+  }
+
+  async verifyHasPermission(idDto: IdDto, permissionId: string): Promise<void> {
+    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}`
+      );
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "exclude": ["node_modules", "dist", "eslint.config.mjs"]
+}