@mondart/nestjs-common-module 1.0.3

package/common/dto/request/id.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsId } from '../../decorators/validations/is-id.decorator';
+
+export class IdDto {
+  @ApiProperty({ default: 1 })
+  @Type(() => Number)
+  @IsId({ optional: false })
+  id: number;
+}

package/common/dto/request/ids.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsId } from '../../decorators/validations/is-id.decorator';
+
+export class IdsDto {
+  @ApiProperty({ default: [1], isArray: true })
+  @Transform((o) => {
+    const ids = o.value.split(',');
+    return ids.map((value: string) => Number(value));
+  })
+  @IsId({ optional: false, each: true })
+  ids: number[];
+}

package/common/dto/request/index.ts

@@ -0,0 +1,4 @@
+export * from './base-request.dto';
+export * from './event.dto';
+export * from './id.dto';
+export * from './ids.dto';

package/common/dto/response/base-response-with-action-dates.dto.ts

@@ -0,0 +1,19 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { BaseResponse } from './base-response.dto';
+
+export class BaseResponseWithActionDates extends BaseResponse {
+  @ApiProperty({ type: Date })
+  public createdAt: Date;
+  @ApiProperty({ type: Date })
+  public updatedAt: Date;
+  @ApiPropertyOptional({ type: Date, default: null })
+  public deletedAt?: Date;
+
+  constructor(init: Partial<BaseResponseWithActionDates>) {
+    super(init);
+
+    this.createdAt = init?.createdAt;
+    this.updatedAt = init?.updatedAt;
+    this.deletedAt = init?.deletedAt;
+  }
+}

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

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class BaseResponse {
+  @ApiProperty({ example: 1 })
+  public id?: number;
+
+  constructor(init?: Partial<BaseResponse>) {
+    this.id = init?.id;
+  }
+}

package/common/dto/response/error-response.dto.ts

