@dirayaah/corporate-module 1.0.17

package/index.ts

@@ -0,0 +1,29 @@
+//MODULES
+export * from './src/modules/corporate.module';
+
+//INTERFACES
+export * from './src/interfaces/corporates-options.interface';
+
+//SERVICES
+export * from './src/services';
+
+//ENTITIES
+export * from './src/entities';
+
+//ENUMS
+export * from './src/enum';
+
+//DTOS
+export * from './src/dto';
+
+//CONSTANTS
+export * from './src/constants';
+
+//MIGRATIONS
+export * from './src/migrations';
+
+//REPOSITORIES
+export * from './src/repository';
+
+//UTILITIES
+export * from './src/utilities';

package/jest.config.ts

@@ -0,0 +1,10 @@
+// jest.config.js
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleFileExtensions: ['ts', 'tsx', 'js'],
+  testMatch: ['src/test/?(*.)+(spec|test).[jt]s?(x)'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
+};

package/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@dirayaah/corporate-module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.17", 
+  "description": "A reusable module for handling Corporates in nestjs applications",
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./migrations": {
+      "import": "./dist/migrations/index.js",
+      "require": "./dist/migrations/index.js"
+    },
+    "./entities": {
+      "import": "./dist/entities/index.js",
+      "require": "./dist/entities/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.zadapps.info/dirayaah/packages/corporate.git"
+  },
+  "author": "MD-LABS",
+  "license": "MIT",
+  "dependencies": {
+    "@nestjs/common": "^10.4.20",
+    "@nestjs/core": "^10.4.20",
+    "@nestjs/platform-express": "^10.4.20",
+    "@nestjs/swagger": "^7.4.2",
+    "@nestjs/typeorm": "^10.0.2",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3",
+    "typeorm": "^0.3.28"
+  },
+  "devDependencies": {
+    "@nestjs/testing": "^10.4.16",
+    "@types/express": "^4.17.21",
+    "@types/jest": "^28.1.8",
+    "@types/node": "^20.14.0",
+    "jest": "^28.1.3",
+    "ts-jest": "^28.0.8",
+    "typescript": "^5.3.3"
+  }
+}

package/src/constants/corporates-options.ts

@@ -0,0 +1 @@
+export const CORPORATES_OPTIONS = 'CORPORATES_OPTIONS';

package/src/constants/index.ts

@@ -0,0 +1 @@
+export { CORPORATES_OPTIONS } from './corporates-options';

package/src/dto/base.dto.ts

@@ -0,0 +1,14 @@
+/**
+ * A DTO base object.
+ */
+export class BaseDTO {
+    id?: number;
+
+    createdBy?: string;
+
+    createdDate?: Date;
+
+    lastModifiedBy?: string;
+
+    lastModifiedDate?: Date;
+}

package/src/dto/corporate.dto.ts

@@ -0,0 +1,27 @@
+import { IsNotEmpty, IsEnum, IsOptional } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+import { BaseDTO } from './base.dto';
+
+export class CorporateDto extends BaseDTO {
+  @IsNotEmpty()
+  @ApiProperty({ type: String, required: true, name: 'name' })
+  name: string;
+
+  @IsNotEmpty()
+  @ApiProperty({ type: Number, required: true, name: 'managerId' })
+  managerId: number;
+
+  @IsOptional()
+  @ApiProperty({ type: String, required: false, name: 'email' })
+  email?: string;
+
+  @ApiProperty({
+    name: 'status',
+    description: 'Corporate status',
+  })
+  status: string;
+
+  @IsOptional()
+  @ApiProperty({ type: Number, required: false, name: 'maxParticipantsCount' })
+  maxParticipantsCount?: number;
+}

package/src/dto/index.ts

@@ -0,0 +1,6 @@
+import { CorporateDto } from './corporate.dto';
+
+
+export {
+  CorporateDto,
+};

package/src/entities/base.entity.ts

