@mondart/nestjs-common-module 1.0.3

package/.eslintrc.js

@@ -0,0 +1,25 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+  },
+};

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,34 @@
+name: Build and Publish
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '16' # Use the Node.js version your project requires
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build project
+        run: npm run build # Adjust this if your build command is different
+
+      - name: Set NPM Token
+        run: npm config set _authToken=${{ secrets.NPM_TOKEN }}
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Publish to npm
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npm publish --access public

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

package/common/caching/caching.module.ts

@@ -0,0 +1,28 @@
+import { Global, Module } from '@nestjs/common';
+import { CachingService } from './caching.service';
+import { CacheModule } from '@nestjs/cache-manager';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import * as redisStore from 'cache-manager-redis-store';
+
+@Global()
+@Module({
+  imports: [
+    CacheModule.register({
+      isGlobal: true,
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        ttl: configService.get('CACHE_TTL', 86400000),
+        store: redisStore,
+        host: configService.get('redis.host'),
+        port: configService.get('redis.port'),
+        password: configService.get('redis.password'),
+        max: 10000,
+        isGlobal: true,
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+  providers: [CachingService],
+  exports: [CachingService],
+})
+export class CachingModule {}

package/common/caching/caching.service.ts

@@ -0,0 +1,34 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Cache } from 'cache-manager';
+
+@Injectable()
+export class CachingService {
+  constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
+
+  getRedisClient() {
+    return this.cacheManager.store;
+  }
+
+  async get<T>(key: string) {
+    const result: string = await this.cacheManager.get<undefined | string>(key);
+    // JSON parse result
+    if (result) {
+      return JSON.parse(result) as T;
+    }
+    return result as T;
+  }
+
+  async set<T>(key: string, value: T, ttlSeconds: number): Promise<void> {
+    // stringify value
+    return await this.cacheManager.set(
+      key,
+      JSON.stringify(value),
+      ttlSeconds * 1000,
+    );
+  }
+
+  async del(key: string): Promise<void> {
+    return await this.cacheManager.del(key);
+  }
+}

package/common/caching/index.ts

@@ -0,0 +1,2 @@
+export * from './caching.module';
+export * from './caching.service';

package/common/constants/index.ts

@@ -0,0 +1 @@
+export * from './validation-constraints.const';

package/common/constants/validation-constraints.const.ts

@@ -0,0 +1,14 @@
+export class ValidationConstraints {
+  static readonly maxIntegerValue = 2147483646;
+  static readonly pageLimit = 50;
+  static readonly otpCodeLength = 6;
+  static readonly minSortFieldLength = 2;
+  static readonly maxSortFieldLength = 32;
+  static readonly shebaNumberLength = 26;
+  static readonly ticketMessageMinLength = 50;
+  static readonly ticketMessageMaxLength = 500;
+  static readonly trackingCodeLength = 8;
+  static readonly phonePattern = /^(?![1-9]).{11}$/;
+  static readonly faxPattern = /^\+?[0-9]{6,}$/;
+  static readonly postalCodeLength = 10;
+}

package/common/controllers/core-crud.controller.ts

@@ -0,0 +1,106 @@
+import {
+  Get,
+  Post,
+  Body,
+  Put,
+  Param,
+  Delete,
+  NotFoundException,
+  HttpStatus,
+  BadRequestException,
+} from '@nestjs/common';
+import { Paginate, Paginated } from 'nestjs-paginate';
+import { PaginateConfig } from 'nestjs-paginate/lib/paginate';
+import { PaginationQueryCustom } from '../interface/pagination-query';
+import { SharedMessages } from '../enums/shared-messages.enum';
+import { SuccessResponse } from '../dto/response/success-response.dto';
+import { BaseResponseWithActionDates } from '../dto/response/base-response-with-action-dates.dto';
+import { IdDto } from '../dto/request/id.dto';
+import { CoreCrudService } from '../services/core-crud.service';
+import { ParentEntity } from '../entities/parent.entity';
+
+export class CoreCrudController<
+  T extends ParentEntity,
+  CreateDto,
+  UpdateDto,
+  ResponseDto extends BaseResponseWithActionDates,
+> {
+  protected constructor(
+    protected readonly coreService: CoreCrudService<T, CreateDto, UpdateDto>,
+    protected readonly responseDto: any,
+  ) {}
+
+  async findAll(
+    @Paginate() query: PaginationQueryCustom,
+    paginateConfig: PaginateConfig<T>,
+  ): Promise<Paginated<T>> {
+    const response = await this.coreService.findAllWithPagination(
+      query,
+      paginateConfig,
+    );
+    if (!response) throw new NotFoundException(SharedMessages.FETCH_FAILED);
+
+    response.data = response.data.map((item) => new this.responseDto(item));
+    return response;
+  }
+
+  async findOneById(id: number): Promise<SuccessResponse<ResponseDto>> {
+    const response = await this.coreService.findOneById(id);
+    if (!response)
+      throw new NotFoundException(SharedMessages.RESOURCE_NOT_FOUND);
+
+    return new SuccessResponse<ResponseDto>(
+      new this.responseDto(response),
+      SharedMessages.SUCCESSFUL,
+      HttpStatus.OK,
+    );
+  }
+
+  async create(createDto: CreateDto): Promise<SuccessResponse<ResponseDto>> {
+    const response = await this.coreService.create(createDto);
+    if (!response) throw new BadRequestException(SharedMessages.CREATE_FAILED);
+
+    return new SuccessResponse<ResponseDto>(
+      new this.responseDto(response),
+      SharedMessages.SUCCESSFUL,
+      HttpStatus.CREATED,
+    );
+  }
+
+  async update(
+    { id }: IdDto,
+    updateDto: UpdateDto,
+  ): Promise<SuccessResponse<ResponseDto>> {
+    const response = await this.coreService.update(id, updateDto);
+    if (!response) throw new BadRequestException(SharedMessages.UPDATE_FAILED);
+
+    const foundItem = await this.coreService.findOneById(id);
+    return new SuccessResponse<ResponseDto>(
+      new this.responseDto(foundItem),
+      SharedMessages.SUCCESSFUL,
+      HttpStatus.OK,
+    );
+  }
+
+  async delete({ id }: IdDto): Promise<SuccessResponse<void>> {
+    const result = await this.coreService.deleteById(id);
+    if (!result) throw new BadRequestException(SharedMessages.DELETE_FAILED);
+
+    return new SuccessResponse<void>(
+      undefined,
+      SharedMessages.SUCCESSFUL,
+      HttpStatus.OK,
+    );
+  }
+
+  async softDelete({ id }: IdDto): Promise<SuccessResponse<void>> {
+    const result = await this.coreService.softDeleteById(id);
+    if (!result) throw new BadRequestException(SharedMessages.DELETE_FAILED);
+
+    return new SuccessResponse<void>(
+      undefined,
+      SharedMessages.SUCCESSFUL,
+      HttpStatus.OK,
+    );
+  }
+}

package/common/controllers/index.ts

@@ -0,0 +1 @@
+export * from './core-crud.controller';

package/common/decorators/entity-order.decorator.ts

@@ -0,0 +1,19 @@
+const ORDER_KEY = Symbol.for('order_key');
+export function Order(value: number): PropertyDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(ORDER_KEY, value, target, propertyKey);
+  };
+}
+
+export function getOrder(
+  target: unknown,
+  propertyKey: string | symbol,
+  defaultVal = 0,
+) {
+  const result = Reflect.getMetadata(ORDER_KEY, target, propertyKey);
+  if (typeof result === 'number') {
+    return result;
+  }
+
+  return defaultVal;
+}

