mvc-common-toolkit 1.43.9 → 1.43.11

package/src/pkg/scripts/lua.ts

@@ -0,0 +1,112 @@
+export const IncrByAndSetTTLIfNotExists = `
+if redis.call("EXISTS", KEYS[1]) == 0 then
+  redis.call("INCRBY", KEYS[1], ARGV[1])
+  redis.call("EXPIRE", KEYS[1], ARGV[2])
+end
+
+return redis.call("GET", KEYS[1])
+`;
+
+export const IncrByAndEnsureTTLIsSet = `
+local inc  = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+
+redis.call("INCRBY", KEYS[1], inc)
+
+if redis.call("TTL", KEYS[1]) == -1 then
+  redis.call("EXPIRE", KEYS[1], ttl)
+end
+
+return tonumber(redis.call("GET", KEYS[1]))
+`;
+export const DecrByAndEnsureTTLIsSet = `
+local inc  = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+
+redis.call("DECRBY", KEYS[1], inc)
+
+if redis.call("TTL", KEYS[1]) == -1 then
+  redis.call("EXPIRE", KEYS[1], ttl)
+end
+
+return tonumber(redis.call("GET", KEYS[1]))
+`;
+export const IncrByFloatAndEnsureTTLIsSet = `
+local inc  = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+
+redis.call("INCRBYFLOAT", KEYS[1], inc)
+
+if redis.call("TTL", KEYS[1]) == -1 then
+  redis.call("EXPIRE", KEYS[1], ttl)
+end
+
+return tonumber(redis.call("GET", KEYS[1]))
+`;
+
+export const IncrByIfExists = `
+if redis.call("EXISTS", KEYS[1]) == 1 then
+  redis.call("INCRBY", KEYS[1], ARGV[1])
+end
+
+return redis.call("GET", KEYS[1])
+`;
+
+export const DecrbyAndSetTTLIfNotExists = `
+if redis.call("EXISTS", KEYS[1]) == 0 then
+  redis.call("DECRBY", KEYS[1], ARGV[1])
+  redis.call("EXPIRE", KEYS[1], ARGV[2])
+end
+
+return redis.call("GET", KEYS[1])
+`;
+
+export const DecrbyIfExists = `
+if redis.call("EXISTS", KEYS[1]) == 1 then
+  redis.call("DECRBY", KEYS[1], ARGV[1])
+end
+
+return redis.call("GET", KEYS[1])
+`;
+
+export const IncrByFloatAndSetTTLIfNotExists = `
+if redis.call("EXISTS", KEYS[1]) == 0 then
+  redis.call("INCRBYFLOAT", KEYS[1], ARGV[1])
+  redis.call("EXPIRE", KEYS[1], ARGV[2])
+end
+
+return redis.call("GET", KEYS[1])
+`;
+
+export const IncrByFloatIfExists = `
+if redis.call("EXISTS", KEYS[1]) == 1 then
+  redis.call("INCRBYFLOAT", KEYS[1], ARGV[1])
+end
+
+return redis.call("GET", KEYS[1])
+`;
+
+export const RefreshTTLIfBelowThreshold = `
+-- KEYS[1] : key to inspect
+-- ARGV[1] : threshold in seconds        (e.g. 10)
+-- ARGV[2] : new TTL in seconds to set   (e.g. 60)
+
+local ttl = redis.call("TTL", KEYS[1])
+
+-- ttl == -2 → key doesn’t exist
+-- ttl == -1 → key has no expiration
+if ttl == -2 then
+  return -2                           -- key absent
+end
+
+local threshold = tonumber(ARGV[1])
+local newTTL    = tonumber(ARGV[2])
+
+-- If TTL is missing (-1) or below threshold, refresh it
+if ttl == -1 or ttl < threshold then
+  redis.call("EXPIRE", KEYS[1], newTTL)
+  return newTTL                       -- return the TTL we just set
+end
+
+return ttl                             -- unchanged TTL
+`;

package/src/pkg/sort-helper.ts