@@ -0,0 +1,23 @@
+import {
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+
+export abstract class BaseEntity {
+  @PrimaryGeneratedColumn()
+  id?: number;
+
+  @Column({ nullable: true })
+  createdBy?: string;
+
+  @CreateDateColumn({ nullable: true })
+  createdDate?: Date;
+
+  @Column({ nullable: true })
+  lastModifiedBy?: string;
+  
+  @UpdateDateColumn({ nullable: true })
+  lastModifiedDate?: Date;
+}

package/src/entities/corporate.entity.ts

@@ -0,0 +1,24 @@
+import { BaseEntity } from './base.entity';
+import { Column, Entity, OneToMany } from 'typeorm';
+import { RelCorporateParticipantsEntity } from './rel-corporate-user.entity';
+
+@Entity('corporate')
+export class CorporateEntity extends BaseEntity {
+  @Column({ nullable: false })
+  name: string;
+
+  @Column({ nullable: true })
+  email: string;
+
+  @Column({ nullable: false })
+  managerId: number;
+
+  @Column({ nullable: true })
+  status: string;
+
+  @Column({ nullable: true, name: 'max_participants_count' })
+  maxParticipantsCount: number;
+
+  @OneToMany(() => RelCorporateParticipantsEntity, (rel) => rel.corporate)
+  relCorporateParticipants: RelCorporateParticipantsEntity[];
+}

package/src/entities/index.ts

@@ -0,0 +1,4 @@
+import { CorporateEntity } from './corporate.entity';
+import { RelCorporateParticipantsEntity } from './rel-corporate-user.entity';
+
+export { CorporateEntity, RelCorporateParticipantsEntity };

package/src/entities/pagination.ts

@@ -0,0 +1,42 @@
+/* eslint-disable max-classes-per-file */
+import { Type, Expose as JsonProperty } from 'class-transformer';
+import { BaseEntity } from './base.entity';
+
+export class Sort {
+  public property: string;
+  public direction: 'ASC' | 'DESC' | string;
+  constructor(sort: string) {
+    if (sort) {
+      [this.property, this.direction] = sort.split(',');
+    }
+  }
+
+  asOrder(): any {
+    const order = {};
+    order[this.property] = this.direction;
+    return order;
+  }
+}
+
+export class PageRequest {
+  @JsonProperty()
+  page: number = 0;
+  @JsonProperty()
+  size: number = 20;
+  @Type(() => Sort)
+  sort: Sort = new Sort('id,ASC');
+
+  constructor(page: number | string, size: number | string, sort: string) {
+    this.page = +page || this.page;
+    this.size = +size || this.size;
+    this.sort = sort ? new Sort(sort) : this.sort;
+  }
+}
+
+export class Page<T extends BaseEntity> {
+  constructor(
+    public content: T[],
+    public total: number,
+    public pageable: PageRequest,
+  ) {}
+}

package/src/entities/rel-corporate-user.entity.ts

@@ -0,0 +1,15 @@
+import { BaseEntity } from './base.entity';
+import { Column, Entity, ManyToOne } from 'typeorm';
+import { CorporateEntity } from './corporate.entity';
+
+@Entity('rel_corporate_participant')
+export class RelCorporateParticipantsEntity extends BaseEntity {
+  @ManyToOne(
+    () => CorporateEntity,
+    (corporate) => corporate.relCorporateParticipants,
+  )
+  corporate: CorporateEntity;
+
+  @Column({ nullable: false })
+  participantId: number;
+}

package/src/enum/corporate-status.enum.ts

@@ -0,0 +1,4 @@
+export enum CorporateStatus {
+  PUBLISHED = 'PUBLISHED',
+  DRAFT = 'DRAFT',
+}

package/src/enum/index.ts

@@ -0,0 +1 @@
+export { CorporateStatus } from './corporate-status.enum';

package/src/interfaces/corporates-options.interface.ts

@@ -0,0 +1,6 @@
+export interface CorporateModuleOptions {
+  connectionProvider: {
+    getTenantConnection(tenantId: string): Promise<any>;
+    getConnection(): Promise<any>;
+  };
+}

package/src/mappers/corporate.mapper.ts

@@ -0,0 +1,36 @@
+import { CorporateDto } from '../dto/corporate.dto';
+import { CorporateEntity } from '../entities';
+
+export class CorporateMapper {
+
+  static fromDTOToEntity(corporateDto: CorporateDto): CorporateEntity {
+    if (!corporateDto) {
+      return;
+    }
+    let corporateEntity = new CorporateEntity();
+
+
+    const fields = Object.getOwnPropertyNames(corporateDto);
+
+    fields.forEach((field) => {
+      corporateEntity[field] = corporateDto[field];
+    });
+
+    return corporateEntity;
+  }
+
+  static fromEntityToDTO(entity: CorporateEntity): CorporateDto {
+    if (!entity) {
+      return;
+    }
+    let entityDTO = new CorporateDto();
+
+    const fields = Object.getOwnPropertyNames(entity);
+
+    fields.forEach((field) => {
+      entityDTO[field] = entity[field];
+    });
+
+    return entityDTO;
+  }
+}

package/src/migrations/1756375695674-CreateCorporateTable.ts

@@ -0,0 +1,50 @@
+import { baseColumns } from '../utilities';
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+import { CorporateStatus } from '../enum/corporate-status.enum';
+
+export class CreateCorporateTable1756375695674 implements MigrationInterface {
+  private readonly table = 'corporate';
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const [idColumn, ...otherBaseColumns] = baseColumns;
+    await queryRunner.createTable(
+      new Table({
+        name: this.table,
+        columns: [
+          idColumn,
+          {
+            name: 'name',
+            type: 'varchar',
+            isNullable: false,
+          },
+          {
+            name: 'managerId',
+            type: 'int4',
+            isNullable: false,
+          },
+          {
+            name: 'email',
+            type: 'varchar',
+            isNullable: true,
+            isUnique: true,
+          },
+          {
+            name: 'status',
+            type: 'varchar',
+            isNullable: false,
+          },
+          {
+            name: 'max_participants_count',
+            type: 'int4',
+            isNullable: true,
+          },
+          ...otherBaseColumns,
+        ],
+      }),
+      false,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable(this.table, true, true, true);
+  }
+}

package/src/migrations/1756375696676-CreateRelCorporateParticipantTable.ts

@@ -0,0 +1,48 @@
+import { baseColumns } from '../utilities';
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+
+export class CreateRelCorporateParticipantTable1756375696676
+  implements MigrationInterface
+{
+  private readonly table = 'rel_corporate_participant';
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const [idColumn, ...otherBaseColumns] = baseColumns;
+    await queryRunner.createTable(
+      new Table({
+        name: this.table,
+        columns: [
+          idColumn,
+          {
+            name: 'corporateId',
+            type: 'int4',
+            isNullable: false,
+          },
+          {
+            name: 'participantId',
+            type: 'int4',
+            isNullable: false,
+          },
+          ...otherBaseColumns,
+        ],
+        foreignKeys: [
+          {
+            name: `fk_${this.table}_corporate`,
+            columnNames: ['corporateId'],
+            referencedTableName: 'corporate',
+            referencedColumnNames: ['id'],
+            onDelete: 'CASCADE',
+          },
+        ],
+        uniques: [
+          {
+            name: `UQ_${this.table}_corporateId_participantId`,
+            columnNames: ['corporateId', 'participantId'],
+          },
+        ],
+      }),
+      false,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {}
+}

package/src/migrations/index.ts

@@ -0,0 +1,12 @@
+import { CreateCorporateTable1756375695674 } from './1756375695674-CreateCorporateTable';
+import { CreateRelCorporateParticipantTable1756375696676 } from './1756375696676-CreateRelCorporateParticipantTable';
+
+export const CorporateMigrations = [
+  CreateCorporateTable1756375695674,
+  CreateRelCorporateParticipantTable1756375696676,
+];
+
+export {
+  CreateCorporateTable1756375695674,
+  CreateRelCorporateParticipantTable1756375696676,
+};

package/src/modules/corporate.module.ts

@@ -0,0 +1,23 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { CORPORATES_OPTIONS } from '../constants/corporates-options';
+import { CorporateModuleOptions } from '../interfaces/corporates-options.interface';
+import { CorporateService } from '../services';
+
+@Module({})
+export class CorporateModule {
+  static forRoot(options: CorporateModuleOptions): DynamicModule {
+    return {
+      module: CorporateModule,
+      providers: [
+        {
+          provide: CORPORATES_OPTIONS,
+          useValue: options,
+        },
+        CorporateService,
+      ],
+      exports: [
+        CorporateService,
+      ],
+    };
+  }
+}

package/src/repository/base.repository.ts

@@ -0,0 +1,42 @@
+import {
+    Repository,
+    DeepPartial,
+    FindManyOptions,
+    FindOneOptions,
+} from 'typeorm';
+import { BaseEntity } from '../entities/base.entity';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+
+export abstract class BaseRepository<
+    T extends BaseEntity,
+> extends Repository<T> {
+    async findById(id: number | 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: number | string,
+        data: QueryDeepPartialEntity<T>,
+        updater?: string,
+    ): Promise<T | undefined> {
+        await this.update(id, {
+            ...data,
+            lastModifiedBy: updater,
+        } as QueryDeepPartialEntity<T>);
+
+        return this.findById(id);
+    }
+}

package/src/repository/corporate.repository.ts

@@ -0,0 +1,4 @@
+import { CorporateEntity } from '../entities/corporate.entity'
+import { BaseRepository } from './base.repository';
+
+export class CorporateRepository extends BaseRepository<CorporateEntity> {}

package/src/repository/index.ts

@@ -0,0 +1 @@
+export * from './corporate.repository';

package/src/services/corporate.service.ts

@@ -0,0 +1,142 @@
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { FindManyOptions, FindOneOptions, Repository } from 'typeorm';
+import { CorporateEntity } from '../entities/corporate.entity';
+import { CorporateModuleOptions } from '../interfaces/corporates-options.interface';
+import { CORPORATES_OPTIONS } from '../constants/corporates-options';
+import { CorporateDto } from '../dto/corporate.dto';
+import { PageRequest } from '../entities/pagination';
+import { CorporateMapper } from '../mappers/corporate.mapper';
+
+@Injectable()
+export class CorporateService {
+  constructor(
+    @Inject(CORPORATES_OPTIONS)
+    private readonly options: CorporateModuleOptions,
+  ) {}
+
+  private async getRepository(
+    tenantId: string,
+  ): Promise<Repository<CorporateEntity>> {
+    const connection =
+      await this.options.connectionProvider.getTenantConnection(tenantId);
+    return connection.getRepository(CorporateEntity);
+  }
+
+  private async validateUniqueCorporateProps(
+    createCorporateDto: CorporateDto,
+    tenantId: string,
+  ) {
+    const corporate = await this.findOneByOptions(
+      {
+        where: { email: createCorporateDto.email },
+      },
+      tenantId,
+    );
+    if (corporate) {
+      throw new BadRequestException('CORPORATE_EMAIL_ALREADY_EXISTS');
+    }
+  }
+
+  async create(createCorporateDto: CorporateDto, tenantId: string) {
+    await this.validateUniqueCorporateProps(createCorporateDto, tenantId);
+
+    const repository = await this.getRepository(tenantId);
+
+    const corporateEntity = CorporateMapper.fromDTOToEntity(createCorporateDto);
+
+    return repository.save(corporateEntity);
+  }
+
+  async findAll(tenantId: string): Promise<CorporateDto[]> {
+    const repository = await this.getRepository(tenantId);
+    const corporates = await repository
+      .createQueryBuilder('corporate')
+      .getMany();
+    return corporates.map((corporate) =>
+      CorporateMapper.fromEntityToDTO(corporate),
+    );
+  }
+
+  async findByOptions(
+    options: FindManyOptions<CorporateEntity>,
+    tenantId: string,
+  ): Promise<CorporateDto[]> {
+    const repository = await this.getRepository(tenantId);
+    const corporates = await repository.find(options);
+    return corporates.map((corporate) =>
+      CorporateMapper.fromEntityToDTO(corporate),
+    );
+  }
+
+  async findOne(id: number, tenantId: string): Promise<CorporateDto> {
+    const repository = await this.getRepository(tenantId);
+
+    const corporate = await repository
+      .createQueryBuilder('corporate')
+      .where('corporate.id = :id', { id })
+      .getOne();
+
+    return CorporateMapper.fromEntityToDTO(corporate);
+  }
+
+  async findOneByOptions(
+    options: FindOneOptions<CorporateEntity>,
+    tenantId: string,
+  ): Promise<CorporateDto> {
+    const repository = await this.getRepository(tenantId);
+    const corporate = await repository.findOne(options);
+    return CorporateMapper.fromEntityToDTO(corporate);
+  }
+
+  async getPaginatedCorporates(
+    pageRequest: PageRequest,
+    tenantId: string,
+  ): Promise<{ result: CorporateDto[]; totalCount: number }> {
+    const repository = await this.getRepository(tenantId);
+    const corporates = await repository
+      .createQueryBuilder('corporate')
+      .skip(pageRequest.page * pageRequest.size)
+      .take(pageRequest.size)
+      .orderBy('corporate.id', 'DESC')
+      .getMany();
+
+    const totalCount = await repository.count();
+    return {
+      result: corporates.map((corporate) =>
+        CorporateMapper.fromEntityToDTO(corporate),
+      ),
+      totalCount,
+    };
+  }
+
+  async update(updateCorporateDto: CorporateDto, tenantId: string) {
+    const repository = await this.getRepository(tenantId);
+    const existingCorporate = await repository.findOne({
+      where: { id: updateCorporateDto.id },
+    });
+    if (!existingCorporate) {
+      throw new NotFoundException('CORPORATE_DOES_NOT_EXIST');
+    }
+    if (updateCorporateDto.email && existingCorporate.email !== updateCorporateDto.email) {
+      const existingCorporateWithNewData = await repository.findOne({
+        where: { email: updateCorporateDto.email },
+      });
+      if (existingCorporateWithNewData) {
+        throw new BadRequestException('CORPORATE_EMAIL_ALREADY_EXISTS');
+      }
+    }
+    const updateCorporateEntity =
+      CorporateMapper.fromDTOToEntity(updateCorporateDto);
+    return repository.update(updateCorporateDto.id, updateCorporateEntity);
+  }
+
+  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,5 @@
+import { CorporateService } from './corporate.service';
+
+export {
+  CorporateService,
+};