lupine.api 1.0.41

package/src/lib/utils/date-utils.ts

@@ -0,0 +1,317 @@
+export class DateUtils {
+  /*
+   * returns the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+   */
+  static now(): number {
+    return Date.now();
+  }
+
+  // Date time string format: YYYY-MM-DDTHH:mm:ss.sssZ
+  // The string that you want to parse into a Date should match this format or a portion of this format.
+  // The “T” character separates the date from the time portion of the string. The “Z” character is the UTC offset representation.
+  static toDate(str: string): Date {
+    return new Date(Date.parse(str));
+  }
+
+  static clone(dt: Date): Date {
+    return new Date(dt.valueOf());
+  }
+
+  static isLeapYear(year: number): boolean {
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+  }
+
+  static daysInMonth(year: number, month: number) {
+    return month === 1 ? (DateUtils.isLeapYear(year) ? 29 : 28) : 31 - ((month % 7) % 2);
+  }
+
+  static createDate(
+    year: number,
+    monthIndex: number,
+    date?: number,
+    hours?: number,
+    minutes?: number,
+    seconds?: number,
+    ms?: number
+  ): Date {
+    const dt = new Date(year, monthIndex, date, hours, minutes, seconds, ms);
+    return dt;
+  }
+
+  // It returns the number of milliseconds since January 1, 1970, 00:00:00 UTC instead of local (regardless of which time zone you are in).
+  static createUTCDate(
+    year: number,
+    monthIndex?: number,
+    date?: number,
+    hours?: number,
+    minutes?: number,
+    seconds?: number,
+    ms?: number
+  ): Date {
+    const dt = new Date(Date.UTC.apply(null, [year, monthIndex, date, hours, minutes, seconds, ms]));
+    return dt;
+  }
+
+  static set(
+    dt: Date,
+    year?: number,
+    monthIndex?: number,
+    date?: number,
+    hours?: number,
+    minutes?: number,
+    seconds?: number,
+    ms?: number
+  ): Date {
+    if (!dt) {
+      dt = new Date(DateUtils.now());
+    }
+    if (typeof year === 'number') {
+      dt.setFullYear(year);
+    }
+    if (typeof monthIndex === 'number') {
+      dt.setMonth(monthIndex);
+    }
+    if (typeof date === 'number') {
+      dt.setDate(date);
+    }
+    if (typeof hours === 'number') {
+      dt.setHours(hours);
+    }
+    if (typeof minutes === 'number') {
+      dt.setMinutes(minutes);
+    }
+    if (typeof seconds === 'number') {
+      dt.setSeconds(seconds);
+    }
+    if (typeof ms === 'number') {
+      dt.setMilliseconds(ms);
+    }
+    return dt;
+  }
+
+  static add(
+    dt: Date,
+    year?: number,
+    monthCount?: number,
+    date?: number,
+    hours?: number,
+    minutes?: number,
+    seconds?: number,
+    ms?: number
+  ): Date {
+    if (!dt) {
+      dt = new Date(DateUtils.now());
+    }
+    if (typeof year === 'number') {
+      dt.setFullYear(dt.getFullYear() + year);
+    }
+    if (typeof monthCount === 'number') {
+      dt.setMonth(dt.getMonth() + monthCount);
+    }
+    if (typeof date === 'number') {
+      dt.setDate(dt.getDate() + date);
+    }
+    if (typeof hours === 'number') {
+      dt.setHours(dt.getHours() + hours);
+    }
+    if (typeof minutes === 'number') {
+      dt.setMinutes(dt.getMinutes() + minutes);
+    }
+    if (typeof seconds === 'number') {
+      dt.setSeconds(dt.getSeconds() + seconds);
+    }
+    if (typeof ms === 'number') {
+      dt.setMilliseconds(dt.getMilliseconds() + ms);
+    }
+    return dt;
+  }
+
+  // returns a difference object from two dates
+  static diff(endDate: Date, startDate: Date): DiffDate {
+    const startYear = startDate.getFullYear();
+    let yearDiff = endDate.getFullYear() - startYear;
+    let monthDiff = endDate.getMonth() - startDate.getMonth();
+    if (monthDiff < 0) {
+      yearDiff--;
+      monthDiff += 12;
+    }
+    let dayDiff = endDate.getDate() - startDate.getDate();
+    if (dayDiff < 0) {
+      if (monthDiff > 0) {
+        monthDiff--;
+      } else {
+        yearDiff--;
+        monthDiff = 11;
+      }
+      dayDiff += DateUtils.daysInMonth(startYear, startDate.getMonth());
+    }
+    const msTotal = endDate.valueOf() - startDate.valueOf(); // milliseconds
+    const secondTotal = Math.floor(msTotal / 1000); // milliseconds -> seconds
+    const hourDiff = Math.floor(secondTotal / (60 * 60)) % 24;
+    const minuteDiff = Math.floor(secondTotal / 60) % 60;
+    const secondDiff = secondTotal % 60;
+    const msDiff = msTotal % 1000;
+    return new DiffDate(yearDiff, monthDiff, dayDiff, hourDiff, minuteDiff, secondDiff, msDiff);
+  }
+
+  // returns a time difference string from two dates
+  static diffString(endDate: Date, startDate: Date, printMS = false): string {
+    const diff = DateUtils.diff(endDate, startDate);
+    let ret = '';
+    if (diff.years !== 0) {
+      ret = ret + diff.years + ' years(s), ';
+    }
+    if (diff.years !== 0 || diff.months !== 0) {
+      ret = ret + diff.months + ' month(s), ';
+    }
+    if (diff.years !== 0 || diff.months !== 0 || diff.days !== 0) {
+      ret = ret + diff.days + ' day(s), ';
+    }
+    if (diff.years !== 0 || diff.months !== 0 || diff.days !== 0 || diff.hours !== 0) {
+      ret = ret + diff.hours + ' hour(s), ';
+    }
+    if (diff.years !== 0 || diff.months !== 0 || diff.days !== 0 || diff.hours !== 0 || diff.minutes !== 0) {
+      ret = ret + diff.minutes + ' minute(s), ';
+    }
+    if (
+      diff.years !== 0 ||
+      diff.months !== 0 ||
+      diff.days !== 0 ||
+      diff.hours !== 0 ||
+      diff.minutes !== 0 ||
+      diff.seconds !== 0 ||
+      !printMS
+    ) {
+      ret = ret + diff.seconds + ' second(s)';
+      if (printMS) {
+        ret += ', ';
+      }
+    }
+    if (printMS) {
+      ret = ret + diff.milliseconds + ' ms';
+    }
+    return ret;
+  }
+
+  // returns a YYYYMMDD format string
+  static toYMD(dt: Date, separator: string) {
+    separator = typeof separator === 'undefined' ? '-' : separator;
+    return (
+      dt.getFullYear() +
+      separator +
+      ('0' + (dt.getMonth() + 1)).toString().slice(-2) +
+      separator +
+      ('0' + dt.getDate()).toString().slice(-2)
+    );
+  }
+  static toYmdHms(dt: Date, separator: string) {
+    separator = typeof separator === 'undefined' ? '-' : separator;
+    return (
+      dt.getFullYear() +
+      separator +
+      ('0' + (dt.getMonth() + 1)).toString().slice(-2) +
+      separator +
+      ('0' + dt.getDate()).toString().slice(-2) +
+      ' ' +
+      ('0' + dt.getHours()).toString().slice(-2) +
+      ':' +
+      ('0' + dt.getMinutes()).toString().slice(-2) +
+      ':' +
+      ('0' + dt.getSeconds()).toString().slice(-2)
+    );
+  }
+
+  static toJSONString(dt: Date) {
+    // return dt.getUTCFullYear() + '-' + ('0' + (dt.getUTCMonth() + 1)).toString().slice(-2) +
+    //     '-' + ('0' + dt.getUTCDate()).toString().slice(-2) + ' ' + ('0' + dt.getUTCHours()).toString().slice(-2) +
+    //     ':' + ('0' + dt.getUTCMinutes()).toString().slice(-2) + ':' + ('0' + dt.getUTCSeconds()).toString().slice(-2) + 'Z';
+    return dt.toJSON();
+  }
+
+  static showJSONString(dt: string, separator = '-') {
+    return DateUtils.toYmdHms(DateUtils.toDate(dt), separator);
+  }
+
+  static fromJSONString(dt: string) {
+    return DateUtils.toDate(dt);
+  }
+
+  static clearTime(dt: Date) {
+    dt.setHours(0);
+    dt.setMinutes(0);
+    dt.setSeconds(0);
+    dt.setMilliseconds(0);
+    return dt;
+  }
+
+  static clearUTCTime(dt: Date) {
+    dt.setUTCHours(0);
+    dt.setUTCMinutes(0);
+    dt.setUTCSeconds(0);
+    dt.setUTCMilliseconds(0);
+    return dt;
+  }
+
+  static format(dt: Date, fmt: string) {
+    if (!fmt) {
+      fmt = 'YYYY-MM-DD';
+    }
+    if (!dt) {
+      dt = new Date();
+    }
+
+    const parts: { [key: string]: string } = {
+      YYYY: dt.getFullYear().toString(),
+      YY: ('00' + (dt.getFullYear() - 100)).toString().slice(-2),
+      MM: ('0' + (dt.getMonth() + 1)).toString().slice(-2),
+      M: (dt.getMonth() + 1).toString(),
+      DD: ('0' + dt.getDate()).toString().slice(-2),
+      D: dt.getDate().toString(),
+      hh: ('0' + dt.getHours()).toString().slice(-2),
+      h: dt.getHours().toString(),
+      mm: ('0' + dt.getMinutes()).toString().slice(-2),
+      ss: ('0' + dt.getSeconds()).toString().slice(-2),
+      SSS: ('00' + dt.getMilliseconds()).toString().slice(-3),
+      S: Math.floor(dt.getMilliseconds() / 100)
+        .toString()
+        .slice(-1),
+    };
+
+    const array = fmt.match(/(\[[^\[]*\])|(\\)?(YYYY|YY|MM?|DD?|hh?|mm?|ss?|SSS|S|.)/g) as string[];
+    for (let i = 0, length = array.length; i < length; i++) {
+      if (parts[array[i]]) {
+        array[i] = parts[array[i]];
+      }
+    }
+    const ret = array.join('');
+    return ret;
+  }
+}
+
+export class DiffDate {
+  years: number;
+  months: number;
+  days: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+
+  constructor(
+    years: number,
+    months: number,
+    days: number,
+    hours: number,
+    minutes: number,
+    seconds: number,
+    milliseconds: number
+  ) {
+    this.years = years;
+    this.months = months;
+    this.days = days;
+    this.hours = hours;
+    this.minutes = minutes;
+    this.seconds = seconds;
+    this.milliseconds = milliseconds;
+  }
+}

package/src/lib/utils/deep-merge.ts

@@ -0,0 +1,37 @@
+/**
+ * Simple object check.
+ * @param item
+ * @returns {boolean}
+ */
+const needMerge = (item: any) => {
+  return item && typeof item === 'object' && !Array.isArray(item);
+};
+
+/**
+ * Deep merge two objects.
+ * target must be a object, and array will be replaced
+ * @param target
+ * @param ...sources
+ */
+export const deepMerge = (target: any, ...sources: any[]): any => {
+  if (!sources.length) return target;
+  const source = sources.shift();
+
+  if (needMerge(target) && needMerge(source)) {
+    for (const key in source) {
+      if (needMerge(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        deepMerge(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+
+  return deepMerge(target, ...sources);
+};
+
+// Clone data object only
+export const cloneJson = (json: any) => {
+  return JSON.parse(JSON.stringify(json));
+};

package/src/lib/utils/delay.ts

@@ -0,0 +1,12 @@
+/*
+delay(3000).then(() => alert('runs after 3 seconds'));
+or
+await delay(3000);
+*/
+export const delay = (ms: number) => {
+  return new Promise<void>((resolve, reject) => {
+    setTimeout(() => {
+      resolve();
+    }, ms);
+  });
+};

package/src/lib/utils/file-setting.ts

@@ -0,0 +1,55 @@
+import { Logger } from '../logger';
+import { FsUtils } from './fs-utils';
+
+const logger = new Logger('setting-file');
+
+export type FileSettingProps = {
+  [key: string]: string | number | boolean | object;
+};
+
+/**
+ * A simple settings/config class for storing key/value pairs with persistence.
+ */
+export class FileSetting {
+  private settings: FileSettingProps = {};
+
+  constructor() {}
+
+  async load(path: string) {
+    let json;
+    if ((json = await FsUtils.readFile(path))) {
+      try {
+        const jsonObject = JSON.parse(json);
+        Object.assign(this.settings, jsonObject);
+      } catch (e: any) {
+        logger.error('Loading json file failed', e.message);
+      }
+    }
+  }
+
+  async save(path: string) {
+    await FsUtils.writeFile(path, JSON.stringify(this.settings));
+  }
+
+  set(key: string, value: string | number | boolean | object | undefined) {
+    if (value === undefined) {
+      delete this.settings[key];
+    } else {
+      this.settings[key] = value;
+    }
+  }
+
+  setAll(values: FileSettingProps) {
+    for (let k in values) {
+      this.settings[k] = values[k];
+    }
+  }
+
+  get(key: string, defaultValue: string | number | boolean | object): string | number | boolean | object {
+    return key in this.settings ? this.settings[key] : defaultValue;
+  }
+
+  get getAll(): FileSettingProps {
+    return this.settings;
+  }
+}

package/src/lib/utils/format-bytes.ts

@@ -0,0 +1,11 @@
+export const formatBytes = (bytes: number, decimals = 2) => {
+  if (!+bytes) return '0 Bytes';
+
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['Bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};

package/src/lib/utils/fs-utils.ts

@@ -0,0 +1,144 @@
+import { Dirent } from 'fs';
+import * as fs from 'fs/promises';
+
+export type FileInfoProps = {
+  size: number;
+  mtime: number;
+  isFile: boolean;
+  isDir: boolean;
+};
+export class FsUtils {
+  static readFile = async (filePath: string): Promise<string | undefined> => {
+    try {
+      const text = await fs.readFile(filePath, 'utf-8');
+      return text;
+    } catch (e) {
+      console.log('writeFile failed', e);
+      return undefined;
+    }
+  };
+
+  static fileInfo = async (filePath: string): Promise<FileInfoProps | undefined> => {
+    try {
+      const stats = await fs.stat(filePath);
+      return { size: stats.size, mtime: stats.mtime.getTime(), isFile: stats.isFile(), isDir: stats.isDirectory() };
+    } catch {
+      return undefined;
+    }
+  };
+
+  static writeFile = async (
+    filePath: string,
+    content:
+      | string
+      | NodeJS.ArrayBufferView
+      | Iterable<string | NodeJS.ArrayBufferView>
+      | AsyncIterable<string | NodeJS.ArrayBufferView>
+  ): Promise<boolean> => {
+    try {
+      await fs.writeFile(filePath, content, 'utf-8');
+      return true;
+    } catch (e) {
+      console.log('writeFile failed', e);
+      return false;
+    }
+  };
+
+  static appendFile = async (filePath: string, content: string | Uint8Array): Promise<boolean> => {
+    try {
+      await fs.appendFile(filePath, content, 'utf-8');
+      return true;
+    } catch (e) {
+      console.log('appendFile failed', e);
+      return false;
+    }
+  };
+
+  static pathExist = async (filePath: string) => {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  static mkdir = async (dirPath: string) => {
+    try {
+      await fs.mkdir(dirPath, { recursive: true });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  static unlinkFile = async (filePath: string) => {
+    try {
+      await fs.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  static unlinkFolderEmpty = async (filePath: string) => {
+    try {
+      await fs.rmdir(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  static unlinkFolderForce = async (filePath: string, recursive: boolean, force: boolean) => {
+    try {
+      await fs.rm(filePath, { recursive: recursive, force: force });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  static rename = async (filePath: string, newPath: string) => {
+    try {
+      await fs.rename(filePath, newPath);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  static getDirAndFiles = async (dirPath: string): Promise<string[]> => {
+    try {
+      const files = await fs.readdir(dirPath, { recursive: false });
+      return files;
+    } catch {
+      return [];
+    }
+  };
+
+  // return with fullpath list of Dirent
+  static getDirsFullpath = async (dirPath: string): Promise<Dirent[]> => {
+    try {
+      const files = await fs.readdir(dirPath, {
+        recursive: false,
+        withFileTypes: true,
+      });
+      return files;
+    } catch {
+      return [];
+    }
+  };
+
+  static async readPartOfFile(path: string, start: number, length: number) {
+    try {
+      const fileHandle = await fs.open(path, 'r');
+      const buffer = Buffer.alloc(length);
+      const { bytesRead } = await fileHandle.read(buffer, 0, length, start);
+      await fileHandle.close();
+      return buffer.slice(0, bytesRead);
+    } catch {
+      return null;
+    }
+  }
+}

package/src/lib/utils/get-env.ts

@@ -0,0 +1,27 @@
+function getEnv(key: string, defaultValue: number): number;
+function getEnv(key: string, defaultValue: string): string;
+function getEnv(key: string, defaultValue: boolean): boolean;
+function getEnv(key: string, defaultValue: object): object;
+function getEnv(key: string, defaultValue: any): any {
+  if (typeof process.env[key] === 'undefined') {
+    return defaultValue;
+  }
+
+  if (typeof defaultValue === 'number') {
+    return Number.parseInt(process.env[key]!);
+  }
+  if (typeof defaultValue === 'boolean') {
+    return process.env[key]!.toLocaleLowerCase() === 'true' || process.env[key] === '1';
+  }
+  if (typeof defaultValue === 'object') {
+    try {
+      return JSON.parse(process.env[key]!);
+    } catch (error) {}
+    return defaultValue;
+  }
+  // if (typeof defaultValue === 'string') {
+  //   return process.env[key];
+  // }
+  return process.env[key];
+}
+export { getEnv };

package/src/lib/utils/index.ts

@@ -0,0 +1,12 @@
+export * from './crypto';
+export * from './date-utils';
+export * from './deep-merge';
+export * from './delay';
+export * from './file-setting';
+export * from './format-bytes';
+export * from './get-env';
+export * from './is-type';
+export * from './load-env';
+export * from './pad';
+export * from './cookie-util';
+export * from './fs-utils';

package/src/lib/utils/is-type.ts

@@ -0,0 +1,48 @@
+export class IsType {
+  static getType(obj: any) {
+    var type = typeof obj;
+    if (type === 'undefined') return 'undefined';
+    else if (type === 'string' || obj instanceof String) return 'string';
+    else if (type === 'number' || obj instanceof Number) return 'number';
+    else if (type === 'function' || obj instanceof Function) return 'function';
+    else if (!!obj && obj.constructor === Array) return 'array';
+    else if (obj && obj.nodeType === 1) return 'element';
+    else if (type === 'object') return 'object';
+    else return 'unknown';
+  }
+
+  static isArray(input: any) {
+    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
+  }
+
+  static isObject(input: any) {
+    // null is not object
+    return input != null && Object.prototype.toString.call(input) === '[object Object]';
+  }
+
+  static isObjectEmpty(obj: any) {
+    if (Object.getOwnPropertyNames) {
+      return Object.getOwnPropertyNames(obj).length === 0;
+    } else {
+      var k;
+      for (k in obj) {
+        if (obj.hasOwnProperty(k)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+
+  static isUndefined(input: any) {
+    return input === void 0;
+  }
+
+  static isNumber(input: any) {
+    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
+  }
+
+  static isDate(input: any) {
+    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+  }
+}

package/src/lib/utils/load-env.ts

@@ -0,0 +1,14 @@
+import * as webEnv from '../../common-js/web-env.js';
+
+export const loadEnv = async (envFile: string, overrideEnv: boolean = false) => {
+  return webEnv.loadEnv(envFile, overrideEnv);
+};
+
+export const getWebEnv = (appName: string): { [k: string]: string } => {
+  return webEnv.getWebEnv(appName) as { [k: string]: string };
+};
+
+// // Replace <!--META-ENV-START-->...<!--META-ENV-END--> for mobile app and replace it again for web app
+// export const replaceWebEnv = (html: string, appName: string, addMetaTag: boolean) => {
+//   return webEnv.replaceWebEnv(html, appName, addMetaTag);
+// }

package/src/lib/utils/pad.ts

@@ -0,0 +1,6 @@
+export const padRight = (str: string, length: number, fillString: string) => {
+  return str.padEnd(length, fillString);
+};
+export const padLeft = (str: string, length: number, fillString: string) => {
+  return str.padStart(length, fillString);
+};

package/src/models/api-base.ts

@@ -0,0 +1,5 @@
+import { IApiRouter } from './api-router-props';
+
+export interface IApiBase {
+  getRouter(): IApiRouter;
+}