mvc-common-toolkit 1.43.10 → 1.44.0

package/src/pkg/encryption-helper.ts

@@ -0,0 +1,155 @@
+import {
+  randomBytes,
+  pbkdf2Sync,
+  createCipheriv,
+  createDecipheriv,
+} from "crypto";
+
+const PBKDF2_ITERATIONS = 310_000; // adjust upward over time
+const KEY_LEN = 32; // 256-bit AES key
+const IV_LEN = 12; // standard for GCM
+const SALT_LEN = 16; // at least 16 bytes
+
+interface EncryptedPayload {
+  iv: string; // hex
+  salt: string; // hex
+  ciphertext: string;
+  tag: string; // auth tag (hex)
+}
+
+interface EncryptedPayload2FA {
+  iv: string;
+  saltUser: string;
+  saltServer: string;
+  ciphertext: string;
+  tag: string;
+}
+
+/**
+ * Encrypt a UTF-8 string using password-based AES-256-GCM
+ */
+export function encrypt(text: string, password: string): EncryptedPayload {
+  const salt = randomBytes(SALT_LEN);
+  const key = pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LEN, "sha256");
+
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+
+  const ciphertext = Buffer.concat([
+    cipher.update(text, "utf8"),
+    cipher.final(),
+  ]);
+  const tag = cipher.getAuthTag();
+
+  return {
+    iv: iv.toString("hex"),
+    salt: salt.toString("hex"),
+    ciphertext: ciphertext.toString("hex"),
+    tag: tag.toString("hex"),
+  };
+}
+
+/**
+ * Decrypt payload produced by `encrypt`
+ */
+export function decrypt(payload: EncryptedPayload, password: string): string {
+  const { iv, salt, ciphertext, tag } = payload;
+
+  const key = pbkdf2Sync(
+    Buffer.from(password),
+    Buffer.from(salt, "hex"),
+    PBKDF2_ITERATIONS,
+    KEY_LEN,
+    "sha256"
+  );
+
+  const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "hex"));
+  decipher.setAuthTag(Buffer.from(tag, "hex"));
+
+  const plaintext = Buffer.concat([
+    decipher.update(Buffer.from(ciphertext, "hex")),
+    decipher.final(),
+  ]);
+
+  return plaintext.toString("utf8");
+}
+
+function deriveKey(password: string, salt: Buffer): Buffer {
+  return pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LEN, "sha256");
+}
+
+export function encryptWithTwoFactors(
+  plaintext: string,
+  userPassword: string,
+  serverSecret: string
+): EncryptedPayload2FA {
+  const saltUser = randomBytes(SALT_LEN);
+  const saltServer = randomBytes(SALT_LEN);
+
+  const userKey = deriveKey(userPassword, saltUser);
+  const serverKey = deriveKey(serverSecret, saltServer);
+
+  // Final AES key: XOR of both keys
+  const finalKey = Buffer.alloc(KEY_LEN);
+  for (let i = 0; i < KEY_LEN; i++) {
+    finalKey[i] = userKey[i] ^ serverKey[i];
+  }
+
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv("aes-256-gcm", finalKey, iv);
+
+  const ciphertext = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final(),
+  ]);
+  const tag = cipher.getAuthTag();
+
+  // Cleanup sensitive buffers
+  userKey.fill(0);
+  serverKey.fill(0);
+  finalKey.fill(0);
+
+  return {
+    iv: iv.toString("hex"),
+    saltUser: saltUser.toString("hex"),
+    saltServer: saltServer.toString("hex"),
+    ciphertext: ciphertext.toString("hex"),
+    tag: tag.toString("hex"),
+  };
+}
+
+export function decryptWithTwoFactors(
+  payload: EncryptedPayload2FA,
+  userPassword: string,
+  serverSecret: string
+): string {
+  const userKey = deriveKey(userPassword, Buffer.from(payload.saltUser, "hex"));
+  const serverKey = deriveKey(
+    serverSecret,
+    Buffer.from(payload.saltServer, "hex")
+  );
+
+  const finalKey = Buffer.alloc(KEY_LEN);
+  for (let i = 0; i < KEY_LEN; i++) {
+    finalKey[i] = userKey[i] ^ serverKey[i];
+  }
+
+  const decipher = createDecipheriv(
+    "aes-256-gcm",
+    finalKey,
+    Buffer.from(payload.iv, "hex")
+  );
+  decipher.setAuthTag(Buffer.from(payload.tag, "hex"));
+
+  const plaintext = Buffer.concat([
+    decipher.update(Buffer.from(payload.ciphertext, "hex")),
+    decipher.final(),
+  ]);
+
+  // Cleanup sensitive buffers
+  userKey.fill(0);
+  serverKey.fill(0);
+  finalKey.fill(0);
+
+  return plaintext.toString("utf8");
+}

