mvc-common-toolkit 1.43.9 → 1.43.11

package/src/pkg/workflow/retry-task.ts

@@ -0,0 +1,119 @@
+import { TaskFn } from "../../interfaces";
+
+type TaskErrorHandler = (err: Error) => void | Promise<void>;
+type DoneFn<T = any> = (err: Error, data: T) => void;
+
+interface RetryTaskOptions {
+  taskName: string;
+  retryCount?: number;
+  retryIntervalInMs?: number;
+  returnOperationResult?: boolean;
+}
+
+export class RetryTask {
+  constructor(task: TaskFn, protected opts: RetryTaskOptions) {
+    this._task = task;
+    this._retryCount = opts?.retryCount || 3;
+    this._retryIntervalInMs = opts?.retryIntervalInMs || 500;
+    this._currentRetryCount = this._retryCount;
+    this.taskName = opts?.taskName;
+  }
+
+  protected _task: TaskFn;
+  protected _retryCount: number;
+  protected _currentRetryCount: number;
+  protected _retryIntervalInMs: number;
+
+  public taskName: string;
+
+  public get maxRetryCount(): number {
+    return this._retryCount;
+  }
+
+  public get retryCount(): number {
+    return this._currentRetryCount;
+  }
+
+  public get retryIntervalInMs(): number {
+    return this._retryIntervalInMs;
+  }
+
+  public async run<T = any>(
+    eachErrorHandler?: TaskErrorHandler,
+    allFailedHandler?: TaskErrorHandler
+  ): Promise<T> {
+    if (this._currentRetryCount === 0) {
+      throw new Error("retry task already run");
+    }
+
+    return new Promise(async (resolve, reject) => {
+      const doneFn = (err: Error, data: T) => {
+        if (err) {
+          reject(err);
+
+          return;
+        }
+
+        resolve(data);
+      };
+
+      this.execTask(doneFn, eachErrorHandler, allFailedHandler);
+    });
+  }
+
+  protected async execTask<T = any>(
+    done: DoneFn<T>,
+    eachErrorHandler: TaskErrorHandler,
+    allFailedHandler: TaskErrorHandler
+  ): Promise<void> {
+    // Max retry reached
+    if (this._currentRetryCount === 0) {
+      if (this.opts?.returnOperationResult) {
+        done(null, {
+          success: false,
+          message: `retry task ${this.taskName} failed after ${this.maxRetryCount} retries`,
+        } as any);
+
+        return;
+      }
+
+      const error = new Error(
+        `retry task ${this.taskName} failed after ${this.maxRetryCount} retries`
+      );
+
+      allFailedHandler?.(error);
+      done(error, null);
+
+      return;
+    }
+
+    try {
+      const result = await this._task();
+
+      // If operation result is returned
+      if (result?.success === false) {
+        throw new Error(result.message || "execution failed");
+      }
+
+      if (this.opts?.returnOperationResult && !result?.success) {
+        done(null, {
+          success: true,
+          data: result,
+        } as any);
+
+        return;
+      }
+
+      done(null, result);
+    } catch (error: any) {
+      eachErrorHandler?.(error);
+
+      setTimeout(
+        () => this.execTask(done, eachErrorHandler, allFailedHandler),
+        this.retryIntervalInMs
+      );
+    } finally {
+      this._currentRetryCount--;
+    }
+  }
+}

package/src/pkg/workflow/sync-taskqueue.ts

