mvc-common-toolkit 1.43.9 → 1.43.11

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,18 @@
+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";

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

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";