@@ -0,0 +1,19 @@
+import { ISort, SORT_DIRECTION } from "../interfaces";
+
+export const toMongooseSort = (sorts: ISort[]): Record<string, number> => {
+  return sorts.reduce((agg, current) => {
+    agg[current.columnName] = current.direction === "ASC" ? 1 : -1;
+
+    return agg;
+  }, {});
+};
+
+export const toTypeOrmSort = (
+  sorts: ISort[]
+): Record<string, SORT_DIRECTION> => {
+  return sorts.reduce((agg, current) => {
+    agg[current.columnName] = current.direction;
+
+    return agg;
+  }, {});
+};

package/src/pkg/string-utils.ts

@@ -0,0 +1,104 @@
+import { createId } from "@paralleldrive/cuid2";
+
+export function generateRandomId(): string {
+  return createId();
+}
+
+export function generatePassword(length = 16): string {
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const numbers = "0123456789";
+  const symbols = "!@#$%^&*(){}|+-";
+  const all = chars + numbers + symbols;
+
+  let retVal = "";
+  retVal += chars.charAt(Math.floor(Math.random() * chars.length));
+  retVal += numbers.charAt(Math.floor(Math.random() * numbers.length));
+  retVal += symbols.charAt(Math.floor(Math.random() * symbols.length));
+
+  for (let i = 0; i < length - 3; ++i) {
+    retVal += all.charAt(Math.floor(Math.random() * all.length));
+  }
+  return retVal;
+}
+
+function escapeRegexCharacters(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function validatePasswordStrengthWithMessage(password: string): string {
+  const escapedPassword = escapeRegexCharacters(password);
+
+  if (escapedPassword.length < 8) {
+    return "Password must be at least 8 characters long";
+  }
+  if (!escapedPassword.match(/[a-z]/)) {
+    return "Password must contain at least one lowercase letter";
+  }
+  if (!escapedPassword.match(/[A-Z]/)) {
+    return "Password must contain at least one uppercase letter";
+  }
+  if (!escapedPassword.match(/[0-9]/)) {
+    return "Password must contain at least one number";
+  }
+  if (!escapedPassword.match(/[^a-zA-Z0-9]/)) {
+    return "Password must contain at least one special character";
+  }
+  return "";
+}
+
+const standardlize = (f1: string) =>
+  f1.replace(new RegExp("_", "g"), "").toLowerCase();
+
+type MaskRule = {
+  keys: string[];
+  pattern: RegExp;
+  replacer: (...groups: string[]) => string;
+};
+
+const maskRules: MaskRule[] = [
+  {
+    keys: [
+      "password",
+      "Authorization",
+      "access_token",
+      "refresh_token",
+      "signature",
+    ],
+    pattern: /^(.*)$/,
+    replacer: () => "***masked***",
+  },
+  {
+    keys: ["txid", "txnid"],
+    pattern: /^(.{10})(.*)(.{36})$/,
+    replacer: (_match, prefix, middle, suffix) =>
+      `${prefix}${"*".repeat(middle.length)}${suffix}`,
+  },
+];
+
+export const maskFn = (
+  key: string,
+  value: unknown,
+  additionalMaskRules: MaskRule[] = []
+): unknown => {
+  // Only process string values
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  const normalizedKey = standardlize(key);
+  // Merge default rules with any additional ones
+  const allRules = [...maskRules, ...additionalMaskRules];
+
+  // Find a rule whose keys match the normalized key
+  const rule = allRules.find(({ keys }) =>
+    keys.some((k) => standardlize(k) === normalizedKey)
+  );
+
+  // No matching rule? Return the original value
+  if (!rule) {
+    return value;
+  }
+
+  // Apply pattern and replacer
+  return value.replace(rule.pattern, rule.replacer);
+};

package/src/pkg/task-helper.ts

@@ -0,0 +1,25 @@
+import { TaskFn } from "../interfaces";
+
+export async function runWithTimeout<T = any>(
+  handler: TaskFn,
+  timeoutInMs: number
+): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(
+      () => reject(new Error("task timed out")),
+      timeoutInMs
+    );
+
+    handler()
+      .then((result: T) => {
+        clearTimeout(timeout);
+
+        resolve(result);
+      })
+      .catch((error: Error) => {
+        clearTimeout(timeout);
+
+        reject(error);
+      });
+  });
+}

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