feat(nestjs): migrate to NestJS

packages/server/src/modules/Roles/commands/CreateRole.service.ts

@@ -0,0 +1,52 @@
+import { Knex } from 'knex';
+import { IRoleCreatedPayload } from '../Roles.types';
+import { Role } from './../models/Role.model';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { UnitOfWork } from '../../Tenancy/TenancyDB/UnitOfWork.service';
+import { events } from '@/common/events/events';
+import { CreateRoleDto } from '../dtos/Role.dto';
+import { TenantModelProxy } from '@/modules/System/models/TenantBaseModel';
+import { Inject, Injectable } from '@nestjs/common';
+import { validateInvalidPermissions } from '../utils';
+
+@Injectable()
+export class CreateRoleService {
+  constructor(
+    private readonly uow: UnitOfWork,
+    private readonly eventPublisher: EventEmitter2,
+
+    @Inject(Role.name)
+    private readonly roleModel: TenantModelProxy<typeof Role>,
+  ) {}
+
+  /**
+   * Creates a new role and store it to the storage.
+   * @param {CreateRoleDto} createRoleDTO -
+   * @returns
+   */
+  public async createRole(createRoleDTO: CreateRoleDto) {
+    // Validates the invalid permissions.
+    validateInvalidPermissions(createRoleDTO.permissions);
+
+    // Transformes the permissions DTO.
+    const permissions = createRoleDTO.permissions;
+
+    // Creates a new role with associated entries under unit-of-work.
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Creates a new role to the storage.
+      const role = await this.roleModel().query(trx).upsertGraph({
+        name: createRoleDTO.roleName,
+        description: createRoleDTO.roleDescription,
+        permissions,
+      });
+      // Triggers `onRoleCreated` event.
+      await this.eventPublisher.emitAsync(events.roles.onCreated, {
+        createRoleDTO,
+        role,
+        trx,
+      } as IRoleCreatedPayload);
+
+      return role;
+    });
+  }
+}

packages/server/src/modules/Roles/commands/DeleteRole.service.ts

@@ -0,0 +1,83 @@
+import { Knex } from 'knex';
+import { IRoleDeletedPayload } from '../Roles.types';
+import { TenantModelProxy } from '../../System/models/TenantBaseModel';
+import { Role } from '../models/Role.model';
+import { RolePermission } from '../models/RolePermission.model';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { Inject, Injectable } from '@nestjs/common';
+import { UnitOfWork } from '@/modules/Tenancy/TenancyDB/UnitOfWork.service';
+import { validateRoleNotPredefined } from '../Roles.utils';
+import { TenantUser } from '@/modules/Tenancy/TenancyModels/models/TenantUser.model';
+import { ServiceError } from '@/modules/Items/ServiceError';
+import { ERRORS } from '../constants';
+
+@Injectable()
+export class DeleteRoleService {
+  constructor(
+    private readonly uow: UnitOfWork,
+    private readonly eventPublisher: EventEmitter2,
+
+    @Inject(Role.name)
+    private readonly roleModel: TenantModelProxy<typeof Role>,
+
+    @Inject(RolePermission.name)
+    private readonly rolePermissionModel: TenantModelProxy<
+      typeof RolePermission
+    >,
+
+    @Inject(TenantUser.name)
+    private readonly tenantUserModel: TenantModelProxy<typeof TenantUser>,
+  ) {}
+
+  /**
+   * Deletes the given role from the storage.
+   * @param {number} roleId - Role id.
+   */
+  public async deleteRole(roleId: number): Promise<void> {
+    // Retrieve the given role or throw not found service error.
+    const oldRole = await this.roleModel()
+      .query()
+      .findById(roleId)
+      .throwIfNotFound();
+
+    // Validate role is not predefined.
+    validateRoleNotPredefined(oldRole);
+
+    // Validates the given role is not associated to any user.
+    await this.validateRoleNotAssociatedToUser(roleId);
+
+    // Deletes the given role and associated models under unit-of-work envirement.
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Deletes the role associated permissions from the storage.
+      await this.rolePermissionModel()
+        .query(trx)
+        .where('roleId', roleId)
+        .delete();
+
+      // Deletes the role object form the storage.
+      await Role.query(trx).findById(roleId).delete();
+
+      // Triggers `onRoleDeleted` event.
+      await this.eventPublisher.emitAsync(events.roles.onDeleted, {
+        oldRole,
+        roleId,
+        trx,
+      } as IRoleDeletedPayload);
+    });
+  }
+  /**
+   * Validates the given role is not associated to any tenant users.
+   * @param {number} roleId
+   */
+  private validateRoleNotAssociatedToUser = async (roleId: number) => {
+    const userAssociatedRole = await this.tenantUserModel()
+      .query()
+      .where('roleId', roleId);
+
+    // Throw service error if the role has associated users.
+    if (userAssociatedRole.length > 0) {
+      throw new ServiceError(ERRORS.CANNT_DELETE_ROLE_ASSOCIATED_TO_USERS);
+    }
+  };
+}

packages/server/src/modules/Roles/commands/EditRole.service.ts

@@ -0,0 +1,55 @@
+import { Knex } from 'knex';
+import { IRoleEditedPayload } from '../Roles.types';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { EditRoleDto } from '../dtos/Role.dto';
+import { Inject, Injectable } from '@nestjs/common';
+import { TenantModelProxy } from '@/modules/System/models/TenantBaseModel';
+import { Role } from '../models/Role.model';
+import { UnitOfWork } from '@/modules/Tenancy/TenancyDB/UnitOfWork.service';
+import { validateInvalidPermissions } from '../utils';
+
+@Injectable()
+export class EditRoleService {
+  constructor(
+    private readonly uow: UnitOfWork,
+    private readonly eventPublisher: EventEmitter2,
+
+    @Inject(Role.name)
+    private readonly roleModel: TenantModelProxy<typeof Role>,
+  ) {}
+
+  /**
+   * Edits details of the given role on the storage.
+   * @param {number} roleId - Role id.
+   * @param {IEditRoleDTO} editRoleDTO - Edit role DTO.
+   */
+  public async editRole(roleId: number, editRoleDTO: EditRoleDto) {
+    // Validates the invalid permissions.
+    validateInvalidPermissions(editRoleDTO.permissions);
+
+    // Retrieve the given role or throw not found serice error.
+    const oldRole = await this.roleModel().query().findById(roleId);
+    const permissions = editRoleDTO.permissions;
+
+    // Updates the role on the storage.
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Updates the given role to the storage.
+      const role = await this.roleModel().query(trx).upsertGraph({
+        id: roleId,
+        name: editRoleDTO.roleName,
+        description: editRoleDTO.roleDescription,
+        permissions,
+      });
+      // Triggers `onRoleEdited` event.
+      await this.eventPublisher.emitAsync(events.roles.onEdited, {
+        editRoleDTO,
+        oldRole,
+        role,
+        trx,
+      } as IRoleEditedPayload);
+
+      return role;
+    });
+  }
+}