@@ -0,0 +1,118 @@
+import { EventEmitter } from "stream";
+
+import { PinoLogger } from "../logger";
+import { TaskQueue } from "../../interfaces";
+
+class Task {
+  protected logger = new PinoLogger();
+  public isDone = false;
+
+  constructor(
+    public name: string,
+    protected handler: any,
+    protected doneFn: any
+  ) {}
+
+  public async run() {
+    try {
+      const data = await this.handler();
+
+      this.doneFn(null, data);
+    } catch (error) {
+      this.doneFn(error);
+    } finally {
+      this.isDone = true;
+    }
+  }
+}
+
+class Queue {
+  protected logger = new PinoLogger();
+  protected eventEmitter = new EventEmitter();
+
+  public isRunning: boolean = false;
+  public tasks: Task[] = [];
+
+  protected _interval: any;
+
+  constructor(protected queueName: string) {}
+
+  public onExhausted(callback: any) {
+    this.eventEmitter.once("exhausted", callback);
+  }
+
+  protected async runNextTask(): Promise<void> {
+    try {
+      const taskToRun = this.tasks.shift();
+      if (!taskToRun) {
+        this.isRunning = false;
+
+        this.eventEmitter.emit("exhausted");
+
+        return;
+      }
+
+      // Execute the task
+      await taskToRun.run();
+
+      // Run next task
+      // Don't want to block the callstack.
+      setTimeout(this.runNextTask.bind(this), 0);
+    } catch (error: any) {
+      this.logger.error(error.message, error.stack);
+
+      setTimeout(this.runNextTask.bind(this), 0);
+    }
+  }
+
+  protected async run(): Promise<void> {
+    // The queue is running, don't start new loop
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+
+    // Task queue is exhausted. Start new loop
+    await this.runNextTask();
+  }
+
+  public add(task: Task): void {
+    this.tasks.push(task);
+
+    this.run();
+  }
+}
+
+export class SyncTaskQueue implements TaskQueue {
+  protected logger = new PinoLogger();
+  protected queueList: Map<string, Queue> = new Map();
+
+  public push<T>(queueName: string, name: string, handler: any): Promise<T> {
+    const queue = this.queueList.get(queueName) || new Queue(queueName);
+
+    return new Promise((resolve, reject) => {
+      const doneFn = (err: Error | null, data: T) => {
+        if (err) {
+          reject(err);
+
+          return;
+        }
+
+        resolve(data);
+      };
+
+      const task = new Task(name, handler, doneFn);
+
+      queue.add(task);
+
+      if (!this.queueList.has(queueName)) {
+        this.queueList.set(queueName, queue);
+
+        // Once the queue is exhausted, delete the queue to save memory
+        queue.onExhausted(() => {
+          this.queueList.delete(queueName);
+        });
+      }
+    });
+  }
+}

package/src/pkg/worksheet.utils.ts