@@ -0,0 +1,22 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class BaseErrorResponse {
+  @ApiProperty({ type: String })
+  message: string;
+
+  @ApiProperty({ type: Number })
+  statusCode: number;
+
+  @ApiProperty()
+  details: Record<string, any>;
+}
+
+export class ErrorResponse extends BaseErrorResponse {
+  constructor(message: string, statusCode: number, details: any = {}) {
+    super();
+
+    this.message = message;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+}

package/common/dto/response/index.ts

@@ -0,0 +1,5 @@
+export * from './base-response-with-action-dates.dto';
+export * from './base-response.dto';
+export * from './error-response.dto';
+export * from './success-response.dto';
+export * from './validation.dto';

package/common/dto/response/kafka-success-response.dto.ts

@@ -0,0 +1,56 @@
+import { IsNumber, IsOptional, IsString } from 'class-validator';
+import { KafkaSuccessResponseInterface } from '../../interface/kafka-success-response.interfase';
+
+export class BaseEventDto<type> {
+  @IsString()
+  @IsOptional()
+  topic?: string;
+
+  @IsString()
+  event_source: string;
+
+  @IsString()
+  @IsOptional()
+  model?: string;
+
+  @IsString()
+  @IsOptional()
+  event_key?: string;
+
+  @IsOptional()
+  data?: type;
+
+  @IsNumber()
+  @IsOptional()
+  partition?: number;
+
+  @IsNumber()
+  @IsOptional()
+  status?: number;
+}
+
+export class KafkaSuccessResponse<type> extends BaseEventDto<type> {
+  constructor({
+    data,
+    event_source,
+    topic,
+    model,
+    event_key,
+    partition,
+    status,
+  }: KafkaSuccessResponseInterface<type>) {
+    super();
+
+    this.data = data;
+    this.topic = topic;
+    this.event_source = event_source;
+    this.model = model;
+    this.event_key = event_key;
+    this.partition = partition;
+    this.status = status;
+  }
+
+  public stringify() {
+    return JSON.stringify(this);
+  }
+}

package/common/dto/response/success-response.dto.ts

@@ -0,0 +1,32 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { SharedMessages } from '../../enums/shared-messages.enum';
+
+export class BaseSuccessResponse<type> {
+  @ApiProperty({ type: Object })
+  data: type;
+
+  @ApiProperty({ type: Object })
+  metadata: object;
+
+  @ApiProperty({ type: String, default: SharedMessages.SUCCESSFUL })
+  message: string;
+
+  @ApiProperty({ type: Number, default: 200 })
+  statusCode: number;
+}
+
+export class SuccessResponse<type> extends BaseSuccessResponse<type> {
+  constructor(
+    data: type,
+    message: string = null,
+    statusCode = 200,
+    metadata = null,
+  ) {
+    super();
+
+    this.data = data;
+    this.message = message;
+    this.statusCode = statusCode;
+    this.metadata = metadata;
+  }
+}

package/common/dto/response/validation.dto.ts

@@ -0,0 +1,80 @@
+import { HttpStatus, ValidationError } from '@nestjs/common';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class validationErrorMsg {
+  @ApiProperty({ type: String })
+  field: string;
+
+  @ApiProperty({ type: String })
+  message: string;
+}
+
+class ValidationMsg {
+  @ApiProperty({ type: String })
+  entity: string;
+
+  @ApiProperty({
+    type: validationErrorMsg,
+    isArray: true,
+  })
+  errors: Array<validationErrorMsg>;
+}
+
+export class ValidationErrorResponseType {
+  @ApiProperty({ type: String })
+  message: string;
+
+  @ApiProperty({ type: String })
+  statusCode: string;
+
+  @ApiProperty({ type: ValidationMsg })
+  validationMsg: ValidationMsg;
+}
+
+export class ValidationErrorResponseDto {
+  public message: string;
+  public statusCode: string;
+  public validationMsg: object;
+
+  constructor(
+    message: string,
+    error: {
+      validationErrors?: Array<ValidationError>;
+      errors?: validationErrorMsg[];
+    },
+  ) {
+    let validation =
+      error.validationErrors &&
+      error.validationErrors.map((error) => {
+        error = { ...error, ...this.formatValidationError(error) };
+
+        const field = error.property;
+
+        const message = Object.values(error.constraints)[0];
+
+        return {
+          field,
+          message,
+        };
+      });
+
+    validation = validation || error.errors;
+
+    this.message = message;
+    this.statusCode = String(HttpStatus.BAD_REQUEST);
+    this.validationMsg = {
+      errors: validation,
+    };
+  }
+
+  private formatValidationError(err: ValidationError) {
+    if (err.children.length === 0)
+      return {
+        property: err.property,
+        constraints: err.constraints,
+        children: err.children,
+      };
+
+    return this.formatValidationError(err.children[0]);
+  }
+}

package/common/entities/action-dates.entity.ts

@@ -0,0 +1,30 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Column,
+  BaseEntity,
+} from 'typeorm';
+import { Order } from '../decorators/entity-order.decorator';
+
+export class ActionDatesEntity extends BaseEntity {
+  @Order(9999)
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @Order(9999)
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @Order(9999)
+  @DeleteDateColumn()
+  deletedAt: Date;
+
+  @Order(9999)
+  @Column({ nullable: true })
+  createdBy?: string;
+
+  @Order(9999)
+  @Column({ nullable: true })
+  updatedBy?: string;
+}

package/common/entities/base.entity.ts

@@ -0,0 +1,7 @@
+import { Column } from 'typeorm';
+import { ActionDatesEntity } from './action-dates.entity';
+
+export class ParentEntity extends ActionDatesEntity {
+  @Column({ default: true })
+  isActive: boolean;
+}

package/common/entities/index.ts

@@ -0,0 +1,2 @@
+export * from './action-dates.entity';
+export * from './base.entity';

package/common/entities/parent.entity.ts

