gemcap-be-common 1.1.2 → 1.1.3

package/helpers/date.helper.ts

@@ -0,0 +1,67 @@
+import dayjs, { OpUnitType, QUnitType } from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+export const defaultDateFormat = 'MM-DD-YYYY';
+
+export const normalizeDate = (date: Date, type: 'start' | 'end'): Date => {
+  return type === 'start'
+    ? dayjs(date).utc().startOf('day').toDate()
+    : dayjs(date).utc().endOf('day').toDate();
+};
+
+export const convertAnyToDate = (date: any): Date | null => {
+  let result = null;
+  if (!date) {
+    result = null;
+  }
+  if (date instanceof Date) {
+    result = date;
+  }
+  if (date.toString().match(/\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)/)) {
+    result = new Date(date.slice(0, -1));
+  }
+  return result;
+};
+
+export const dateLessThan = (date: Date, compare: number, unit: QUnitType | OpUnitType) => {
+  const currentDate = dayjs();
+  const nextDate = dayjs(new Date(date));
+  const difference = currentDate.diff(nextDate, unit);
+  return difference < compare;
+};
+
+export const formatDate = (date: Date): string => {
+  return dayjs(date).format(defaultDateFormat);
+};
+
+export const calculateTimeZone = (date: Date): Date => {
+  if (date instanceof Date) {
+    return dayjs(date).subtract(date.getTimezoneOffset(), 'minute').toDate();
+  }
+  return date;
+};
+
+export const convertToDefaultFormat = (date: Date) => {
+  return dayjs(date).format(defaultDateFormat);
+};
+
+export const excelDateToJSDate = (serial: number) => {
+  const utcDays = Math.floor(serial - 25569);
+  const utcValue = utcDays * 86400;
+  const dateInfo = new Date(utcValue * 1000);
+  const fractionalDay = serial - Math.floor(serial) + 0.0000001;
+  let totalSeconds = Math.floor(86400 * fractionalDay);
+  const seconds = totalSeconds % 60;
+  totalSeconds -= seconds;
+  const hours = Math.floor(totalSeconds / (60 * 60));
+  const minutes = Math.floor(totalSeconds / 60) % 60;
+  return new Date(dateInfo.getFullYear(), dateInfo.getMonth(), dateInfo.getDate(), hours, minutes, seconds);
+};
+
+export const convertToFormat = (date: Date, format: string) => {
+  return dayjs(date).format(format);
+};

package/helpers/enums.helper.d.ts

@@ -0,0 +1,3 @@
+export declare const getEnumKeyByEnumValue: <T extends {
+    [index: string]: string | number;
+}>(myEnum: T, enumValue: string) => keyof T;

package/helpers/enums.helper.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumKeyByEnumValue = void 0;
+var getEnumKeyByEnumValue = function (myEnum, enumValue) {
+    var keys = Object.keys(myEnum).filter(function (x) { return myEnum[x] == enumValue; });
+    return keys.length > 0 ? keys[0] : null;
+};
+exports.getEnumKeyByEnumValue = getEnumKeyByEnumValue;

package/helpers/enums.helper.ts

@@ -0,0 +1,4 @@
+export const getEnumKeyByEnumValue = <T extends { [index: string]: string | number }>(myEnum: T, enumValue: string): keyof T | null => {
+  let keys = Object.keys(myEnum).filter((x) => myEnum[x] == enumValue);
+  return keys.length > 0 ? keys[0] : null;
+};

package/helpers/exec.d.ts

@@ -0,0 +1 @@
+export declare const asyncExec: (command: string) => Promise<string>;

package/helpers/exec.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncExec = void 0;
+var child_process_1 = require("child_process");
+var asyncExec = function (command) {
+    return new Promise(function (resolve, reject) {
+        (0, child_process_1.exec)(command, { maxBuffer: 2048 * 2048 }, function (error, stdout, stderr) {
+            if (error) {
+                console.error({ error: error });
+                reject({ error: error, message: 'Something went wrong' });
+            }
+            resolve(stdout || stderr);
+        });
+    });
+};
+exports.asyncExec = asyncExec;

package/helpers/exec.ts