@@ -0,0 +1,178 @@
+import { Worksheet, Cell, Row, Column } from "exceljs";
+
+import { ICellData, ICellOptions } from "../interfaces";
+
+export class WorksheetUtils {
+  protected isAlive = true;
+
+  public id: number;
+
+  constructor(protected worksheet: Worksheet) {
+    this.id = worksheet.id;
+  }
+
+  public markRemoved(): void {
+    this.isAlive = false;
+  }
+
+  public rename(newName: string): void {
+    this.worksheet.name = newName;
+  }
+
+  public setRowHeight(rowNumber: number, height: number): void {
+    const row = this.getRow(rowNumber);
+
+    row.height = height;
+  }
+
+  public setColumnSize(columnName: string, width: number): void {
+    const column = this.getColumn(columnName);
+
+    column.width = width;
+  }
+
+  public getCellByAddress(
+    rowIndexOrName: string | number,
+    colIndexOrName: string | number
+  ): Cell {
+    const targetCell = this.worksheet.getCell(rowIndexOrName, colIndexOrName);
+
+    return targetCell;
+  }
+
+  public writeCellByAddress(
+    cellAddress: string,
+    cellData: Partial<ICellData>
+  ): Cell {
+    const targetCell = this.worksheet.getCell(cellAddress);
+
+    this.writeCell(targetCell, cellData);
+
+    return targetCell;
+  }
+
+  public writeRow(
+    rowNumber: number,
+    startColumnNumber: number,
+    writeData: any[]
+  ): Row {
+    const emptyArrayWithLength = Array(startColumnNumber);
+    const rowData = emptyArrayWithLength.concat(writeData);
+    const newRow = this.worksheet.insertRow(rowNumber, rowData, "o+");
+
+    newRow.commit();
+
+    return newRow;
+  }
+
+  public duplicateRow(rowNumber: number, amount = 1, insert = true): void {
+    this.worksheet.duplicateRow(rowNumber, amount, insert);
+  }
+
+  public duplicateColumn(colIndex: number): void {
+    const columnValues = this.worksheet.getColumn(colIndex).values;
+
+    this.cutAndOptionallyAddColumns(colIndex, 0, columnValues.slice());
+  }
+
+  public cutAndOptionallyAddColumns(
+    startColIndex: number,
+    cutCount: number,
+    ...args: any[][]
+  ) {
+    return this.worksheet.spliceColumns(startColIndex, cutCount, ...args);
+  }
+
+  public mergeCells(
+    startCellName: string,
+    endCellName: string,
+    ignoreStyle?: boolean
+  ): void {
+    this.throwIfNotAlive();
+
+    return this.worksheet.mergeCells(`${startCellName}:${endCellName}`);
+  }
+
+  public getRow(rowNumber1Based: number): Row {
+    this.throwIfNotAlive();
+
+    return this.worksheet.getRow(rowNumber1Based);
+  }
+
+  public getColumn(columnName: string): Partial<Column> {
+    this.throwIfNotAlive();
+
+    return this.worksheet.getColumn(columnName);
+  }
+
+  public commit(): void {
+    this.worksheet.commit();
+  }
+
+  public getColumnData(columnName: string, startIndex = 0): any[] {
+    this.throwIfNotAlive();
+
+    const column = this.getColumn(columnName);
+    const columnValues = column.values;
+
+    if (!columnValues || !columnValues.length) {
+      return [];
+    }
+
+    return columnValues.map((i) => i.valueOf()).slice(startIndex);
+  }
+
+  public getRowData(
+    rowNumber1Based: number,
+    startColIndex = 0,
+    endColIndex: number
+  ): any[] {
+    this.throwIfNotAlive();
+
+    const row = this.getRow(rowNumber1Based);
+    const rowValues = row.values;
+
+    if (!rowValues || !rowValues.length) {
+      return [];
+    }
+
+    if (Array.isArray(rowValues)) {
+      return rowValues
+        .map((cellValue) => cellValue.valueOf())
+        .slice(startColIndex, endColIndex);
+    } else {
+      return Object.values(rowValues)
+        .map((i) => i.valueOf())
+        .slice(startColIndex, endColIndex);
+    }
+  }
+
+  protected applyOptionsToCell(cell: Cell, options?: ICellOptions): void {
+    const { style, border } = options;
+
+    if (style) {
+      cell.style = style;
+    }
+
+    if (border) {
+      cell.border = border;
+    }
+  }
+
+  protected writeCell(cell: Cell, cellData: Partial<ICellData>): void {
+    const { value, options } = cellData;
+
+    cell.value = value;
+    if (options) {
+      this.applyOptionsToCell(cell, options);
+    }
+  }
+
+  protected throwIfNotAlive(): void {
+    if (this.isAlive) {
+      return;
+    }
+
+    throw new Error("Worksheet has been destroyed.");
+  }
+}

package/src/services/audit-service.ts

@@ -0,0 +1,22 @@
+import { AuditGateway } from "../interfaces";
+import { LogObject } from "../models/audit-log";
+
+export class AuditService {
+  constructor(protected auditCarrier: AuditGateway) {}
+
+  public async emitLog(log: LogObject): Promise<any> {
+    let result = null;
+    try {
+      result = await this.auditCarrier.publish(
+        log.logId,
+        log.level,
+        log.toJSON()
+      );
+    } catch (error) {
+      console.error(`[${log.logId}]failed to emit log: ` + log.toJSON());
+      console.error(error);
+    }
+
+    return result;
+  }
+}