package/common/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from './validations';
+export * from './swagger-api-response.decorator';

package/common/decorators/swagger-api-response.decorator.ts

@@ -0,0 +1,30 @@
+import { applyDecorators } from '@nestjs/common';
+import { getSchemaPath } from '@nestjs/swagger';
+import { SuccessResponse } from '../dto/response/success-response.dto';
+import { ApiResponse } from '@nestjs/swagger';
+
+export function CustomApiResponse(options: {
+  status: number;
+  description: string;
+  responseDto: any;
+}) {
+  // Return a function that NestJS will call to apply the decorator
+  return function (target: any, key?: string, descriptor?: PropertyDescriptor) {
+    // Use applyDecorators to handle combining with other potential decorators
+    return applyDecorators(
+      ApiResponse({
+        status: options.status, // Typically CREATED status
+        description: options.description,
+        schema: {
+          $ref: getSchemaPath(SuccessResponse),
+          type: 'object',
+          properties: {
+            data: {
+              $ref: getSchemaPath(options.responseDto),
+            },
+          },
+        },
+      }),
+    )(target, key, descriptor);
+  };
+}

package/common/decorators/validations/default/array-max-size.decorator.ts

@@ -0,0 +1,9 @@
+import { ArrayMaxSize as arrayMaxSize } from 'class-validator';
+
+export function ArrayMaxSize(length: number): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    arrayMaxSize(length, {
+      message: 'validation.ARRAY_MAX_SIZE',
+    })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/array-min-size.decorator.ts

