mvc-common-toolkit 1.43.10 → 1.44.0

package/src/pkg/workflow/delayed-task-registry.ts

@@ -0,0 +1,54 @@
+import { DelayedTaskOps, ITask, TaskRegistry } from "../../interfaces";
+import { DelayedTask } from "./delayed-task";
+
+export class DelayedTaskRegistry implements TaskRegistry {
+  protected taskRegistry = new Map<string, ITask>();
+
+  public async register(options: DelayedTaskOps): Promise<ITask> {
+    const delayedTask = new DelayedTask(options);
+
+    this.taskRegistry.set(delayedTask.id, delayedTask);
+
+    return delayedTask;
+  }
+
+  public async count(): Promise<number> {
+    return this.taskRegistry.size;
+  }
+
+  public async getTasks(): Promise<ITask[]> {
+    return Object.values(this.taskRegistry);
+  }
+
+  public async getTaskById(id: string): Promise<ITask> {
+    return this.taskRegistry.get(id);
+  }
+
+  public async cancelTaskById(id: string): Promise<void> {
+    const task = this.taskRegistry.get(id);
+    if (!task) {
+      throw new Error(`task with id ${id} not exist`);
+    }
+
+    if (!task.isRunning) {
+      return;
+    }
+
+    await task.cancel();
+
+    this.taskRegistry.delete(id);
+  }
+
+  public async startTaskById(id: string): Promise<void> {
+    const task = this.taskRegistry.get(id);
+    if (!task) {
+      throw new Error(`task with id ${id} not exist`);
+    }
+
+    if (task.isRunning) {
+      return;
+    }
+
+    return task.start();
+  }
+}

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

@@ -0,0 +1,106 @@
+import { createId } from "@paralleldrive/cuid2";
+
+import dayjs from "dayjs";
+
+import {
+  DelayFn,
+  DelayedTaskOps,
+  ITask,
+  Subscription,
+  TaskRescheduleOps,
+} from "../../interfaces";
+
+const nativeTimeout: DelayFn = (callback, timeout) => {
+  const timeoutId = setTimeout(callback, timeout);
+
+  return {
+    async unsubscribe() {
+      clearTimeout(timeoutId);
+    },
+  };
+};
+
+export class DelayedTask implements ITask {
+  public id: string;
+  public isCron: boolean = false;
+  public isRunning: boolean = false;
+  public isCancelled: boolean = false;
+
+  protected _lastRun: Date;
+  protected subscription: Subscription;
+
+  constructor(
+    protected options: DelayedTaskOps,
+    protected delayFn: DelayFn = nativeTimeout
+  ) {
+    this.id = createId();
+
+    if (options?.startOnCreate) {
+      this._start();
+    }
+  }
+
+  protected _start(): void {
+    this.subscription = this.delayFn(() => {
+      // run the task
+      this.options.callback();
+
+      // set last run to the moment
+      this._lastRun = new Date();
+    }, this.options.timeout);
+
+    this.isRunning = true;
+  }
+
+  public cancel(): Promise<void> {
+    this.isCancelled = true;
+    this.isRunning = false;
+
+    return this.subscription.unsubscribe();
+  }
+
+  public async reschedule(options: TaskRescheduleOps): Promise<void> {
+    if (!options?.msFromNow && !options?.runTime) {
+      throw new Error("must pass either msFromNow or runTime");
+    }
+
+    await this.cancel();
+
+    if (options.msFromNow && options.runTime) {
+      throw new Error("only accept either msFromNow or runTime.");
+    }
+
+    if (options.msFromNow) {
+      this.options.timeout = options.msFromNow;
+
+      return this._start();
+    }
+
+    if (options.runTime) {
+      const timeDiff = dayjs(options.runTime).diff(new Date());
+      if (timeDiff <= 0) {
+        throw new Error("new run time must be after now");
+      }
+
+      this.options.timeout = timeDiff;
+
+      return this._start();
+    }
+  }
+
+  public async start(): Promise<void> {
+    this._start();
+  }
+
+  public async lastRun(): Promise<Date> {
+    return this._lastRun;
+  }
+
+  public async nextRun(): Promise<Date> {
+    if (!this.isRunning) {
+      return null;
+    }
+
+    return dayjs(this._lastRun).add(this.options.timeout).toDate();
+  }
+}

package/src/pkg/workflow/index.ts

@@ -0,0 +1,5 @@
+export * from "./delayed-task-registry";
+export * from "./delayed-task";
+export * from "./sync-taskqueue";
+export * from "./retry-task";
+export * from "./processing-milestone";

package/src/pkg/workflow/processing-milestone.ts