package/src/services/excel.service.ts

@@ -0,0 +1,103 @@
+import "core-js/modules/es.promise";
+import "core-js/modules/es.string.includes";
+import "core-js/modules/es.object.assign";
+import "core-js/modules/es.object.keys";
+import "core-js/modules/es.symbol";
+import "core-js/modules/es.symbol.async-iterator";
+import "regenerator-runtime/runtime"; // For exceljs es5 to work.
+
+import { AddWorksheetOptions, Buffer, Workbook as IWorkbook } from "exceljs";
+import * as stream from "stream";
+import { WorksheetUtils } from "../pkg/worksheet.utils";
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Workbook = require("exceljs/dist/es5/doc/workbook.js");
+
+export class ExcelService {
+  protected workbook: IWorkbook;
+  protected workSheetMap = new Map() as Map<string, WorksheetUtils>;
+
+  public async loadTemplate(templatePath: string): Promise<this> {
+    try {
+      if (!templatePath) {
+        throw new Error("Missing excel template path");
+      }
+
+      const newWorkbook = new Workbook();
+      this.workbook = await newWorkbook.xlsx.readFile(templatePath);
+
+      return this;
+    } catch (error: any) {
+      throw new Error(`Error loading excel template: ${error.message}`);
+    }
+  }
+
+  public async loadFromBuffer(buffer: Buffer): Promise<this> {
+    try {
+      if (!buffer || !buffer.byteLength) {
+        throw new Error("Excel buffer is empty!");
+      }
+
+      const newWorkbook = new Workbook();
+      this.workbook = await newWorkbook.xlsx.load(buffer);
+
+      return this;
+    } catch (error: any) {
+      throw new Error(`Error loading excel from buffer: ${error.message}`);
+    }
+  }
+
+  public addWorkSheet(
+    workSheetName: string,
+    options?: Partial<AddWorksheetOptions>
+  ): WorksheetUtils {
+    const newWorksheet = this.workbook.addWorksheet(workSheetName, options);
+    const wrappedWorksheet = new WorksheetUtils(newWorksheet);
+
+    this.workSheetMap.set(workSheetName, wrappedWorksheet);
+
+    return wrappedWorksheet;
+  }
+
+  public getWorkSheet(workSheetName: string): WorksheetUtils {
+    const worksheet = this.workbook.getWorksheet(workSheetName);
+
+    if (worksheet) {
+      const newWorkSheetUtil = new WorksheetUtils(worksheet);
+      this.workSheetMap.set(workSheetName, newWorkSheetUtil);
+
+      return newWorkSheetUtil;
+    }
+
+    return this.addWorkSheet(workSheetName);
+  }
+
+  public writeToStream(readStream: stream.Stream): Promise<void> {
+    return this.workbook.xlsx.write(readStream);
+  }
+
+  public writeToFile(path: string): Promise<void> {
+    return this.workbook.xlsx.writeFile(path);
+  }
+
+  public write(stream: stream.Stream): Promise<void> {
+    return this.writeToStream(stream);
+  }
+
+  public writeToBuffer(): Promise<Buffer> {
+    return this.workbook.xlsx.writeBuffer();
+  }
+
+  public removeWorkSheet(worksheet: WorksheetUtils): void {
+    worksheet.markRemoved();
+    return this.workbook.removeWorksheet(worksheet.id);
+  }
+
+  protected throwIfTemplateNotLoaded(): void {
+    if (this.workbook) {
+      return;
+    }
+
+    throw new Error("Template not loaded. Please load template.");
+  }
+}

package/src/services/http-service.ts