@@ -0,0 +1,35 @@
+import {
+  BaseEntity,
+  Column,
+  DataSource,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import { ActionDatesEntity } from './action-dates.entity';
+import { getOrder, Order } from '../decorators/entity-order.decorator';
+
+export class ParentEntity extends ActionDatesEntity {
+  @Order(-1)
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Order(9998)
+  @Column({ default: true })
+  isActive: boolean;
+
+  @Order(9999)
+  @Column({ type: 'json', nullable: true })
+  metadata?: any;
+
+  static useDataSource(dataSource: DataSource) {
+    BaseEntity.useDataSource.call(this, dataSource);
+    const meta = dataSource.entityMetadatasMap.get(this);
+    if (meta != null) {
+      // reorder columns here
+      meta.columns = [...meta.columns].sort((x, y) => {
+        const orderX = getOrder((x.target as any).prototype, x.propertyName);
+        const orderY = getOrder((y.target as any).prototype, y.propertyName);
+        return orderX - orderY;
+      });
+    }
+  }
+}

package/common/enums/environments.enum.ts

@@ -0,0 +1,6 @@
+export enum Environments {
+  PRODUCTION = 'production',
+  STAGE = 'stage',
+  TEST = 'test',
+  DEVELOP = 'develop',
+}

package/common/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './environments.enum';
+export * from './environments.enum';

package/common/enums/shared-messages.enum.ts

@@ -0,0 +1,40 @@
+export enum SharedMessages {
+  // Generic errors
+  INTERNAL_SERVER_ERROR = 'Internal Server Error.',
+  NOT_IMPLEMENTED = 'This feature has not been implemented yet.',
+  RECURSIVE_CHILD = 'Some children IDs are invalid, the parent product can not be used in children, it is recursive.',
+  SUCCESSFUL = 'Operation completed successfully.',
+  IS_UNiQUE = 'Field must be unique.',
+
+  // Create (POST) specific errors
+  CREATE_FAILED = 'Failed to create: {0}.',
+  CREATE_DENIED = 'Permission denied to create: {0}.',
+
+  // Read (GET) specific errors
+  FETCH_FAILED = 'Failed to fetch: {0}.',
+  RESOURCE_NOT_FOUND = 'The requested {0} was not found.',
+  DUPLICATED_SKU = 'The SKU is reserved.',
+  DUPLICATED_CODE = 'The Code is reserved.',
+  INVALID_COMPOSITE_SUB_ITEMS = 'Composite sub items are invalid.',
+  INVALID_GROUPED_SUB_ITEMS = 'Sub items are invalid.',
+
+  // Update (PUT/PATCH) specific errors
+  UPDATE_FAILED = 'Failed to update: {0}.',
+  UPDATE_DENIED = 'Permission denied to update: {0}.',
+
+  // Upsert (PUT/PATCH) specific errors
+  UPSERT_FAILED = 'Failed to upsert: {0}.',
+  UPSERT_DENIED = 'Permission denied to upsert: {0}.',
+
+  // Delete (DELETE) specific errors
+  DELETE_FAILED = 'Failed to delete: {0}.',
+  DELETE_DENIED = 'Permission denied to delete: {0}.',
+
+  // Validation errors
+  SORT_VALIDATION_FAILED = 'Sort parameter validation failed {0}.',
+  PARAMETER_VALIDATION_FAILED = 'Parameter validation failed {0}.',
+
+  // Authentication and Authorization errors
+  UNAUTHORIZED = 'Authorization is required to access this {0}.',
+  FORBIDDEN = 'Access to this {0} is forbidden.',
+}

package/common/filters/http-exception.filter.ts

@@ -0,0 +1,74 @@
+import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Response } from 'express';
+import { ErrorResponse } from '../dto';
+import { ConfigService } from '@nestjs/config';
+import { SharedMessages } from '../enums/shared-messages.enum';
+import { KafkaContext } from '@nestjs/microservices';
+
+@Catch(HttpException)
+export class HttpExceptionFilter implements ExceptionFilter {
+  constructor(private readonly configService: ConfigService) {}
+  catch(exception: HttpException, host: ArgumentsHost) {
+    const context = host.switchToHttp();
+    const response = context.getResponse<Response>();
+    const status = exception.getStatus();
+    const result = exception.getResponse() as {
+      message: string | string[];
+      error: string | string[];
+      details: any;
+    };
+    const logger = new Logger('OrderKafkaController', { timestamp: true });
+
+    if (response instanceof KafkaContext) {
+      logger.error(result);
+
+      // TODO: add sentry for manage kafka exceptions
+    }
+    try {
+      if (status === HttpStatus.UNPROCESSABLE_ENTITY) {
+        return response.status(status).json(result);
+      } else if (status === HttpStatus.BAD_REQUEST) {
+        // if (result instanceof SharedMessages) {
+        //
+        // }
+        return response
+          .status(status)
+          .json(
+            new ErrorResponse(
+              String(result?.error),
+              status,
+              typeof result?.message === 'string'
+                ? result?.message
+                : result?.message[0],
+            ),
+          );
+      } else {
+        let message: string;
+
+        if (typeof result.message === 'string') {
+          message = result?.message;
+        } else {
+          message = result?.message[0];
+        }
+
+        return response.status(status).json(new ErrorResponse(message, status));
+      }
+    } catch (err) {
+      response
+        .status(HttpStatus.INTERNAL_SERVER_ERROR)
+        .json(
+          new ErrorResponse(
+            SharedMessages.INTERNAL_SERVER_ERROR,
+            HttpStatus.INTERNAL_SERVER_ERROR,
+          ),
+        );
+    }
+  }
+}

