@dirayaah/assessment-module 1.0.0

package/src/migrations/1767108782301-CreateAssessmentTable.ts

@@ -0,0 +1,88 @@
+import { baseColumns } from '../utilities/migrations/get-base-columns';
+import {
+  MigrationInterface,
+  QueryRunner,
+  Table,
+  TableUnique,
+} from 'typeorm/index.js';
+
+export class CreateAssessmentTable1767108782301 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const [idColumn, ...otherBaseColumns] = baseColumns;
+    await queryRunner.createTable(
+      new Table({
+        name: 'assessment',
+        columns: [
+          idColumn,
+          {
+            name: 'title',
+            type: 'varchar',
+            isNullable: false,
+          },
+          {
+            name: 'type',
+            type: 'varchar',
+            isNullable: false,
+          },
+          {
+            name: 'description',
+            type: 'text',
+            isNullable: true,
+          },
+          {
+            name: 'background_image_url',
+            type: 'varchar',
+            isNullable: true,
+          },
+          {
+            name: 'price',
+            type: 'numeric',
+            isNullable: true,
+          },
+          {
+            name: 'discount_price',
+            type: 'numeric',
+            isNullable: true,
+          },
+          {
+            name: 'status',
+            type: 'varchar',
+            isNullable: true,
+          },
+          {
+            name: 'configuration',
+            type: 'json',
+            isNullable: true,
+          },
+          {
+            name: 'published_by',
+            type: 'varchar',
+            isNullable: true,
+          },
+          {
+            name: 'is_private',
+            type: 'boolean',
+            default: false,
+          },
+          {
+            name: 'slug',
+            type: 'varchar',
+            isNullable: false,
+          },
+          {
+            name: 'meta_description',
+            type: 'varchar',
+            isNullable: true,
+          },
+          ...otherBaseColumns,
+        ],
+        uniques: [{ columnNames: ['slug'] }],
+      }),
+      true,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('assessment');
+  }
+}

package/src/migrations/1767200020161-CreatePredefinedAssessmentTable.ts

@@ -0,0 +1,77 @@
+import { PredefinedAssessmentType } from '../enums';
+import { AssessmentDetailsLanguage } from '../enums/language';
+import { baseColumns } from '../utilities/migrations/get-base-columns';
+import {
+  Column,
+  Entity,
+  MigrationInterface,
+  OneToMany,
+  QueryRunner,
+  Table,
+} from 'typeorm/index.js';
+
+export class CreatePredefinedAssessmentTable1767200020161
+  implements MigrationInterface
+{
+  private readonly tableName = 'predefined_assessment';
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const [idColumn, ...otherBaseColumns] = baseColumns;
+    await queryRunner.createTable(
+      new Table({
+        name: this.tableName,
+        columns: [
+          idColumn,
+          {
+            name: 'title',
+            type: 'varchar',
+            isNullable: false,
+          },
+          {
+            name: 'type',
+            type: 'enum',
+            enum: Object.values(PredefinedAssessmentType),
+            isNullable: false,
+          },
+          {
+            name: 'description',
+            type: 'text',
+            isNullable: true,
+          },
+          {
+            name: 'background_image_url',
+            type: 'varchar',
+            isNullable: true,
+          },
+          {
+            name: 'language',
+            type: 'enum',
+            enum: Object.values(AssessmentDetailsLanguage),
+            isNullable: false,
+          },
+          {
+            name: 'category',
+            type: 'varchar',
+            isNullable: true,
+          },
+          {
+            name: 'details',
+            type: 'json',
+            isNullable: false,
+          },
+          {
+            name: 'configuration',
+            type: 'json',
+            isNullable: true,
+          },
+          ...otherBaseColumns,
+        ],
+        uniques: [{ columnNames: ['type', 'language'] }],
+      }),
+      true,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable(this.tableName);
+  }
+}

package/src/migrations/1767204696509-SeedPredefinedAssessments.ts