package/src/pkg/filter-helper.spec.ts

@@ -0,0 +1,105 @@
+import { expect } from "chai";
+
+import { FILTER_OPERATOR } from "../constants";
+import { IFilter } from "../interfaces";
+import { toSimpleMongooseFilter } from "./filter-helper";
+
+describe("filter helper", () => {
+  describe("simple mongoose filter", () => {
+    it("should parse simple equal filters correctly", () => {
+      const filters: IFilter[] = [
+        {
+          field: "name",
+          operator: FILTER_OPERATOR.EQUAL,
+          value: "andy",
+        },
+        {
+          field: "email",
+          operator: FILTER_OPERATOR.EQUAL,
+          value: "andy@gmail.com",
+        },
+      ];
+
+      const parsedFilter = toSimpleMongooseFilter(filters);
+
+      expect(parsedFilter.name).to.be.equal("andy");
+      expect(parsedFilter.email).to.be.equal("andy@gmail.com");
+    });
+
+    it("should parse more complex filters correctly", () => {
+      const filters: IFilter[] = [
+        {
+          field: "name",
+          operator: FILTER_OPERATOR.INS_STARTS_WITH,
+          value: "andy",
+        },
+        {
+          field: "email",
+          operator: FILTER_OPERATOR.INS_ENDS_WITH,
+          value: "andy@gmail.com",
+        },
+        {
+          field: "age",
+          operator: FILTER_OPERATOR.IN,
+          value: [20, 30, 40],
+        },
+      ];
+
+      const parsedFilter = toSimpleMongooseFilter(filters);
+
+      expect(parsedFilter.name).to.be.deep.equal({
+        $regex: "^andy.*$",
+        $options: "i",
+      });
+
+      expect(parsedFilter.email).to.be.deep.equal({
+        $regex: ".*andy@gmail.com$",
+        $options: "i",
+      });
+
+      expect(parsedFilter.age).to.be.deep.equal([20, 30, 40]);
+    });
+
+    it("should parse OR operator correctly", () => {
+      const filters: IFilter[] = [
+        {
+          field: null,
+          operator: FILTER_OPERATOR.OR,
+          value: [
+            {
+              field: "name",
+              operator: FILTER_OPERATOR.EQUAL,
+              value: "andy",
+            },
+            {
+              field: "name",
+              operator: FILTER_OPERATOR.EQUAL,
+              value: "devstic",
+            },
+          ] as IFilter[],
+        },
+        {
+          field: "email",
+          operator: FILTER_OPERATOR.INS_LIKE,
+          value: "andy@gmail.com",
+        },
+      ];
+
+      const parsedFilter = toSimpleMongooseFilter(filters);
+
+      expect(parsedFilter.$or).to.be.deep.equal([
+        {
+          name: "andy",
+        },
+        {
+          name: "devstic",
+        },
+      ]);
+
+      expect(parsedFilter.email).to.be.deep.equal({
+        $regex: ".*andy@gmail.com.*",
+        $options: "i",
+      });
+    });
+  });
+});

package/src/pkg/filter-helper.ts

