src/utils/Utils.ts

   1 import Configuration from './Configuration';
   2 import { WebSocketCloseEventStatusString } from '../types/WebSocket';
   3 import { WorkerProcessType } from '../types/Worker';
   4 import crypto from 'crypto';
   5 import { v4 as uuid } from 'uuid';
   6
   7 export default class Utils {
   8   public static logPrefix(prefixString = ''): string {
   9     return new Date().toLocaleString() + prefixString;
  10   }
  11
  12   public static generateUUID(): string {
  13     return uuid();
  14   }
  15
  16   public static async sleep(milliSeconds: number): Promise<NodeJS.Timeout> {
  17     return new Promise((resolve) => setTimeout(resolve, milliSeconds));
  18   }
  19
  20   public static formatDurationMilliSeconds(duration: number): string {
  21     duration = Utils.convertToInt(duration);
  22     const hours = Math.floor(duration / (3600 * 1000));
  23     const minutes = Math.floor((duration / 1000 - (hours * 3600)) / 60);
  24     const seconds = duration / 1000 - (hours * 3600) - (minutes * 60);
  25     let hoursStr = hours.toString();
  26     let minutesStr = minutes.toString();
  27     let secondsStr = seconds.toString();
  28
  29     if (hours < 10) {
  30       hoursStr = '0' + hours.toString();
  31     }
  32     if (minutes < 10) {
  33       minutesStr = '0' + minutes.toString();
  34     }
  35     if (seconds < 10) {
  36       secondsStr = '0' + seconds.toString();
  37     }
  38     return hoursStr + ':' + minutesStr + ':' + secondsStr.substring(0, 6);
  39   }
  40
  41   public static formatDurationSeconds(duration: number): string {
  42     return Utils.formatDurationMilliSeconds(duration * 1000);
  43   }
  44
  45   public static convertToDate(value: unknown): Date {
  46     // Check
  47     if (!value) {
  48       return value as Date;
  49     }
  50     // Check Type
  51     if (!(value instanceof Date)) {
  52       return new Date(value as string);
  53     }
  54     return value;
  55   }
  56
  57   public static convertToInt(value: unknown): number {
  58     let changedValue: number = value as number;
  59     if (!value) {
  60       return 0;
  61     }
  62     if (Number.isSafeInteger(value)) {
  63       return value as number;
  64     }
  65     // Check
  66     if (Utils.isString(value)) {
  67       // Create Object
  68       changedValue = parseInt(value as string);
  69     }
  70     return changedValue;
  71   }
  72
  73   public static convertToFloat(value: unknown): number {
  74     let changedValue: number = value as number;
  75     if (!value) {
  76       return 0;
  77     }
  78     // Check
  79     if (Utils.isString(value)) {
  80       // Create Object
  81       changedValue = parseFloat(value as string);
  82     }
  83     return changedValue;
  84   }
  85
  86   public static convertToBoolean(value: unknown): boolean {
  87     let result = false;
  88     // Check boolean
  89     if (value) {
  90       // Check the type
  91       if (typeof value === 'boolean') {
  92         // Already a boolean
  93         result = value;
  94       } else {
  95         // Convert
  96         result = (value === 'true');
  97       }
  98     }
  99     return result;
 100   }
 101
 102   public static getRandomFloat(max: number, min = 0, negative = false): number {
 103     if (max < min || min < 0 || max < 0) {
 104       throw new RangeError('Invalid interval');
 105     }
 106     const randomPositiveFloat = crypto.randomBytes(4).readUInt32LE() / 0xffffffff;
 107     const sign = (negative && randomPositiveFloat < 0.5) ? -1 : 1;
 108     return sign * (randomPositiveFloat * (max - min) + min);
 109   }
 110
 111   public static getRandomInteger(max: number, min = 0): number {
 112     if (max < 0) {
 113       throw new RangeError('Invalid interval');
 114     }
 115     max = Math.floor(max);
 116     if (min) {
 117       if (max < min || min < 0) {
 118         throw new RangeError('Invalid interval');
 119       }
 120       min = Math.ceil(min);
 121       return Math.floor(Utils.secureRandom() * (max - min + 1)) + min;
 122     }
 123     return Math.floor(Utils.secureRandom() * (max + 1));
 124   }
 125
 126   public static roundTo(numberValue: number, scale: number): number {
 127     const roundPower = Math.pow(10, scale);
 128     return Math.round(numberValue * roundPower) / roundPower;
 129   }
 130
 131   public static truncTo(numberValue: number, scale: number): number {
 132     const truncPower = Math.pow(10, scale);
 133     return Math.trunc(numberValue * truncPower) / truncPower;
 134   }
 135
 136   public static getRandomFloatRounded(max: number, min = 0, scale = 2): number {
 137     if (min) {
 138       return Utils.roundTo(Utils.getRandomFloat(max, min), scale);
 139     }
 140     return Utils.roundTo(Utils.getRandomFloat(max), scale);
 141   }
 142
 143   public static getRandomFloatFluctuatedRounded(staticValue: number, fluctuationPercent: number, scale = 2): number {
 144     if (fluctuationPercent === 0) {
 145       return Utils.roundTo(staticValue, scale);
 146     }
 147     const fluctuationRatio = fluctuationPercent / 100;
 148     return Utils.getRandomFloatRounded(staticValue * (1 + fluctuationRatio), staticValue * (1 - fluctuationRatio), scale);
 149   }
 150
 151   public static cloneObject<T>(object: T): T {
 152     return JSON.parse(JSON.stringify(object)) as T;
 153   }
 154
 155   public static isIterable<T>(obj: T): boolean {
 156     if (obj) {
 157       return typeof obj[Symbol.iterator] === 'function';
 158     }
 159     return false;
 160   }
 161
 162   public static isString(value: unknown): boolean {
 163     return typeof value === 'string';
 164   }
 165
 166   public static isUndefined(value: unknown): boolean {
 167     return typeof value === 'undefined';
 168   }
 169
 170   public static isNullOrUndefined(value: unknown): boolean {
 171     // eslint-disable-next-line no-eq-null, eqeqeq
 172     if (value == null) {
 173       return true;
 174     }
 175     return false;
 176   }
 177
 178   public static isEmptyArray(object: unknown): boolean {
 179     if (!object) {
 180       return true;
 181     }
 182     if (Array.isArray(object) && object.length > 0) {
 183       return false;
 184     }
 185     return true;
 186   }
 187
 188   public static isEmptyObject(obj: Record<string, unknown>): boolean {
 189     return !Object.keys(obj).length;
 190   }
 191
 192   public static insertAt = (str: string, subStr: string, pos: number): string => `${str.slice(0, pos)}${subStr}${str.slice(pos)}`;
 193
 194   /**
 195    * @param [retryNumber=0]
 196    * @returns delay in milliseconds
 197    */
 198   public static exponentialDelay(retryNumber = 0): number {
 199     const delay = Math.pow(2, retryNumber) * 100;
 200     const randomSum = delay * 0.2 * Utils.secureRandom(); // 0-20% of the delay
 201     return delay + randomSum;
 202   }
 203
 204   /**
 205    * Convert websocket error code to human readable string message
 206    *
 207    * @param code websocket error code
 208    * @returns human readable string message
 209    */
 210   public static getWebSocketCloseEventStatusString(code: number): string {
 211     if (code >= 0 && code <= 999) {
 212       return '(Unused)';
 213     } else if (code >= 1016) {
 214       if (code <= 1999) {
 215         return '(For WebSocket standard)';
 216       } else if (code <= 2999) {
 217         return '(For WebSocket extensions)';
 218       } else if (code <= 3999) {
 219         return '(For libraries and frameworks)';
 220       } else if (code <= 4999) {
 221         return '(For applications)';
 222       }
 223     }
 224     if (!Utils.isUndefined(WebSocketCloseEventStatusString[code])) {
 225       return WebSocketCloseEventStatusString[code] as string;
 226     }
 227     return '(Unknown)';
 228   }
 229
 230   public static workerPoolInUse(): boolean {
 231     return [WorkerProcessType.DYNAMIC_POOL, WorkerProcessType.STATIC_POOL].includes(Configuration.getWorkerProcess());
 232   }
 233
 234   public static workerDynamicPoolInUse(): boolean {
 235     return Configuration.getWorkerProcess() === WorkerProcessType.DYNAMIC_POOL;
 236   }
 237
 238   /**
 239    * Generate a cryptographically secure random number in the [0,1[ range
 240    *
 241    * @returns
 242    */
 243   public static secureRandom(): number {
 244     return crypto.randomBytes(4).readUInt32LE() / 0x100000000;
 245   }
 246 }