mvc-common-toolkit 1.43.10 → 1.44.0

package/src/pkg/referral-tree-utils.ts

@@ -0,0 +1,165 @@
+import { faker } from "@faker-js/faker";
+
+import { stringUtils } from ".";
+
+interface UserConfig {
+  rootRefCode?: string;
+  password: string;
+}
+
+interface User {
+  parentRefCode: string;
+  refCode: string;
+  password: string;
+  email: string;
+  children: User[];
+}
+
+interface NormalizedUser {
+  parentRefCode: string;
+  refCode: string;
+  password: string;
+  email: string;
+}
+
+interface ReferralTreeConfig {
+  noOfLevels: number;
+  minChildPerNode: number;
+  maxChildPerNode: number;
+  mustHaveChildPerNode: number;
+  userConfig: UserConfig;
+  passwordHasher?: (password: string) => Promise<string>;
+  refCodeGenerator?: () => string;
+  addAdditionalData?: () => Promise<Record<string, any>>;
+}
+
+const defaultRefcodeGenerator = () =>
+  stringUtils.generateRandomId().slice(10).toUpperCase();
+
+export const generateReferralTree = async (data: ReferralTreeConfig) => {
+  const {
+    maxChildPerNode,
+    minChildPerNode,
+    mustHaveChildPerNode,
+    noOfLevels,
+    userConfig,
+    passwordHasher,
+    refCodeGenerator,
+    addAdditionalData = () => {},
+  } = data;
+
+  const hashedPassword = await passwordHasher(userConfig.password);
+
+  const rootUser = await genNewUser(null, {
+    hashedPassword,
+    additionalDataGenerator: addAdditionalData,
+    refCodeGenerator: refCodeGenerator || defaultRefcodeGenerator,
+  });
+
+  const totalUsersToInsert: NormalizedUser[] = [normalizeUser(rootUser)];
+
+  let currentLayerUsers: User[] = [rootUser];
+  let totalUsersCount = currentLayerUsers.length;
+
+  for (let currentLevel = 0; currentLevel < noOfLevels; currentLevel++) {
+    const allChildUserCreated: User[] = [];
+
+    // Handle the node where the number of children is required
+    const nodeSelectedAsRequired = currentLayerUsers[0];
+    for (let i = 0; i < mustHaveChildPerNode; i++) {
+      const newUser = await genNewUser(nodeSelectedAsRequired.refCode, {
+        hashedPassword,
+        refCodeGenerator: refCodeGenerator || defaultRefcodeGenerator,
+        additionalDataGenerator: addAdditionalData,
+      });
+
+      allChildUserCreated.push(newUser);
+      nodeSelectedAsRequired.children.push(newUser);
+    }
+
+    // Handle the nodes where the number of children is within range.
+    // Exclude the first user as it's already processed
+    await Promise.all(
+      currentLayerUsers.slice(1, currentLayerUsers.length).map(async (user) => {
+        const noOfChildNodes = faker.helpers.rangeToNumber({
+          min: minChildPerNode,
+          max: maxChildPerNode,
+        });
+
+        for (let i = 0; i < noOfChildNodes; i++) {
+          const newUser = await genNewUser(user.refCode, {
+            hashedPassword,
+            refCodeGenerator: refCodeGenerator || defaultRefcodeGenerator,
+            additionalDataGenerator: addAdditionalData,
+          });
+
+          allChildUserCreated.push(newUser);
+          user.children.push(newUser);
+        }
+      })
+    );
+
+    // Move on to next layer
+    const normalizedUsers: Omit<User, "children">[] =
+      allChildUserCreated.map(normalizeUser);
+
+    totalUsersToInsert.push(...normalizedUsers);
+    currentLayerUsers = allChildUserCreated;
+    totalUsersCount += currentLayerUsers.length;
+  }
+
+  return { rootUser, totalUsersCount, totalUsersToInsert };
+};
+
+const normalizeUser = (user: User) => {
+  const cloned = JSON.parse(JSON.stringify(user));
+  delete cloned.children;
+
+  return cloned;
+};
+
+const genNewUser = async (
+  parentRefCode: string,
+  { hashedPassword, refCodeGenerator, additionalDataGenerator }
+): Promise<User> => {
+  const additionalData = await additionalDataGenerator();
+
+  return {
+    parentRefCode,
+    password: hashedPassword,
+    email: faker.internet.email().toLowerCase(),
+    children: [],
+    refCode: refCodeGenerator(),
+    ...additionalData,
+  };
+};
+
+// generateReferralTree({
+//   maxChildPerNode: 2,
+//   minChildPerNode: 1,
+//   mustHaveChildPerNode: 5,
+//   noOfLevels: 5,
+//   passwordHasher: async (data) => data,
+//   addAdditionalData: async () => {
+//     return {
+//       fullName: faker.person.fullName(),
+//     };
+//   },
+//   userConfig: {
+//     password: "12345",
+//     rootRefCode: "ABCD1234",
+//   },
+// })
+//   .then((data) => {
+//     console.log(data.totalUsersCount);
+//     fs.writeFileSync(
+//       path.resolve(__dirname, "referral_tree.json"),
+//       Buffer.from(JSON.stringify(data.rootUser))
+//     );
+
+//     fs.writeFileSync(
+//       path.resolve(__dirname, "referral_users.json"),
+//       Buffer.from(JSON.stringify(data.totalUsersToInsert))
+//     );
+//   })
+//   .catch((e) => console.error(e));