@@ -0,0 +1,13 @@
+import { exec } from 'child_process';
+
+export const asyncExec = (command: string): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    exec(command, { maxBuffer: 2048 * 2048 }, (error, stdout, stderr) => {
+      if (error) {
+        console.error({ error });
+        reject({ error, message: 'Something went wrong' });
+      }
+      resolve(stdout || stderr);
+    });
+  });
+}

package/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './common.helper';
+export * from './common.helper';
+export * from './date.helper';
+export * from './enums.helper';
+export * from './exec';
+export * from './mongo.helper';
+export * from './paginator.helper';

package/helpers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common.helper"), exports);
+__exportStar(require("./common.helper"), exports);
+__exportStar(require("./date.helper"), exports);
+__exportStar(require("./enums.helper"), exports);
+__exportStar(require("./exec"), exports);
+__exportStar(require("./mongo.helper"), exports);
+__exportStar(require("./paginator.helper"), exports);

package/helpers/index.ts

@@ -0,0 +1,7 @@
+export * from './common.helper';
+export * from './common.helper';
+export * from './date.helper';
+export * from './enums.helper';
+export * from './exec';
+export * from './mongo.helper';
+export * from './paginator.helper';

package/helpers/mongo.helper.d.ts

@@ -0,0 +1,4 @@
+import mongoose from 'mongoose';
+export declare const renameKeys: (obj: any, oldName: any, newName: any) => any;
+export declare const normalizeObject: (obj: any, oldName?: string, newName?: string) => any;
+export declare const isValidId: (id: string | mongoose.Types.ObjectId) => boolean;

package/helpers/mongo.helper.js

@@ -0,0 +1,88 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidId = exports.normalizeObject = exports.renameKeys = void 0;
+var mongoose_1 = __importDefault(require("mongoose"));
+var renameKeys = function (obj, oldName, newName) {
+    var keyValues = Object.keys(obj).map(function (key) {
+        var _a;
+        var newKey;
+        if (key === oldName) {
+            newKey = newName;
+        }
+        else {
+            newKey = key;
+        }
+        if (Array.isArray(obj[key])) {
+            obj[key] = obj[key].map(function (obj) { return (0, exports.renameKeys)(obj, oldName, newName); });
+        }
+        if ((obj[key] instanceof Object) && !(obj[key] instanceof Date) && !(obj[key] instanceof mongoose_1.default.Types.ObjectId)) {
+            obj[key] = (0, exports.renameKeys)(obj[key], oldName, newName);
+        }
+        return _a = {},
+            _a[newKey] = obj[key],
+            _a;
+    });
+    return Object.assign.apply(Object, __spreadArray([{}], keyValues, false));
+};
+exports.renameKeys = renameKeys;
+var normalizeObject = function (obj, oldName, newName) {
+    if (oldName === void 0) { oldName = '_id'; }
+    if (newName === void 0) { newName = 'id'; }
+    var keyValues = Object.keys(obj).map(function (key) {
+        var _a, _b, _c;
+        if (key === '__v') {
+            delete obj[key];
+            return;
+        }
+        var newKey;
+        if (key === oldName) {
+            newKey = newName;
+        }
+        else {
+            newKey = key;
+        }
+        if (Array.isArray(obj[key])) {
+            obj[key] = obj[key].map(function (nestedObj) { return (0, exports.normalizeObject)(nestedObj, oldName, newName); });
+            return _a = {}, _a[newKey] = obj[key], _a;
+        }
+        if ((obj[key] instanceof Object) && !(obj[key] instanceof Date) && !(obj[key] instanceof mongoose_1.default.Types.ObjectId)) {
+            obj[key] = (0, exports.normalizeObject)(obj[key], oldName, newName);
+            return _b = {}, _b[newKey] = obj[key], _b;
+        }
+        return _c = {},
+            _c[newKey] = obj[key],
+            _c;
+    });
+    return Object.assign.apply(Object, __spreadArray([{}], keyValues, false));
+};
+exports.normalizeObject = normalizeObject;
+var mongoValidator = function (id) {
+    if (mongoose_1.default.Types.ObjectId.isValid(id)) {
+        return (String)(new mongoose_1.default.Types.ObjectId(id)) === id;
+    }
+    return false;
+};
+var isValidId = function (id) {
+    if (!id) {
+        return false;
+    }
+    if (typeof id !== 'string') {
+        id = id.toString();
+    }
+    var regex = new RegExp(/^[a-f\d]{24}$/i);
+    var regexResult = regex.test(id);
+    return regexResult && mongoValidator(id);
+};
+exports.isValidId = isValidId;