@@ -0,0 +1,71 @@
+import axios from "axios";
+
+import { PinoLogger } from "../pkg/logger";
+import { APP_ERROR, HttpMethod } from "../constants";
+import {
+  HttpRequestOption,
+  HttpService,
+  Logger,
+  OperationResult,
+} from "../interfaces";
+
+export class AxiosHttpService implements HttpService {
+  constructor(protected logger: Logger = new PinoLogger()) {}
+
+  public async send<T = any>(
+    method: HttpMethod,
+    url: string,
+    options: HttpRequestOption = {}
+  ): Promise<OperationResult<T>> {
+    let response: any;
+
+    try {
+      response = await axios.request({
+        method,
+        url,
+        headers: options.headers,
+        data: options.body,
+        params: options.query,
+        ...options,
+      });
+
+      if (response.status >= 400) {
+        return {
+          success: false,
+          httpCode: response.status,
+          data: response.data,
+        };
+      }
+
+      return {
+        success: true,
+        data: response.data,
+      };
+    } catch (error: any) {
+      const errMsg =
+        error?.message ||
+        response?.data?.message ||
+        "error sending http request";
+
+      const errDetails = response?.data?.data ||
+        response?.data || { stack: error.stack };
+      this.logger.error(errMsg, errDetails);
+
+      // Due to timeout
+      if (error?.code && error.code === APP_ERROR.HTTP_REQ_TIMEOUT) {
+        return {
+          success: false,
+          code: APP_ERROR.HTTP_REQ_TIMEOUT,
+          httpCode: 408,
+          message: "request timeout",
+        };
+      }
+
+      return {
+        success: false,
+        message: error.message,
+        data: response?.data || {},
+      };
+    }
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,8 @@
+export * from "./audit-service";
+export * from "./excel.service";
+export * from "./mailer-service";
+export * from "./kafka-service";
+export * from "./redis-service";
+export * from "./security-service";
+export * from "./http-service";
+export * from "./paginated-cache";

package/src/services/kafka-service.ts

@@ -0,0 +1,81 @@
+import { IMessageQueueService } from "../interfaces";
+import {
+  Consumer,
+  ConsumerConfig,
+  ConsumerSubscribeTopics,
+  Kafka,
+  KafkaConfig,
+  Producer,
+  ProducerConfig,
+  ConsumerRunConfig,
+  ProducerRecord,
+  TopicPartitionOffsetAndMetadata,
+} from "kafkajs";
+
+export class KafkaService implements IMessageQueueService {
+  protected _kafka: Kafka;
+
+  protected _producer: Producer;
+  protected _consumer: Consumer;
+
+  public get producer() {
+    if (!this._producer) {
+      throw new Error("producer not yet init");
+    }
+
+    return this._producer;
+  }
+
+  public get consumer() {
+    if (!this._consumer) {
+      throw new Error("consumer not yet init");
+    }
+
+    return this._consumer;
+  }
+
+  constructor(config: KafkaConfig) {
+    this._kafka = new Kafka(config);
+  }
+
+  async initProducer(config?: ProducerConfig) {
+    if (this._producer) {
+      console.warn("producer already initialized");
+
+      return;
+    }
+
+    this._producer = this._kafka.producer(config);
+
+    await this._producer.connect();
+  }
+
+  async initConsumer(config?: ConsumerConfig) {
+    if (this._consumer) {
+      console.warn("consumer already initialized");
+
+      return;
+    }
+
+    this._consumer = this._kafka.consumer(config);
+
+    await this._consumer.connect();
+  }
+
+  async listen(
+    subscribeConfig: ConsumerSubscribeTopics,
+    runConfig: ConsumerRunConfig
+  ): Promise<void> {
+    await this.consumer.subscribe(subscribeConfig);
+
+    return this.consumer.run(runConfig);
+  }
+
+  async publish(record: ProducerRecord): Promise<void> {
+    this._producer.send(record);
+  }
+
+  async commitOffsets(data: TopicPartitionOffsetAndMetadata[]): Promise<void> {
+    return this.consumer.commitOffsets(data);
+  }
+}