package/common/filters/index.ts

@@ -0,0 +1 @@
+export * from './http-exception.filter';

package/common/filters/rpc-exception.filter.ts

@@ -0,0 +1,40 @@
+import { Catch, ArgumentsHost } from '@nestjs/common';
+import { BaseRpcExceptionFilter, RpcException } from '@nestjs/microservices';
+
+@Catch(RpcException)
+export class KafkaExceptionFilter extends BaseRpcExceptionFilter {
+  catch(exception: any, host: ArgumentsHost) {
+    return super.catch(exception, host);
+  }
+}
+
+// @Catch(RpcException)
+// export class CustomRpcExceptionFilter
+//   implements RpcExceptionFilter<RpcException>
+// {
+//   catch(exception: RpcException, host: ArgumentsHost) {
+//     const ctx = host.switchToRpc();
+//     const response = ctx.getContext();
+//
+//     const status =
+//       exception instanceof HttpException
+//         ? exception.getStatus()
+//         : HttpStatus.INTERNAL_SERVER_ERROR;
+//
+//     const message = exception.message || 'Internal server error';
+//
+//     return response.send({
+//       statusCode: status,
+//       message: message,
+//     });
+//   }
+//   // catch(exception: RpcException, host: ArgumentsHost): Observable<any> {
+//   //   return throwError(() =>
+//   //     new KafkaSuccessResponse<any>({
+//   //       data: exception.getError(),
+//   //       event_source: 'product',
+//   //       status: 400,
+//   //     }).stringify(),
+//   //   );
+//   // }
+// }

package/common/helper/get-env.helper.ts

@@ -0,0 +1,3 @@
+export function env(key, defaultValue: any = null) {
+  return process?.env?.[key] ?? defaultValue;
+}

package/common/helper/get-env.ts

@@ -0,0 +1,3 @@
+export function env(key, defaultValue: any = null) {
+  return process?.env?.[key] ?? defaultValue;
+}

package/common/helper/index.ts

@@ -0,0 +1,2 @@
+export * from './get-env';
+export * from './multi-inheritance.util';

package/common/helper/message-formatter.helper.ts