package/helpers/mongo.helper.ts

@@ -0,0 +1,68 @@
+import mongoose from 'mongoose';
+
+export const renameKeys = (obj, oldName, newName) => {
+  const keyValues = Object.keys(obj).map((key) => {
+    let newKey;
+    if (key === oldName) {
+      newKey = newName;
+    } else {
+      newKey = key;
+    }
+    if (Array.isArray(obj[key])) {
+      obj[key] = obj[key].map(obj => renameKeys(obj, oldName, newName));
+    }
+    if ((obj[key] instanceof Object) && !(obj[key] instanceof Date) && !(obj[key] instanceof mongoose.Types.ObjectId)) {
+      obj[key] = renameKeys(obj[key], oldName, newName);
+    }
+    return {
+      [newKey]: obj[key]
+    };
+  });
+  return Object.assign({}, ...keyValues);
+}
+
+export const normalizeObject = (obj, oldName = '_id', newName = 'id') => {
+  const keyValues = Object.keys(obj).map((key) => {
+    if (key === '__v') {
+      delete obj[key];
+      return;
+    }
+    let newKey;
+    if (key === oldName) {
+      newKey = newName;
+    } else {
+      newKey = key;
+    }
+    if (Array.isArray(obj[key])) {
+      obj[key] = obj[key].map((nestedObj) => normalizeObject(nestedObj, oldName, newName));
+      return { [newKey]: obj[key] }
+    }
+    if ((obj[key] instanceof Object) && !(obj[key] instanceof Date) && !(obj[key] instanceof mongoose.Types.ObjectId)) {
+      obj[key] = normalizeObject(obj[key], oldName, newName);
+      return { [newKey]: obj[key] }
+    }
+    return {
+      [newKey]: obj[key]
+    };
+  });
+  return Object.assign({}, ...keyValues);
+}
+
+const mongoValidator = (id: string) => {
+  if (mongoose.Types.ObjectId.isValid(id)) {
+    return (String)(new mongoose.Types.ObjectId(id)) === id;
+  }
+  return false;
+}
+
+export const isValidId = (id: string | mongoose.Types.ObjectId) => {
+  if (!id) {
+    return false;
+  }
+  if (typeof id !== 'string') {
+    id = id.toString();
+  }
+  const regex = new RegExp(/^[a-f\d]{24}$/i);
+  const regexResult = regex.test(id);
+  return regexResult && mongoValidator(id);
+}

package/helpers/paginator.helper.d.ts

@@ -0,0 +1,2 @@
+import { IPaginatorOptions } from '../interfaces';
+export declare const getPaginator: (request: any) => IPaginatorOptions;

package/helpers/paginator.helper.js

@@ -0,0 +1,26 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaginator = void 0;
+var interfaces_1 = require("../interfaces");
+var getPaginator = function (request) {
+    var paginator = __assign({}, interfaces_1.DEFAULT_PAGINATOR);
+    if (request.pageIndex) {
+        paginator.pageIndex = +request.pageIndex;
+    }
+    if (request.pageSize) {
+        paginator.pageSize = +request.pageSize;
+    }
+    return paginator;
+};
+exports.getPaginator = getPaginator;

package/helpers/paginator.helper.ts

@@ -0,0 +1,12 @@
+import { DEFAULT_PAGINATOR, IPaginatorOptions } from '../interfaces';
+
+export const getPaginator = (request): IPaginatorOptions => {
+  const paginator = { ...DEFAULT_PAGINATOR };
+  if (request.pageIndex) {
+    paginator.pageIndex = +request.pageIndex;
+  }
+  if (request.pageSize) {
+    paginator.pageSize = +request.pageSize;
+  }
+  return paginator;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemcap-be-common",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -10,11 +10,14 @@
   "author": "Nick Elovsky",
   "license": "ISC",
   "dependencies": {
+    "dayjs": "^1.11.9",
     "express": "^4.18.2",
+    "lodash": "^4.17.21",
     "mongoose": "^6.10.5"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
+    "@types/lodash": "^4.14.196",
     "typescript": "^5.1.6"
   }
 }