package/src/pkg/scripts/index.ts

@@ -0,0 +1 @@
+export * as luaScripts from "./lua";

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/trading-pair-helper.spec.ts

@@ -0,0 +1,146 @@
+// test/normalizePairName.spec.ts
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { normalizePairName } from "./trading-pair-helper";
+import { CRYPTO_TOKEN, STABLE_COIN } from "../constants";
+
+describe("normalizePairName (functional factory)", () => {
+  const normalize = normalizePairName(STABLE_COIN, CRYPTO_TOKEN);
+
+  it("places stable coin last when stableCoinRule = 'last' (order-agnostic input)", () => {
+    const a = normalize("USDTWVPC", {
+      stableCoinRule: "last",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    const b = normalize("WVPCUSDT", {
+      stableCoinRule: "last",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    expect(a).to.equal("wvpc/usdt");
+    expect(b).to.equal("wvpc/usdt");
+  });
+
+  it("places stable coin first when stableCoinRule = 'first'", () => {
+    const out = normalize("WVPCUSDC", {
+      stableCoinRule: "first",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    expect(out).to.equal("usdc/wvpc");
+  });
+
+  it("with stableCoinRule = 'default', uses general sort (no special placement)", () => {
+    const outAsc = normalize("WVPCUSDT", {
+      stableCoinRule: "default",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    const outDesc = normalize("WVPCUSDT", {
+      stableCoinRule: "default",
+      sortOrder: "desc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    // asc: 'usdt' < 'wvpc' lexicographically
+    expect(outAsc).to.equal("usdt/wvpc");
+    // desc: 'wvpc' > 'usdt'
+    expect(outDesc).to.equal("wvpc/usdt");
+  });
+
+  it("strips separators and is case-insensitive", () => {
+    const a = normalize("ETH/USDT", {
+      stableCoinRule: "last",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    const b = normalize("ETH|USDT", {
+      stableCoinRule: "last",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    const c = normalize("wVpCusdT", {
+      stableCoinRule: "last",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    expect(a).to.equal("eth/usdt");
+    expect(b).to.equal("eth/usdt");
+    expect(c).to.equal("wvpc/usdt");
+  });
+
+  it("handles overlapping tokens by preferring longest match (e.g., WETH vs ETH)", () => {
+    // No stable coin here, so general path + sorting
+    const outAsc = normalize("WETHETH", {
+      stableCoinRule: "default",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    const outDesc = normalize("WETHETH", {
+      stableCoinRule: "default",
+      sortOrder: "desc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    // After longest-first split → parts = ['weth','eth']; then sorted:
+    expect(outAsc).to.equal("eth/weth");
+    expect(outDesc).to.equal("weth/eth");
+  });
+
+  it("sorts non-stable pairs lexicographically based on sortOrder", () => {
+    const outAsc = normalize("BTCETH", {
+      stableCoinRule: "default",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    const outDesc = normalize("BTCETH", {
+      stableCoinRule: "default",
+      sortOrder: "desc",
+      separator: "/",
+      outputFormater: undefined as any,
+    });
+    expect(outAsc).to.equal("btc/eth");
+    expect(outDesc).to.equal("eth/btc");
+  });
+
+  it("passes the separator into the output formatter", () => {
+    const out = normalize("WVPCUSDT", {
+      stableCoinRule: "last",
+      sortOrder: "asc",
+      separator: "-",
+      outputFormater: (parts, sep) => parts.join(sep),
+    });
+    expect(out).to.equal("wvpc-usdt");
+  });
+
+  it("supports custom formatter (e.g., uppercase concatenation)", () => {
+    const out = normalize("WVPCUSDT", {
+      stableCoinRule: "last",
+      sortOrder: "asc",
+      separator: "/",
+      outputFormater: (parts) => parts.map((p) => p.toUpperCase()).join(""),
+    });
+    expect(out).to.equal("WVPCUSDT");
+  });
+
+  it("throws when no known tokens found", () => {
+    expect(() =>
+      normalize("FOOBAR", {
+        stableCoinRule: "default",
+        sortOrder: "asc",
+        separator: "/",
+        outputFormater: undefined as any,
+      })
+    ).to.throw(/does not contain crypto from list/i);
+  });
+});

package/src/pkg/trading-pair-helper.ts

@@ -0,0 +1,78 @@
+import { CRYPTO_TOKEN, STABLE_COIN } from "../constants";
+
+const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+export type PairNameFormater = (data: string[], separator: string) => string;
+
+const defaultFormatter: PairNameFormater = (data, separator) =>
+  data.join(separator);
+
+export type NormalizePairNameOptions = {
+  sortOrder?: "asc" | "desc";
+  stableCoinRule?: "first" | "last" | "default";
+  separator?: string;
+  outputFormater?: PairNameFormater;
+};
+
+export const normalizePairName = (
+  stableCoinList = STABLE_COIN,
+  cryptoList = CRYPTO_TOKEN
+) => {
+  const stableTokensLower = Object.values(stableCoinList).map((i) =>
+    i.toLowerCase()
+  );
+  const stableRe = new RegExp(`(${stableTokensLower.map(esc).join("|")})`, "i");
+
+  // Keep both raw-lower (for includes) and escaped (for regex)
+  const cryptoTokensLower = Object.values(cryptoList)
+    .map((i) => i.toLowerCase())
+    .sort((a, b) => b.length - a.length); // longest-first to avoid overlaps
+
+  const cryptoTokensEscaped = cryptoTokensLower.map(esc);
+
+  return (pairName: string, options?: NormalizePairNameOptions): string => {
+    const {
+      outputFormater = defaultFormatter,
+      sortOrder = "asc",
+      stableCoinRule = "last",
+      separator = "/",
+    } = options || {};
+
+    // strip separators and normalize case once
+    const normalized = pairName.replace(/[|/]/g, "").toLowerCase();
+    const parts: string[] = [];
+
+    // Stable-coin rule branch
+    const hasStable = stableTokensLower.some((t) => normalized.includes(t));
+    if (stableCoinRule !== "default" && hasStable) {
+      const other = normalized.replace(stableRe, ""); // remove first stable
+      const stable = normalized.replace(other, ""); // remainder is the stable
+      const ordered =
+        stableCoinRule === "first" ? [stable, other] : [other, stable];
+
+      return outputFormater(ordered, separator);
+    }
+
+    // General branch
+    for (let i = 0; i < cryptoTokensLower.length; i++) {
+      const raw = cryptoTokensLower[i];
+      if (normalized.includes(raw)) {
+        const pat = new RegExp(cryptoTokensEscaped[i], "i");
+        const remainder = normalized.replace(pat, "");
+        parts.push(raw, remainder);
+        break; // stop at first/best match
+      }
+    }
+
+    if (parts.length === 0) {
+      throw new Error("pairname does not contain crypto from list");
+    }
+
+    const ordered =
+      sortOrder === "asc"
+        ? parts.sort((a, b) => a.localeCompare(b))
+        : parts.sort((a, b) => b.localeCompare(a));
+
+    return outputFormater(ordered, separator);
+  };
+};