@@ -0,0 +1,30 @@
+export class MessageFormatter {
+  /**
+   * Function to replace a message from the SharedMessages enum with custom arguments.
+   * @param message The message of the SharedMessages enum.
+   * @param args Custom arguments to replace placeholders in the message.
+   * @returns The formatted message.
+   */
+  static replace(message: string, ...args: any[]): string {
+    // Check if the message exists in the enum
+    if (!message) {
+      throw new Error(`Message with key ${message} does not exist.`);
+    }
+
+    // Replace placeholders in the message with provided arguments
+    if (args.length !== 0) {
+      args.forEach((arg, index) => {
+        const placeholder = `{${index}}`;
+        if (arg !== undefined && arg !== null) {
+          message = message.replace(placeholder, String(arg));
+        } else {
+          message = message.replace(placeholder, '');
+        }
+      });
+    } else {
+      message = message.replace(' {0} ', ' ');
+    }
+
+    return message;
+  }
+}

package/common/helper/multi-inheritance.helper.ts

@@ -0,0 +1,12 @@
+export const multiInheritance = (baseClass: any, extendedClasses: any[]) => {
+  extendedClasses.forEach((extendedClass) => {
+    Object.getOwnPropertyNames(extendedClass.prototype).forEach((name) => {
+      Object.defineProperty(
+        baseClass.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(extendedClass.prototype, name) ||
+          Object.create(null),
+      );
+    });
+  });
+};

package/common/helper/multi-inheritance.util.ts

@@ -0,0 +1,12 @@
+export const multiInheritance = (baseClass: any, extendedClasses: any[]) => {
+  extendedClasses.forEach((extendedClass) => {
+    Object.getOwnPropertyNames(extendedClass.prototype).forEach((name) => {
+      Object.defineProperty(
+        baseClass.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(extendedClass.prototype, name) ||
+          Object.create(null),
+      );
+    });
+  });
+};

package/common/index.ts

@@ -0,0 +1,14 @@
+export * as caching from './caching';
+export * as constants from './constants';
+export * as controllers from './controllers';
+export * as decorators from './decorators';
+export * as dto from './dto';
+export * as entities from './entities';
+export * as enums from './enums';
+export * as filters from './filters';
+export * as helper from './helper';
+export * as interfaces from './interface';
+export * as lib from './lib';
+export * as services from './services';
+export * as strategy from './strategy';
+export * as validators from './validators';

package/common/interface/core-crud-service.option.ts

@@ -0,0 +1,8 @@
+import { EntityManager } from 'typeorm';
+import { FindOptionsRelations } from 'typeorm/find-options/FindOptionsRelations';
+
+export class CoreCrudServiceOption<T> {
+  entityManager?: EntityManager;
+  relations?: FindOptionsRelations<T>;
+  existsCheck?: boolean = true;
+}

package/common/interface/custom-validation-arguments.interface.ts

@@ -0,0 +1,20 @@
+import { ValidationArguments } from 'class-validator/types/validation/ValidationArguments';
+import { ValidatorConstraintInterface } from 'class-validator/types/validation/ValidatorConstraintInterface';
+
+export interface CustomValidationArguments extends ValidationArguments {
+  constraints: CustomConstraintsInterface[];
+}
+
+export interface CustomConstraintsInterface {
+  repository: string;
+  pathToProperty?: string;
+  whereQuery?: object;
+  stringPropertyQuery?: string[];
+}
+export interface CustomValidatorConstraintInterface
+  extends ValidatorConstraintInterface {
+  validate(
+    value: any,
+    validationArguments?: CustomValidationArguments,
+  ): Promise<boolean> | boolean;
+}

package/common/interface/index.ts

@@ -0,0 +1,2 @@
+export * from './core-crud-service.option';
+export * from './core-crud-service.option';

package/common/interface/kafka-success-response.interfase.ts

@@ -0,0 +1,9 @@
+export interface KafkaSuccessResponseInterface<type> {
+  data: type;
+  event_source: string;
+  topic?: string;
+  model?: string;
+  event_key?: string;
+  partition?: number;
+  status?: number;
+}