@@ -0,0 +1,54 @@
+export interface Step {
+  name?: string;
+  onFailure?: OnFailure;
+}
+
+export interface OnFailure {
+  reason: string;
+}
+
+export class SingleProcessingMilestone {
+  protected _steps: Step[];
+  protected _isFinished = false;
+
+  constructor(
+    protected pipelineName?: string,
+    protected logger?: (msg: string) => void
+  ) {}
+
+  protected throwIfEnded() {
+    if (this._isFinished) {
+      throw new Error("pipeline has already ended");
+    }
+  }
+
+  public get totalSteps(): number {
+    this.throwIfEnded();
+
+    return this._steps.length;
+  }
+
+  public addStep(name?: string, onFailure?: OnFailure): void {
+    this.throwIfEnded();
+    const stepNo = this.totalSteps + 1;
+
+    this._steps.push({
+      name: name || `step_${stepNo}`,
+      onFailure: onFailure || {
+        reason: "unknown",
+      },
+    });
+
+    if (this.pipelineName && this.logger) {
+      this.logger(`step ${stepNo} of pipeline ${this.pipelineName} reached!`);
+    }
+  }
+
+  public result(): Step {
+    this.throwIfEnded();
+
+    this._isFinished = true;
+
+    return this._steps.pop();
+  }
+}

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

@@ -0,0 +1,194 @@
+import chai from "chai";
+import chaiAsPromised from "chai-as-promised";
+
+chai.use(chaiAsPromised);
+
+const expect = chai.expect;
+
+import { RetryTask } from "./retry-task";
+
+describe("retry task", () => {
+  describe("success cases", () => {
+    it("it should resolve correct data if no error occurs", async () => {
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(() => resolve("hello world"), 100);
+        });
+
+      const data = "hello world";
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName: data,
+        returnOperationResult: true,
+      });
+
+      const result = await retryTask.run();
+
+      expect(result.success).to.exist;
+      expect(result.success).to.be.true;
+      expect(result.data).to.be.eq(data);
+    });
+
+    it("it should resolve operation result with data if no error occurs", async () => {
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(() => resolve("hello world"), 100);
+        });
+
+      const data = "hello world";
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName: data,
+      });
+
+      const result = await retryTask.run();
+
+      expect(result).to.be.eq(data);
+    });
+
+    it("it should resolve correct data if error occurs within retry count", async () => {
+      let retryCount = 0;
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(() => {
+            retryCount++;
+            retryCount === 2 ? resolve("hello world") : reject("not time yet");
+          }, 100);
+        });
+
+      const data = "hello world";
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName: data,
+        retryIntervalInMs: 300,
+      });
+
+      const result = await retryTask.run((err) => console.log(err));
+
+      expect(result).to.be.eq(data);
+    });
+
+    it("should pass if operation result is successful", async () => {
+      const data = "hello world";
+
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(
+            () =>
+              resolve({
+                success: true,
+                data,
+              }),
+            100
+          );
+        });
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName: data,
+      });
+
+      const result = await retryTask.run();
+
+      expect(result?.data).to.be.eq(data);
+    });
+  });
+
+  describe("failure cases", () => {
+    it("throws if retry count is exceeded", async () => {
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(() => reject(new Error("always fail!")), 100);
+        });
+
+      const data = "hello world";
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName: data,
+        retryIntervalInMs: 300,
+      });
+
+      await expect(retryTask.run()).to.be.rejectedWith(
+        "retry task hello world failed after 3 retries"
+      );
+    });
+
+    it("returns failed operation result if retry count is exceeded", async () => {
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(() => reject(new Error("always fail!")), 100);
+        });
+
+      const data = "hello world";
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName: data,
+        retryIntervalInMs: 300,
+        returnOperationResult: true,
+      });
+
+      const failedResult = await retryTask.run();
+      expect(failedResult.success).to.exist;
+      expect(failedResult.success).to.be.false;
+    });
+
+    it("throws if retry count is exceeded when operation result failed", async () => {
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(
+            () =>
+              resolve({
+                success: false,
+                message: "failed for some reason",
+              }),
+            100
+          );
+        });
+
+      const taskName = "hello world";
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName,
+        retryIntervalInMs: 300,
+      });
+
+      await expect(retryTask.run()).to.be.rejectedWith(
+        "retry task hello world failed after 3 retries"
+      );
+    });
+
+    it("returns failed operation result if retry count is exceeded when operation result failed", async () => {
+      const task = () =>
+        new Promise((resolve, reject) => {
+          setTimeout(
+            () =>
+              resolve({
+                success: false,
+                message: "failed for some reason",
+              }),
+            100
+          );
+        });
+
+      const taskName = "hello world";
+
+      const retryTask = new RetryTask(task, {
+        retryCount: 3,
+        taskName,
+        retryIntervalInMs: 300,
+        returnOperationResult: true,
+      });
+
+      const failedResult = await retryTask.run();
+
+      expect(failedResult.success).to.exist;
+      expect(failedResult.success).to.be.false;
+    });
+  });
+});

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);
+        });
+      }
+    });
+  }
+}