@@ -0,0 +1,32 @@
+import { PredefinedAssessmentEntity } from '../entities';
+import {
+  DISC_ASSESSMENT,
+  HOLLAND_ASSESSMENT,
+  LEADERSHIP_ASSESSMENT,
+} from '../constants';
+import { MigrationInterface, QueryRunner } from 'typeorm/index.js';
+
+export class SeedPredefinedAssessments1767204696509
+  implements MigrationInterface
+{
+  private readonly tableName = 'predefined_assessment';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const assessments = [
+      ...DISC_ASSESSMENT,
+      ...HOLLAND_ASSESSMENT,
+      ...LEADERSHIP_ASSESSMENT,
+    ].map((item) => ({
+      ...item,
+      configuration: item.configuration ?? {},
+    }));
+
+    for (const assessment of assessments) {
+        await queryRunner.manager.save(queryRunner.manager.create(PredefinedAssessmentEntity, assessment));
+    };
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DELETE FROM "${this.tableName}"`);
+  }
+}

package/src/migrations/1767651698587-AddMetaFieldsToAssessmentTable.ts

@@ -0,0 +1,88 @@
+import {
+  MigrationInterface,
+  QueryRunner,
+  TableColumn,
+  TableUnique,
+} from 'typeorm/index.js';
+
+export class AddMetaFieldsToAssessmentTable1767651698587
+  implements MigrationInterface
+{
+  private readonly tableName = 'assessment';
+  private readonly slugUniqueConstraintName = `UQ_${this.tableName}_slug`;
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const table = await queryRunner.getTable(this.tableName);
+    if (!table) {
+      throw new Error(`Table ${this.tableName} does not exist`);
+    }
+
+    const columnsToAdd: TableColumn[] = [];
+
+    if (!table.findColumnByName('slug')) {
+      columnsToAdd.push(
+        new TableColumn({
+          name: 'slug',
+          type: 'varchar',
+          isNullable: false,
+        }),
+      );
+    }
+
+    if (!table.findColumnByName('meta_description')) {
+      columnsToAdd.push(
+        new TableColumn({
+          name: 'meta_description',
+          type: 'varchar',
+          isNullable: true,
+        }),
+      );
+    }
+
+    if (columnsToAdd.length > 0) {
+      await queryRunner.addColumns(this.tableName, columnsToAdd);
+    }
+
+    // Check if slug unique constraint already exists
+    // Refresh table to get latest state after adding columns
+    const refreshedTable = await queryRunner.getTable(this.tableName);
+    if (refreshedTable) {
+      const slugColumn = refreshedTable.findColumnByName('slug');
+      if (slugColumn) {
+        const existingConstraint = refreshedTable.uniques.find(
+          (u) => u.name === this.slugUniqueConstraintName,
+        );
+        // Also check if there's any unique constraint on slug column
+        const hasSlugUnique = refreshedTable.uniques.some((u) =>
+          u.columnNames.includes('slug'),
+        );
+        if (!existingConstraint && !hasSlugUnique) {
+          await queryRunner.createUniqueConstraint(
+            this.tableName,
+            new TableUnique({
+              name: this.slugUniqueConstraintName,
+              columnNames: ['slug'],
+            }),
+          );
+        }
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const constraintExists = await queryRunner.getTable(this.tableName);
+    if (constraintExists) {
+      const uniqueConstraint = constraintExists.uniques.find(
+        (u) => u.name === this.slugUniqueConstraintName,
+      );
+      if (uniqueConstraint) {
+        await queryRunner.dropUniqueConstraint(
+          this.tableName,
+          this.slugUniqueConstraintName,
+        );
+      }
+    }
+
+    await queryRunner.dropColumns(this.tableName, ['slug', 'meta_description']);
+  }
+}

package/src/migrations/index.ts

@@ -0,0 +1,20 @@
+import { CreateAssessmentTable1767108782301 } from './1767108782301-CreateAssessmentTable';
+
+import { CreatePredefinedAssessmentTable1767200020161 } from './1767200020161-CreatePredefinedAssessmentTable';
+
+import { SeedPredefinedAssessments1767204696509 } from './1767204696509-SeedPredefinedAssessments';
+
+import { AddMetaFieldsToAssessmentTable1767651698587 } from './1767651698587-AddMetaFieldsToAssessmentTable';
+export const AssessmentMigrations = [
+  CreateAssessmentTable1767108782301,
+  CreatePredefinedAssessmentTable1767200020161,
+  SeedPredefinedAssessments1767204696509,
+  AddMetaFieldsToAssessmentTable1767651698587,
+];
+
+export {
+  CreateAssessmentTable1767108782301,
+  CreatePredefinedAssessmentTable1767200020161,
+  SeedPredefinedAssessments1767204696509,
+  AddMetaFieldsToAssessmentTable1767651698587,
+};

package/src/modules/assessment.module.ts

@@ -0,0 +1,22 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { AssessmentService, PredefinedAssessmentService } from '../services';
+import { AssessmentModuleOptions } from '../interfaces/assessments-options.interface';
+import { ASSESSMENTS_OPTIONS } from '../constants';
+
+@Module({})
+export class AssessmentModule {
+  static forRoot(options: AssessmentModuleOptions): DynamicModule {
+    return {
+      module: AssessmentModule,
+      providers: [
+        {
+          provide: ASSESSMENTS_OPTIONS,
+          useValue: options,
+        },
+        AssessmentService,
+        PredefinedAssessmentService,
+      ],
+      exports: [AssessmentService, PredefinedAssessmentService],
+    };
+  }
+}

package/src/repositories/assessment.repository.ts

@@ -0,0 +1,6 @@
+import { AssessmentEntity } from '../entities';
+import { EntityRepository } from 'typeorm/index.js';
+import { BaseRepository } from './base.repository';
+
+@EntityRepository(AssessmentEntity)
+export class AssessmentRepository extends BaseRepository<AssessmentEntity> {}

package/src/repositories/base.repository.ts

@@ -0,0 +1,39 @@
+
+import { FindManyOptions, FindOneOptions, Repository } from 'typeorm/index.js';
+import { BaseEntity } from '../entities/base.entity';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { DeepPartial } from 'typeorm/browser';
+
+export abstract class BaseRepository<
+  T extends BaseEntity,
+> extends Repository<T> {
+  async findById(id: string): Promise<T | undefined> {
+    return this.findOne({ where: { id } } as FindOneOptions<T>);
+  }
+
+  async findWithOptions(options: FindManyOptions<T>): Promise<[T[], number]> {
+    return this.findAndCount(options);
+  }
+
+  async createEntity(data: DeepPartial<T>, creator?: string): Promise<T> {
+    const entity = this.create(data);
+    if (creator) {
+      entity.createdBy = creator;
+      entity.lastModifiedBy = creator;
+    }
+    return this.save(entity as DeepPartial<T>);
+  }
+
+  async updateEntity(
+    id: string,
+    data: QueryDeepPartialEntity<T>,
+    updater?: string,
+  ): Promise<T | undefined> {
+    await this.update(id, {
+      ...data,
+      updatedBy: updater,
+    } as QueryDeepPartialEntity<T>);
+
+    return this.findById(id);
+  }
+}

package/src/repositories/index.ts

@@ -0,0 +1,4 @@
+import { AssessmentRepository } from './assessment.repository';
+import { PredefinedAssessmentRepository } from './predefined-assessment.repository';
+
+export { AssessmentRepository, PredefinedAssessmentRepository };

package/src/repositories/predefined-assessment.repository.ts

@@ -0,0 +1,6 @@
+import { EntityRepository } from 'typeorm/index.js';
+import { BaseRepository } from './base.repository';
+import { PredefinedAssessmentEntity } from '../entities/predefined-assessment.entity';
+
+@EntityRepository(PredefinedAssessmentEntity)
+export class PredefinedAssessmentRepository extends BaseRepository<PredefinedAssessmentEntity> {}

package/src/services/assessment.service.ts

@@ -0,0 +1,144 @@
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { ASSESSMENTS_OPTIONS } from '../constants/assessments-options';
+import { AssessmentModuleOptions } from '../interfaces/assessments-options.interface';
+import { AssessmentEntity } from '../entities';
+import { AssessmentDto } from '../dto';
+import { FindManyOptions, Repository } from 'typeorm/index.js';
+import { PageRequest } from '../entities/pagination';
+import { AssessmentMapper } from '../mappers/assessment.mapper';
+
+@Injectable()
+export class AssessmentService {
+  constructor(
+    @Inject(ASSESSMENTS_OPTIONS)
+    private readonly options: AssessmentModuleOptions,
+  ) {}
+
+  private async getRepository(
+    tenantId: string,
+  ): Promise<Repository<AssessmentEntity>> {
+    const connection =
+      await this.options.connectionProvider.getTenantConnection(tenantId);
+    return connection.getRepository(AssessmentEntity);
+  }
+
+  private async validateUniqueAssessmentSlug(
+    createAssessmentDto: AssessmentDto,
+    tenantId: string,
+  ) {
+    const assessment = await this.findOneByOptions(
+      {
+        where: [{ slug: createAssessmentDto.slug }],
+      },
+      tenantId,
+    );
+    if (assessment) {
+      throw new BadRequestException('ASSESSMENT_SLUG_ALREADY_EXISTS');
+    }
+  }
+
+  async create(createAssessmentDto: AssessmentDto, tenantId: string) {
+    const repository = await this.getRepository(tenantId);
+
+    const assessmentEntity =
+      AssessmentMapper.fromDTOToEntity(createAssessmentDto);
+
+    return repository.save(assessmentEntity);
+  }
+
+  async findAll(tenantId: string): Promise<AssessmentDto[]> {
+    const repository = await this.getRepository(tenantId);
+    const assessments = await repository
+      .createQueryBuilder('assessment')
+      .getMany();
+    return assessments.map((assessment) =>
+      AssessmentMapper.fromEntityToDTO(assessment),
+    );
+  }
+
+  async findByOptions(
+    options: FindManyOptions<AssessmentEntity>,
+    tenantId: string,
+  ): Promise<AssessmentDto[]> {
+    const repository = await this.getRepository(tenantId);
+    const assessments = await repository.find(options);
+    return assessments.map((assessment) =>
+      AssessmentMapper.fromEntityToDTO(assessment),
+    );
+  }
+
+  async findOne(id: number, tenantId: string): Promise<AssessmentDto> {
+    const repository = await this.getRepository(tenantId);
+
+    const assessment = await repository
+      .createQueryBuilder('assessment')
+      .where('assessment.id = :id', { id })
+      .getOne();
+
+    return AssessmentMapper.fromEntityToDTO(assessment);
+  }
+
+  async findOneBySlug(slug: string, tenantId: string): Promise<AssessmentDto> {
+    const repository = await this.getRepository(tenantId);
+
+    const assessment = await repository
+      .createQueryBuilder('assessment')
+      .where('assessment.slug = :slug', { slug })
+      .getOne();
+
+    return AssessmentMapper.fromEntityToDTO(assessment);
+  }
+
+  async findOneByOptions(
+    options: FindManyOptions<AssessmentEntity>,
+    tenantId: string,
+  ): Promise<AssessmentDto> {
+    const repository = await this.getRepository(tenantId);
+    const assessment = await repository.findOne(options);
+    return AssessmentMapper.fromEntityToDTO(assessment);
+  }
+
+  async getPaginatedAssessments(
+    pageRequest: PageRequest,
+    tenantId: string,
+  ): Promise<{ result: AssessmentDto[]; totalCount: number }> {
+    const repository = await this.getRepository(tenantId);
+    const assessments = await repository
+      .createQueryBuilder('assessment')
+      .skip(pageRequest.page * pageRequest.size)
+      .take(pageRequest.size)
+      .orderBy('assessment.id', 'DESC')
+      .getMany();
+
+    const totalCount = await repository.count();
+    return {
+      result: assessments.map((assessment) =>
+        AssessmentMapper.fromEntityToDTO(assessment),
+      ),
+      totalCount,
+    };
+  }
+
+  async update(updateAssessmentDto: AssessmentDto, tenantId: string) {
+    const repository = await this.getRepository(tenantId);
+    const existingAssessment = await repository.findOne(updateAssessmentDto.id);
+    if (!existingAssessment) {
+      throw new NotFoundException('ASSESSMENT_DOES_NOT_EXIST');
+    }
+
+    const updateAssessmentEntity =
+      AssessmentMapper.fromDTOToEntity(updateAssessmentDto);
+
+    return repository.update(updateAssessmentDto.id, updateAssessmentEntity);
+  }
+
+  async remove(id: number, tenantId: string) {
+    const repository = await this.getRepository(tenantId);
+    return await repository.delete(id);
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,4 @@
+import { AssessmentService } from './assessment.service';
+import { PredefinedAssessmentService } from './predefined-assessment.service';
+
+export { AssessmentService, PredefinedAssessmentService };

package/src/services/predefined-assessment.service.ts

@@ -0,0 +1,121 @@
+import { Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { ASSESSMENTS_OPTIONS } from '../constants/assessments-options';
+import { AssessmentModuleOptions } from '../interfaces/assessments-options.interface';
+import { FindManyOptions, Repository } from 'typeorm/index.js';
+import { PageRequest } from '../entities/pagination';
+import { PredefinedAssessmentEntity } from '../entities/predefined-assessment.entity';
+import { PredefinedAssessmentDto } from '../dto/predefined-assessment.dto';
+import { PredefinedAssessmentMapper } from '../mappers/predefined-assessment.mapper';
+
+@Injectable()
+export class PredefinedAssessmentService {
+  constructor(
+    @Inject(ASSESSMENTS_OPTIONS)
+    private readonly options: AssessmentModuleOptions,
+  ) {}
+
+  private async getRepository(
+    tenantId: string,
+  ): Promise<Repository<PredefinedAssessmentEntity>> {
+    const connection =
+      await this.options.connectionProvider.getTenantConnection(tenantId);
+    return connection.getRepository(PredefinedAssessmentEntity);
+  }
+
+  async findAll(tenantId: string): Promise<PredefinedAssessmentDto[]> {
+    const repository = await this.getRepository(tenantId);
+    const predefinedAssessments = await repository
+      .createQueryBuilder('assessment')
+      .getMany();
+    return predefinedAssessments.map((assessment) =>
+      PredefinedAssessmentMapper.fromEntityToDTO(assessment),
+    );
+  }
+
+  async findByOptions(
+    options: FindManyOptions<PredefinedAssessmentEntity>,
+    tenantId: string,
+  ): Promise<PredefinedAssessmentDto[]> {
+    const repository = await this.getRepository(tenantId);
+    const assessments = await repository.find(options);
+    return assessments.map((assessment) =>
+      PredefinedAssessmentMapper.fromEntityToDTO(assessment),
+    );
+  }
+
+  async findOne(
+    id: number,
+    tenantId: string,
+  ): Promise<PredefinedAssessmentDto> {
+    const repository = await this.getRepository(tenantId);
+
+    const predefinedAssessment = await repository
+      .createQueryBuilder('assessment')
+      .where('assessment.id = :id', { id })
+      .getOne();
+
+    return PredefinedAssessmentMapper.fromEntityToDTO(predefinedAssessment);
+  }
+
+  async findOneBySlug(
+    slug: string,
+    tenantId: string,
+  ): Promise<PredefinedAssessmentDto> {
+    const repository = await this.getRepository(tenantId);
+
+    const predefinedAssessment = await repository
+      .createQueryBuilder('assessment')
+      .where('assessment.slug = :slug', { slug })
+      .getOne();
+
+    return PredefinedAssessmentMapper.fromEntityToDTO(predefinedAssessment);
+  }
+
+  async findOneByOptions(
+    options: FindManyOptions<PredefinedAssessmentEntity>,
+    tenantId: string,
+  ): Promise<PredefinedAssessmentDto> {
+    const repository = await this.getRepository(tenantId);
+    const assessment = await repository.findOne(options);
+    return PredefinedAssessmentMapper.fromEntityToDTO(assessment);
+  }
+
+  async getPaginatedAssessments(
+    pageRequest: PageRequest,
+    tenantId: string,
+  ): Promise<{ result: PredefinedAssessmentDto[]; totalCount: number }> {
+    const repository = await this.getRepository(tenantId);
+    const assessments = await repository
+      .createQueryBuilder('assessment')
+      .skip(pageRequest.page * pageRequest.size)
+      .take(pageRequest.size)
+      .orderBy('assessment.id', 'DESC')
+      .getMany();
+
+    const totalCount = await repository.count();
+    return {
+      result: assessments.map((assessment) =>
+        PredefinedAssessmentMapper.fromEntityToDTO(assessment),
+      ),
+      totalCount,
+    };
+  }
+
+  async update(updateAssessmentDto: PredefinedAssessmentDto, tenantId: string) {
+    const repository = await this.getRepository(tenantId);
+    const existingAssessment = await repository.findOne(updateAssessmentDto.id);
+    if (!existingAssessment) {
+      throw new NotFoundException('ASSESSMENT_DOES_NOT_EXIST');
+    }
+
+    const updateAssessmentEntity =
+      PredefinedAssessmentMapper.fromDTOToEntity(updateAssessmentDto);
+
+    return repository.update(updateAssessmentDto.id, updateAssessmentEntity);
+  }
+
+  async remove(id: number, tenantId: string) {
+    const repository = await this.getRepository(tenantId);
+    return await repository.delete(id);
+  }
+}

package/src/utilities/migrations/get-base-columns.ts

@@ -0,0 +1,32 @@
+import { TableColumnOptions } from 'typeorm/schema-builder/options/TableColumnOptions';
+
+export const baseColumns: TableColumnOptions[] = [
+  {
+    name: 'id',
+    type: 'int4',
+    isPrimary: true,
+    isGenerated: true,
+    generationStrategy: 'increment',
+  },
+  {
+    name: 'createdDate',
+    type: 'timestamptz',
+    isNullable: true,
+    default: 'now()',
+  },
+  {
+    name: 'createdBy',
+    type: 'varchar',
+    isNullable: true,
+  },
+  {
+    name: 'lastModifiedDate',
+    type: 'timestamptz',
+    isNullable: true,
+  },
+  {
+    name: 'lastModifiedBy',
+    type: 'varchar',
+    isNullable: true,
+  },
+];