@@ -0,0 +1,9 @@
+import { ArrayMinSize as arrayMinSize } from 'class-validator';
+
+export function ArrayMinSize(length: number): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    arrayMinSize(length, {
+      message: 'validation.ARRAY_MIN_SIZE',
+    })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/array-not-empty.decorator.ts

@@ -0,0 +1,7 @@
+import { ArrayNotEmpty as arrayNotEmpty } from 'class-validator';
+
+export function ArrayNotEmpty(): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    arrayNotEmpty({ message: 'validation.NOT_EMPTY' })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/index.ts

@@ -0,0 +1,20 @@
+export * from './is-string.decorator';
+export * from './is-not-empty.decorator';
+export * from './min-length.decorator';
+export * from './max-length.decorator';
+export * from './is-enum.decorator';
+export * from './is-int.decorator';
+export * from './is-positive.decorator';
+export * from './min.decorator';
+export * from './max.decorator';
+export * from './is-array.decorator';
+export * from './matches.decorator';
+export * from './is-number-string.decorator';
+export * from './is-boolean.decorator';
+export * from './is-uuid.decorator';
+export * from './is-object.decorator';
+export * from './is-date.decorator';
+export * from './array-not-empty.decorator';
+export * from './array-min-size.decorator';
+export * from './array-max-size.decorator';
+export * from './is-not-empty-object.decorator';

package/common/decorators/validations/default/is-array.decorator.ts

@@ -0,0 +1,7 @@
+import { IsArray as isArray } from 'class-validator';
+
+export function IsArray(): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isArray({ message: 'validation.ARRAY' })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/is-boolean.decorator.ts

@@ -0,0 +1,10 @@
+import { IsBoolean as isBoolean } from 'class-validator';
+
+export function IsBoolean(options?: { each?: boolean }): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isBoolean(Object.assign({ message: 'validation.BOOLEAN' }, options))(
+      target,
+      propertyKey,
+    );
+  };
+}

package/common/decorators/validations/default/is-date.decorator.ts

@@ -0,0 +1,10 @@
+import { IsDate as isDate } from 'class-validator';
+
+export function IsDate(options?: { each?: boolean }): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isDate(Object.assign({ message: 'validation.DATE' }, options))(
+      target,
+      propertyKey,
+    );
+  };
+}

package/common/decorators/validations/default/is-enum.decorator.ts

@@ -0,0 +1,9 @@
+import { IsEnum as isEnum } from 'class-validator';
+
+export function IsEnum(value: any): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isEnum(value, {
+      message: 'validation.ENUM',
+    })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/is-int.decorator.ts

@@ -0,0 +1,10 @@
+import { IsInt as isInt } from 'class-validator';
+
+export function IsInt(options?: { each?: boolean }): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isInt(Object.assign({ message: 'validation.INT' }, options))(
+      target,
+      propertyKey,
+    );
+  };
+}

package/common/decorators/validations/default/is-not-empty-object.decorator.ts

@@ -0,0 +1,15 @@
+import { IsNotEmptyObject as isNotEmptyObject } from 'class-validator';
+
+export function IsNotEmptyObject(
+  params: {
+    nullable?: boolean;
+  },
+  options?: { each?: boolean },
+): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isNotEmptyObject(params, {
+      ...options,
+      message: 'validation.IS_NOT_EMPTY_OBJECT',
+    })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/is-not-empty.decorator.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty as isNotEmpty } from 'class-validator';
+
+export function IsNotEmpty(): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isNotEmpty({ message: 'validation.NOT_EMPTY' })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/is-number-string.decorator.ts

@@ -0,0 +1,12 @@
+import { IsNumberString as isNumberString } from 'class-validator';
+
+export function IsNumberString(options?: {
+  each?: boolean;
+}): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isNumberString(
+      {},
+      Object.assign({ message: 'validation.NUMBER_STRING' }, options),
+    )(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/is-object.decorator.ts

@@ -0,0 +1,7 @@
+import { ValidationOptions, IsObject as isObject } from 'class-validator';
+
+export function IsObject(options?: ValidationOptions): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isObject({ ...options, message: 'validation.OBJECT' })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/is-positive.decorator.ts

@@ -0,0 +1,10 @@
+import { IsPositive as isPositive } from 'class-validator';
+
+export function IsPositive(options?: { each?: boolean }): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isPositive(Object.assign({ message: 'validation.POSITIVE' }, options))(
+      target,
+      propertyKey,
+    );
+  };
+}

package/common/decorators/validations/default/is-string.decorator.ts