@@ -0,0 +1,139 @@
+import { FILTER_OPERATOR } from "../constants";
+import { IFilter } from "../interfaces";
+
+export const toSimpleMongooseFilter = (
+  filters: IFilter[]
+): Record<string, any> => {
+  return filters.reduce((agg, current) => {
+    switch (current.operator) {
+      case FILTER_OPERATOR.EQUAL:
+        agg[current.field] = current.value;
+
+        break;
+      case FILTER_OPERATOR.NOT_EQUAL:
+        agg[current.field] = {
+          $ne: current.value,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.NOT:
+        agg[current.field] = {
+          $ne: current.value,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.LIKE:
+        agg[current.field] = {
+          $regex: `.*${current.value}.*`,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.INS_LIKE:
+        agg[current.field] = {
+          $regex: `.*${current.value}.*`,
+          $options: "i",
+        };
+
+        break;
+
+      case FILTER_OPERATOR.STARTS_WITH:
+        agg[current.field] = {
+          $regex: `^${current.value}.*$`,
+        };
+
+        break;
+      case FILTER_OPERATOR.ENDS_WITH:
+        agg[current.field] = {
+          $regex: `.*${current.value}$`,
+        };
+
+        break;
+      case FILTER_OPERATOR.INS_STARTS_WITH:
+        agg[current.field] = {
+          $regex: `^${current.value}.*$`,
+          $options: "i",
+        };
+
+        break;
+      case FILTER_OPERATOR.INS_ENDS_WITH:
+        agg[current.field] = {
+          $regex: `.*${current.value}$`,
+          $options: "i",
+        };
+
+        break;
+      case FILTER_OPERATOR.GREATER_THAN:
+        agg[current.field] = {
+          $gt: current.value,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.GREATER_THAN_OR_EQUAL:
+        agg[current.field] = {
+          $gte: current.value,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.LESS_THAN:
+        agg[current.field] = {
+          $lt: current.value,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.LESS_THAN_OR_EQUAL:
+        agg[current.field] = {
+          $lte: current.value,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.IN:
+        agg[current.field] = current.value;
+
+        break;
+
+      case FILTER_OPERATOR.NOT_IN:
+        agg[current.field] = {
+          $nin: current.value,
+        };
+
+        break;
+
+      case FILTER_OPERATOR.OR:
+        const parsedOr =
+          current.value?.map((filterCondition: IFilter) =>
+            toSimpleMongooseFilter([filterCondition])
+          ) || [];
+
+        if (!parsedOr.length) {
+          break;
+        }
+
+        agg.$or = parsedOr;
+
+        break;
+
+      case FILTER_OPERATOR.NOR:
+        const parsedNor =
+          current.value?.map((filterCondition: IFilter) =>
+            toSimpleMongooseFilter([filterCondition])
+          ) || [];
+
+        if (!parsedNor.length) {
+          break;
+        }
+
+        agg.$nor = parsedNor;
+
+        break;
+    }
+
+    return agg;
+  }, {} as Record<string, any>);
+};

package/src/pkg/geoip-helper.ts

@@ -0,0 +1,5 @@
+import * as geoip from "geoip-country";
+
+export function lookupIp(address: string): geoip.Lookup {
+  return geoip.lookup(address);
+}

package/src/pkg/hash-helper.ts

@@ -0,0 +1,12 @@
+import * as crypto from "crypto";
+
+import jsonS = require("fast-json-stable-stringify");
+
+export const generateHashFromJSON = (data: Record<string, any>): string => {
+  if (!data || typeof data !== "object") {
+    throw new Error("Input must be a non-null object");
+  }
+
+  const jsonString = jsonS(data);
+  return crypto.createHash("sha256").update(jsonString).digest("hex");
+};

package/src/pkg/http-request-utils.ts

@@ -0,0 +1,75 @@
+export function constructUrlQueryString(
+  url: string,
+  queryStringData: any,
+  options?: { encodeUrl?: boolean }
+): string {
+  if (!queryStringData) {
+    return url;
+  }
+
+  const encoder = options?.encodeUrl
+    ? encodeURIComponent
+    : (value: any) => value;
+
+  const rawQueryString = [];
+  for (const props in queryStringData) {
+    const propValue = queryStringData[props];
+    if (propValue === undefined || propValue === null) {
+      continue;
+    }
+
+    if (typeof propValue === "object") {
+      rawQueryString.push(`${props}=${encoder(JSON.stringify(propValue))}`);
+    } else {
+      rawQueryString.push(`${props}=${encoder(propValue)}`);
+    }
+  }
+
+  return `${url}?${rawQueryString.join("&")}`;
+}
+
+const MASK_FIELDS = ["password", "secret"];
+
+export function maskSensitiveData(
+  data: any,
+  maskFields: string[] = MASK_FIELDS
+): Record<string, any> {
+  // It is a string, number, or whatever. We don't process
+  if (typeof data !== "object") {
+    return data;
+  }
+
+  // Data is an object
+  if (!Array.isArray(data)) {
+    const maskedData = Object.assign({}, data || {});
+    const keys = Object.keys(data);
+
+    keys.forEach((key) => {
+      let value = data[key];
+
+      if (!value) {
+        return;
+      }
+
+      if (typeof value === "object") {
+        value = maskSensitiveData(value, maskFields);
+
+        maskedData[key] = value;
+
+        return;
+      }
+
+      // Key is not sensitive
+      if (!maskFields.includes(key)) {
+        return;
+      }
+
+      maskedData[key] = "***";
+    });
+
+    return maskedData;
+  }
+
+  // Data is an array
+  return data.map((i) => maskSensitiveData(i, maskFields));
+}

package/src/pkg/index.ts

@@ -0,0 +1,19 @@
+export * as bcryptHelper from "./bcrypt-helper";
+export * as httpRequestUtils from "./http-request-utils";
+export * as objectHelper from "./object-helper";
+export * as queryHelper from "./query-helper";
+export * as stringUtils from "./string-utils";
+export * as worksheetUtils from "./worksheet.utils";
+export * as cryptoHelpers from "./crypto-helper";
+export * as sortHelpers from "./sort-helper";
+export * as filterHelpers from "./filter-helper";
+export * as loggers from "./logger";
+export * as workflows from "./workflow";
+export * as geoipHelpers from "./geoip-helper";
+export * as arrayHelpers from "./array-helper";
+export * as referralTreeHelpers from "./referral-tree-utils";
+export * as timeoutHelper from "./task-helper";
+export * as cacheHelper from "./paginated-cache-registry";
+export * as encryptionHelper from "./encryption-helper";
+export * as scripts from "./scripts";
+export * as tradingPairHelper from "./trading-pair-helper";

package/src/pkg/key-helper.ts

@@ -0,0 +1,20 @@
+const versionPlaceholder = '_version';
+
+// Helper functions for versioned cache keys
+export const getVersionedCacheKey = (key: string, version: number) => {
+  if (key.includes(versionPlaceholder)) {
+    return key.replace(versionPlaceholder, version.toString());
+  }
+
+  return `${key}:version:${version}`;
+};
+
+export const getVersionCacheKeyForKey = (key: string) => {
+  if (key.includes(versionPlaceholder)) {
+    const indexOfPlaceholder = key.indexOf(versionPlaceholder);
+
+    return key.substring(0, indexOfPlaceholder);
+  }
+
+  return `${key}:version`;
+};

package/src/pkg/logger.ts

@@ -0,0 +1,23 @@
+import pino from "pino";
+
+import { Logger } from "../interfaces";
+
+export class PinoLogger implements Logger {
+  protected _logger: pino.Logger;
+
+  constructor() {
+    this._logger = pino();
+  }
+
+  public info(message: string, ...args: any[]): void {
+    return this._logger.info(message, ...args);
+  }
+
+  public error(message: string, ...args: any[]): void {
+    return this._logger.error(message, ...args);
+  }
+
+  public warn(message: string, ...args: any[]): void {
+    return this._logger.warn(message, ...args);
+  }
+}

package/src/pkg/object-helper.ts

@@ -0,0 +1,42 @@
+export function removeUndefinedProps(data: any): any {
+  const allKeys = Object.keys(data);
+
+  return allKeys.reduce((aggregated, current) => {
+    if (data[current] !== undefined) {
+      aggregated[current] = data[current];
+    }
+
+    return aggregated;
+  }, {});
+}
+
+export const tryParseStringIntoCorrectData = (data: string): any => {
+  if (!data?.length) {
+    return;
+  }
+
+  try {
+    // Parse boolean
+    if (data === "true") {
+      return true;
+    }
+
+    if (data === "false") {
+      return false;
+    }
+
+    // Parse number
+    const dataAsNumber = Number(data);
+
+    if (!Number.isNaN(dataAsNumber)) {
+      return dataAsNumber;
+    }
+
+    // Parse object
+    const parsedObject = JSON.parse(data);
+
+    return parsedObject;
+  } catch (error) {
+    return data;
+  }
+};

package/src/pkg/paginated-cache-registry.ts

@@ -0,0 +1,25 @@
+import { CacheService, IPaginatedDataCache } from "../interfaces";
+import { PaginatedDataCache } from "../services/paginated-cache";
+
+export class PaginatedCacheRegistry {
+  protected _registry = new Map<string, IPaginatedDataCache>();
+
+  constructor(protected cacheService: CacheService) {}
+
+  public has(dataName: string): boolean {
+    return this._registry.has(dataName);
+  }
+
+  public getOrCreatePaginatedCache<T = any>(
+    dataName: string
+  ): IPaginatedDataCache<T> {
+    if (this._registry.has(dataName)) {
+      return this._registry.get(dataName);
+    }
+
+    const service = new PaginatedDataCache(dataName, this.cacheService);
+    this._registry.set(dataName, service);
+
+    return service;
+  }
+}

package/src/pkg/query-helper.ts

@@ -0,0 +1,79 @@
+import { FILTER_OPERATOR } from "../constants";
+import { IFilter, ISort } from "../interfaces";
+
+/**
+ * Parses a sort data such as "-price name date" into an array of generic sort data
+ * @param data the sort string
+ * @returns ISort[]
+ */
+export function parseSort(data: string): ISort[] {
+  if (!data) {
+    return [];
+  }
+
+  const sortConditions: ISort[] = data.split(" ").map((item) => {
+    if (item[0] === "-") {
+      return {
+        columnName: item.slice(1, item.length - 1),
+        direction: "DESC",
+      };
+    }
+
+    return {
+      columnName: item,
+      direction: "ASC",
+    };
+  });
+
+  return sortConditions;
+}
+
+/**
+ * Parses filter expression for a field name
+ * @param field The fieldname in query string ?email=
+ * @param filterData The filter expression. Ex: eq:123 lt:100 gt:400
+ * @returns IFilter
+ */
+export function parseFilter(field: string, filterData: string): IFilter {
+  if (!filterData) {
+    throw new Error("missing filter data");
+  }
+
+  const splittedData = filterData.split(":");
+  if (splittedData.length === 1) {
+    return {
+      field,
+      operator: FILTER_OPERATOR.EQUAL,
+      value: splittedData[0],
+    };
+  }
+
+  if (splittedData.length === 2) {
+    const [operator, value] = splittedData;
+
+    if (!Object.keys(FILTER_OPERATOR).includes(operator)) {
+      throw new Error(`invalid filter operator ${operator}`);
+    }
+
+    if (operator === FILTER_OPERATOR.OR || operator === FILTER_OPERATOR.AND) {
+      throw new Error("operator $or and $and are only for internal use");
+    }
+
+    if (
+      operator === FILTER_OPERATOR.IN ||
+      operator === FILTER_OPERATOR.NOT_IN
+    ) {
+      return {
+        field,
+        operator: operator as FILTER_OPERATOR,
+        value: value.split(","),
+      };
+    }
+
+    return {
+      field,
+      operator: operator as FILTER_OPERATOR,
+      value,
+    };
+  }
+}