@@ -0,0 +1,8 @@
+import { IsString as isString } from 'class-validator';
+
+export function IsString(options?: { each?: boolean }): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    const each = (options && options.each) || false;
+    isString({ each, message: 'validation.STRING' })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/is-uuid.decorator.ts

@@ -0,0 +1,7 @@
+import { IsUUID as isUUID } from 'class-validator';
+
+export function IsUUID(options?: { each?: boolean }): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    isUUID(4, options)(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/matches.decorator.ts

@@ -0,0 +1,13 @@
+import { Matches as matches } from 'class-validator';
+
+export function Matches(
+  pattern,
+  options?: { each?: boolean },
+): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    matches(pattern, Object.assign({ message: 'validation.PATTERN' }, options))(
+      target,
+      propertyKey,
+    );
+  };
+}

package/common/decorators/validations/default/max-length.decorator.ts

@@ -0,0 +1,9 @@
+import { MaxLength as maxLength } from 'class-validator';
+
+export function MaxLength(length: number): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    maxLength(length, {
+      message: 'validation.MAX_LENGTH',
+    })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/max.decorator.ts

@@ -0,0 +1,13 @@
+import { Max as max } from 'class-validator';
+
+export function Max(
+  value: number,
+  options?: { each?: boolean },
+): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    max(value, Object.assign({ message: 'validation.MAX' }, options))(
+      target,
+      propertyKey,
+    );
+  };
+}

package/common/decorators/validations/default/min-length.decorator.ts

@@ -0,0 +1,9 @@
+import { MinLength as minLength } from 'class-validator';
+
+export function MinLength(length: number): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    minLength(length, {
+      message: 'validation.MIN_LENGTH',
+    })(target, propertyKey);
+  };
+}

package/common/decorators/validations/default/min.decorator.ts

@@ -0,0 +1,13 @@
+import { Min as min } from 'class-validator';
+
+export function Min(
+  value: number,
+  options?: { each?: boolean },
+): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    min(value, Object.assign({ message: 'validation.MIN' }, options))(
+      target,
+      propertyKey,
+    );
+  };
+}

package/common/decorators/validations/index.ts

@@ -0,0 +1,3 @@
+export * from './default';
+export * from './is-id.decorator';
+export * from './is-not-empty-string.decorator';

package/common/decorators/validations/is-id.decorator.ts

@@ -0,0 +1,20 @@
+import { IsOptional } from 'class-validator';
+import { IsInt, IsNotEmpty, IsPositive, Max } from './default';
+import { ValidationConstraints } from '../../constants/validation-constraints.const';
+
+export function IsId(options?: {
+  optional?: boolean;
+  each?: boolean;
+}): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    const each = (options && options.each) || false;
+    IsInt({ each })(target, propertyKey);
+    IsPositive({ each })(target, propertyKey);
+    Max(ValidationConstraints.maxIntegerValue, {
+      each,
+    })(target, propertyKey);
+
+    if (options && options.optional) IsOptional()(target, propertyKey);
+    else IsNotEmpty()(target, propertyKey);
+  };
+}

package/common/decorators/validations/is-not-empty-string.decorator.ts

@@ -0,0 +1,14 @@
+import { IsOptional } from 'class-validator';
+import { IsNotEmpty, IsString } from './default';
+
+export function CustomIsString(options?: {
+  each?: boolean;
+  optional: boolean;
+}): PropertyDecorator {
+  return function (target: any, propertyKey: string | symbol): void {
+    IsString({ each: options ? options.each : false })(target, propertyKey);
+
+    if (options && options.optional) IsOptional()(target, propertyKey);
+    else IsNotEmpty()(target, propertyKey);
+  };
+}

package/common/dto/index.ts

@@ -0,0 +1,2 @@
+export * from './request';
+export * from './response';

package/common/dto/request/base-request.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsBoolean, IsOptional } from 'class-validator';
+
+export class BaseRequest {
+  @ApiProperty({ example: false })
+  @IsBoolean()
+  @IsOptional()
+  isActive?: boolean;
+
+  metadata?: any;
+}

package/common/dto/request/event.dto.ts

@@ -0,0 +1,25 @@
+import { IsNumber, IsOptional, IsString } from 'class-validator';
+
+export class EventDto<T> {
+  @IsString()
+  @IsOptional()
+  topic?: string;
+
+  @IsString()
+  event_source: string;
+
+  @IsString()
+  @IsOptional()
+  model?: string;
+
+  @IsString()
+  @IsOptional()
+  event_key?: string;
+
+  @IsOptional()
+  data?: T;
+
+  @IsNumber()
+  @IsOptional()
+  partition?: number;
+}