@oneuptime/common 7.0.2513 → 7.0.2550

package/Types/JSONFunctions.ts

@@ -1,399 +1,389 @@
-import BaseModel from '../Models/BaseModel';
-import DatabaseProperty from './Database/DatabaseProperty';
-import OneUptimeDate from './Date';
-import { JSONArray, JSONObject, JSONValue, ObjectType } from './JSON';
-import SerializableObject from './SerializableObject';
-import SerializableObjectDictionary from './SerializableObjectDictionary';
-import Typeof from './Typeof';
-import JSON5 from 'json5';
+import BaseModel from "../Models/BaseModel";
+import DatabaseProperty from "./Database/DatabaseProperty";
+import OneUptimeDate from "./Date";
+import { JSONArray, JSONObject, JSONValue, ObjectType } from "./JSON";
+import SerializableObject from "./SerializableObject";
+import SerializableObjectDictionary from "./SerializableObjectDictionary";
+import Typeof from "./Typeof";
+import JSON5 from "json5";
 
 export default class JSONFunctions {
-    public static nestJson(obj: JSONObject): JSONObject {
-        // obj could be in this format:
+  public static nestJson(obj: JSONObject): JSONObject {
+    // obj could be in this format:
 
-        /**
+    /**
          * {
     "http.url.protocol": "http",
     "http.url.hostname": "localhost",
     "http.host": "localhost",
          */
 
-        // we want to convert it to this format:
-
-        /**
-         * {
-         *
-         * "http": {
-         *     "url": {
-         *        "protocol": "http",
-         *       "hostname": "localhost"
-         *   },
-         *    "host": "localhost",
-         *   "method": "POST",
-         *  "scheme": "http",
-         * "client_ip": "
-         * ...
-         *
-         * },
-         */
-
-        const result: JSONObject = {};
-
-        for (const key in obj) {
-            const keys: Array<string> = key.split('.');
+    // we want to convert it to this format:
+
+    /**
+     * {
+     *
+     * "http": {
+     *     "url": {
+     *        "protocol": "http",
+     *       "hostname": "localhost"
+     *   },
+     *    "host": "localhost",
+     *   "method": "POST",
+     *  "scheme": "http",
+     * "client_ip": "
+     * ...
+     *
+     * },
+     */
+
+    const result: JSONObject = {};
+
+    for (const key in obj) {
+      const keys: Array<string> = key.split(".");
+
+      let currentObj: JSONObject = result;
+
+      for (let i: number = 0; i < keys.length; i++) {
+        const k: string | undefined = keys[i];
+
+        if (!k) {
+          continue;
+        }
 
-            let currentObj: JSONObject = result;
+        if (i === keys.length - 1) {
+          currentObj[k] = obj[key];
+        } else {
+          if (!currentObj[k]) {
+            currentObj[k] = {};
+          }
 
-            for (let i: number = 0; i < keys.length; i++) {
-                const k: string | undefined = keys[i];
+          currentObj = currentObj[k] as JSONObject;
+        }
+      }
+    }
 
-                if (!k) {
-                    continue;
-                }
+    return result;
+  }
 
-                if (i === keys.length - 1) {
-                    currentObj[k] = obj[key];
-                } else {
-                    if (!currentObj[k]) {
-                        currentObj[k] = {};
-                    }
+  public static isEmptyObject(
+    obj: JSONObject | BaseModel | null | undefined,
+  ): boolean {
+    if (!obj) {
+      return true;
+    }
 
-                    currentObj = currentObj[k] as JSONObject;
-                }
-            }
-        }
+    return Object.keys(obj).length === 0;
+  }
 
-        return result;
-    }
+  public static removeCircularReferences(obj: JSONObject): JSONObject {
+    const cache: any[] = [];
+    const returnValue: string = JSON.stringify(
+      obj,
+      (_key: string, value: any) => {
+        if (typeof value === "object" && value !== null) {
+          if (cache.includes(value)) {
+            return;
+          }
 
-    public static isEmptyObject(
-        obj: JSONObject | BaseModel | null | undefined
-    ): boolean {
-        if (!obj) {
-            return true;
+          cache.push(value);
         }
 
-        return Object.keys(obj).length === 0;
-    }
-
-    public static removeCircularReferences(obj: JSONObject): JSONObject {
-        const cache: any[] = [];
-        const returnValue: string = JSON.stringify(
-            obj,
-            (_key: string, value: any) => {
-                if (typeof value === 'object' && value !== null) {
-                    if (cache.includes(value)) {
-                        return;
-                    }
+        return value;
+      },
+    );
 
-                    cache.push(value);
-                }
+    return JSON.parse(returnValue);
+  }
 
-                return value;
-            }
-        );
+  public static isEqualObject(
+    obj1: JSONObject | undefined,
+    obj2: JSONObject | undefined,
+  ): boolean {
+    // check if all the keys are the same
 
-        return JSON.parse(returnValue);
+    if (!obj1 && !obj2) {
+      return true;
     }
 
-    public static isEqualObject(
-        obj1: JSONObject | undefined,
-        obj2: JSONObject | undefined
-    ): boolean {
-        // check if all the keys are the same
+    if (!obj1 || !obj2) {
+      return false;
+    }
 
-        if (!obj1 && !obj2) {
-            return true;
-        }
+    const keys1: Array<string> = Object.keys(obj1);
+    const keys2: Array<string> = Object.keys(obj2);
 
-        if (!obj1 || !obj2) {
-            return false;
-        }
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
 
-        const keys1: Array<string> = Object.keys(obj1);
-        const keys2: Array<string> = Object.keys(obj2);
+    for (const key of keys1) {
+      if (!keys2.includes(key)) {
+        return false;
+      }
+    }
 
-        if (keys1.length !== keys2.length) {
-            return false;
-        }
+    // check if all the values are the same
 
-        for (const key of keys1) {
-            if (!keys2.includes(key)) {
-                return false;
-            }
-        }
+    for (const key of keys1) {
+      if (obj1[key] !== obj2[key]) {
+        return false;
+      }
+    }
 
-        // check if all the values are the same
+    return true;
+  }
 
-        for (const key of keys1) {
-            if (obj1[key] !== obj2[key]) {
-                return false;
-            }
-        }
+  public static toCompressedString(val: JSONValue): string {
+    return JSON.stringify(val, null, 2);
+  }
 
-        return true;
+  public static toString(val: JSONValue): string {
+    if (typeof val === Typeof.String) {
+      return val as string;
     }
 
-    public static toCompressedString(val: JSONValue): string {
-        return JSON.stringify(val, null, 2);
+    return JSON.stringify(val);
+  }
+
+  public static getJSONValueInPath(
+    obj: JSONObject,
+    path: string,
+  ): JSONValue | null {
+    const paths: Array<string> = path.split(".");
+    let returnValue: JSONObject = obj as JSONObject;
+    for (const p of paths) {
+      if (!p) {
+        continue;
+      }
+
+      if (returnValue && returnValue[p as string]!) {
+        returnValue = returnValue[p] as JSONObject;
+      } else {
+        return null;
+      }
     }
 
-    public static toString(val: JSONValue): string {
-        if (typeof val === Typeof.String) {
-            return val as string;
-        }
+    return returnValue as JSONValue;
+  }
 
-        return JSON.stringify(val);
-    }
+  // this function serializes JSON with Common Objects to JSON that can be stringified.
+  public static serialize(val: JSONObject): JSONObject {
+    const newVal: JSONObject = {};
 
-    public static getJSONValueInPath(
-        obj: JSONObject,
-        path: string
-    ): JSONValue | null {
-        const paths: Array<string> = path.split('.');
-        let returnValue: JSONObject = obj as JSONObject;
-        for (const p of paths) {
-            if (!p) {
-                continue;
-            }
-
-            if (returnValue && returnValue[p as string]!) {
-                returnValue = returnValue[p] as JSONObject;
-            } else {
-                return null;
-            }
-        }
+    for (const key in val) {
+      if (val[key] === undefined) {
+        continue;
+      }
 
-        return returnValue as JSONValue;
-    }
+      if (val[key] === null) {
+        newVal[key] = val[key];
+      }
 
-    // this function serializes JSON with Common Objects to JSON that can be stringified.
-    public static serialize(val: JSONObject): JSONObject {
-        const newVal: JSONObject = {};
-
-        for (const key in val) {
-            if (val[key] === undefined) {
-                continue;
-            }
-
-            if (val[key] === null) {
-                newVal[key] = val[key];
-            }
-
-            if (Array.isArray(val[key])) {
-                const arraySerialize: Array<JSONValue> = [];
-                for (const arrVal of val[key] as Array<JSONValue>) {
-                    arraySerialize.push(this.serializeValue(arrVal));
-                }
-
-                newVal[key] = arraySerialize;
-            } else {
-                newVal[key] = this.serializeValue(val[key] as JSONValue);
-            }
+      if (Array.isArray(val[key])) {
+        const arraySerialize: Array<JSONValue> = [];
+        for (const arrVal of val[key] as Array<JSONValue>) {
+          arraySerialize.push(this.serializeValue(arrVal));
         }
 
-        return newVal;
+        newVal[key] = arraySerialize;
+      } else {
+        newVal[key] = this.serializeValue(val[key] as JSONValue);
+      }
     }
 
-    public static serializeValue(val: JSONValue): JSONValue {
-        if (val === null || val === undefined) {
-            return val;
-        } else if (
-            typeof val === Typeof.String &&
-            val.toString().trim() === ''
-        ) {
-            return val;
-        } else if (val instanceof BaseModel) {
-            return BaseModel.toJSON(val, BaseModel);
-        } else if (typeof val === Typeof.Number) {
-            return val;
-        } else if (ArrayBuffer.isView(val)) {
-            return {
-                _type: ObjectType.Buffer,
-                value: val as Uint8Array,
-            };
-        } else if (val && val instanceof SerializableObject) {
-            return val.toJSON();
-        } else if (val && val instanceof Date) {
-            return {
-                _type: ObjectType.DateTime,
-                value: OneUptimeDate.toString(val as Date).toString(),
-            };
-        } else if (
-            typeof val === Typeof.Object &&
-            (val as JSONObject)['_type'] &&
-            Object.keys(ObjectType).includes(
-                (val as JSONObject)['_type'] as string
-            )
-        ) {
-            return val;
-        } else if (typeof val === Typeof.Object) {
-            return this.serialize(val as JSONObject);
-        }
-
-        return val;
+    return newVal;
+  }
+
+  public static serializeValue(val: JSONValue): JSONValue {
+    if (val === null || val === undefined) {
+      return val;
+    } else if (typeof val === Typeof.String && val.toString().trim() === "") {
+      return val;
+    } else if (val instanceof BaseModel) {
+      return BaseModel.toJSON(val, BaseModel);
+    } else if (typeof val === Typeof.Number) {
+      return val;
+    } else if (ArrayBuffer.isView(val)) {
+      return {
+        _type: ObjectType.Buffer,
+        value: val as Uint8Array,
+      };
+    } else if (val && val instanceof SerializableObject) {
+      return val.toJSON();
+    } else if (val && val instanceof Date) {
+      return {
+        _type: ObjectType.DateTime,
+        value: OneUptimeDate.toString(val as Date).toString(),
+      };
+    } else if (
+      typeof val === Typeof.Object &&
+      (val as JSONObject)["_type"] &&
+      Object.keys(ObjectType).includes((val as JSONObject)["_type"] as string)
+    ) {
+      return val;
+    } else if (typeof val === Typeof.Object) {
+      return this.serialize(val as JSONObject);
     }
 
-    public static deserializeValue(val: JSONValue): JSONValue {
-        if (val === null || val === undefined) {
-            return val;
-        } else if (
-            typeof val === Typeof.String &&
-            val.toString().trim() === ''
-        ) {
-            return val;
-        } else if (
-            val &&
-            typeof val === Typeof.Object &&
-            (val as JSONObject)['_type'] &&
-            (val as JSONObject)['value'] &&
-            ((val as JSONObject)['value'] as JSONObject)['data'] &&
-            ((val as JSONObject)['value'] as JSONObject)['type'] &&
-            ((val as JSONObject)['value'] as JSONObject)['type'] ===
-                ObjectType.Buffer &&
-            ((val as JSONObject)['_type'] as string) === ObjectType.Buffer
-        ) {
-            return Buffer.from(
-                ((val as JSONObject)['value'] as JSONObject)[
-                    'data'
-                ] as Uint8Array
-            );
-        } else if (val && ArrayBuffer.isView(val)) {
-            return Buffer.from(val as Uint8Array);
-        } else if (typeof val === Typeof.Number) {
-            return val;
-        } else if (val instanceof DatabaseProperty) {
-            return val;
-        } else if (
-            val &&
-            typeof val === Typeof.Object &&
-            (val as JSONObject)['_type'] &&
-            SerializableObjectDictionary[(val as JSONObject)['_type'] as string]
-        ) {
-            return SerializableObjectDictionary[
-                (val as JSONObject)['_type'] as string
-            ].fromJSON(val);
-        } else if (val instanceof Date) {
-            return val;
-        } else if (typeof val === Typeof.Object) {
-            return this.deserialize(val as JSONObject);
-        } else if (Array.isArray(val)) {
-            const arr: Array<JSONValue> = [];
-
-            for (const v of val) {
-                arr.push(this.deserializeValue(v));
-            }
-
-            return arr;
-        }
-
-        return val;
+    return val;
+  }
+
+  public static deserializeValue(val: JSONValue): JSONValue {
+    if (val === null || val === undefined) {
+      return val;
+    } else if (typeof val === Typeof.String && val.toString().trim() === "") {
+      return val;
+    } else if (
+      val &&
+      typeof val === Typeof.Object &&
+      (val as JSONObject)["_type"] &&
+      (val as JSONObject)["value"] &&
+      ((val as JSONObject)["value"] as JSONObject)["data"] &&
+      ((val as JSONObject)["value"] as JSONObject)["type"] &&
+      ((val as JSONObject)["value"] as JSONObject)["type"] ===
+        ObjectType.Buffer &&
+      ((val as JSONObject)["_type"] as string) === ObjectType.Buffer
+    ) {
+      return Buffer.from(
+        ((val as JSONObject)["value"] as JSONObject)["data"] as Uint8Array,
+      );
+    } else if (val && ArrayBuffer.isView(val)) {
+      return Buffer.from(val as Uint8Array);
+    } else if (typeof val === Typeof.Number) {
+      return val;
+    } else if (val instanceof DatabaseProperty) {
+      return val;
+    } else if (
+      val &&
+      typeof val === Typeof.Object &&
+      (val as JSONObject)["_type"] &&
+      SerializableObjectDictionary[(val as JSONObject)["_type"] as string]
+    ) {
+      return SerializableObjectDictionary[
+        (val as JSONObject)["_type"] as string
+      ].fromJSON(val);
+    } else if (val instanceof Date) {
+      return val;
+    } else if (typeof val === Typeof.Object) {
+      return this.deserialize(val as JSONObject);
+    } else if (Array.isArray(val)) {
+      const arr: Array<JSONValue> = [];
+
+      for (const v of val) {
+        arr.push(this.deserializeValue(v));
+      }
+
+      return arr;
     }
 
-    public static deserializeArray(array: JSONArray): JSONArray {
-        const returnArr: JSONArray = [];
+    return val;
+  }
 
-        for (const obj of array) {
-            returnArr.push(this.deserialize(obj));
-        }
+  public static deserializeArray(array: JSONArray): JSONArray {
+    const returnArr: JSONArray = [];
 
-        return returnArr;
+    for (const obj of array) {
+      returnArr.push(this.deserialize(obj));
     }
 
-    public static serializeArray(array: JSONArray): JSONArray {
-        const returnArr: JSONArray = [];
+    return returnArr;
+  }
 
-        for (const obj of array) {
-            returnArr.push(this.serialize(obj));
-        }
+  public static serializeArray(array: JSONArray): JSONArray {
+    const returnArr: JSONArray = [];
 
-        return returnArr;
+    for (const obj of array) {
+      returnArr.push(this.serialize(obj));
     }
 
-    public static parse(val: string): JSONObject | JSONArray {
-        return JSON5.parse(val);
-    }
+    return returnArr;
+  }
 
-    public static parseJSONObject(val: string): JSONObject {
-        const result: JSONObject | JSONArray = this.parse(val);
+  public static parse(val: string): JSONObject | JSONArray {
+    return JSON5.parse(val);
+  }
 
-        if (Array.isArray(result)) {
-            throw new Error('Expected JSONObject, but got JSONArray');
-        }
+  public static parseJSONObject(val: string): JSONObject {
+    const result: JSONObject | JSONArray = this.parse(val);
 
-        return result;
+    if (Array.isArray(result)) {
+      throw new Error("Expected JSONObject, but got JSONArray");
     }
 
-    public static parseJSONArray(val: string): JSONArray {
-        const result: JSONObject | JSONArray = this.parse(val);
+    return result;
+  }
 
-        if (!Array.isArray(result)) {
-            throw new Error('Expected JSONArray, but got JSONObject');
-        }
+  public static parseJSONArray(val: string): JSONArray {
+    const result: JSONObject | JSONArray = this.parse(val);
 
-        return result;
+    if (!Array.isArray(result)) {
+      throw new Error("Expected JSONArray, but got JSONObject");
     }
 
-    public static deserialize(val: JSONObject): JSONObject {
-        const newVal: JSONObject = {};
-        for (const key in val) {
-            if (val[key] === null || val[key] === undefined) {
-                newVal[key] = val[key];
-            }
-
-            if (Array.isArray(val[key])) {
-                const arraySerialize: Array<JSONValue> = [];
-                for (const arrVal of val[key] as Array<JSONValue>) {
-                    arraySerialize.push(this.deserializeValue(arrVal));
-                }
-
-                newVal[key] = arraySerialize;
-            } else {
-                newVal[key] = this.deserializeValue(val[key] as JSONValue);
-            }
+    return result;
+  }
+
+  public static deserialize(val: JSONObject): JSONObject {
+    const newVal: JSONObject = {};
+    for (const key in val) {
+      if (val[key] === null || val[key] === undefined) {
+        newVal[key] = val[key];
+      }
+
+      if (Array.isArray(val[key])) {
+        const arraySerialize: Array<JSONValue> = [];
+        for (const arrVal of val[key] as Array<JSONValue>) {
+          arraySerialize.push(this.deserializeValue(arrVal));
         }
 
-        return newVal;
+        newVal[key] = arraySerialize;
+      } else {
+        newVal[key] = this.deserializeValue(val[key] as JSONValue);
+      }
     }
 
-    public static toFormattedString(val: JSONValue): string {
-        return JSON.stringify(val, null, 4);
-    }
+    return newVal;
+  }
 
-    public static anyObjectToJSONObject(val: any): JSONObject {
-        return JSON.parse(JSON.stringify(val));
-    }
+  public static toFormattedString(val: JSONValue): string {
+    return JSON.stringify(val, null, 4);
+  }
 
-    public static flattenObject(val: JSONObject): JSONObject {
-        const returnObj: JSONObject = {};
+  public static anyObjectToJSONObject(val: any): JSONObject {
+    return JSON.parse(JSON.stringify(val));
+  }
 
-        type FlattenFunction = (obj: JSONObject, prefix: string) => void;
+  public static flattenObject(val: JSONObject): JSONObject {
+    const returnObj: JSONObject = {};
 
-        const flatten: FlattenFunction = (
-            obj: JSONObject,
-            prefix: string
-        ): void => {
-            for (const key in obj) {
-                if (typeof obj[key] === Typeof.Object) {
-                    flatten(obj[key] as JSONObject, `${prefix}${key}.`);
-                } else {
-                    returnObj[`${prefix}${key}`] = obj[key];
-                }
-            }
-        };
+    type FlattenFunction = (obj: JSONObject, prefix: string) => void;
 
-        flatten(val, '');
+    const flatten: FlattenFunction = (
+      obj: JSONObject,
+      prefix: string,
+    ): void => {
+      for (const key in obj) {
+        if (typeof obj[key] === Typeof.Object) {
+          flatten(obj[key] as JSONObject, `${prefix}${key}.`);
+        } else {
+          returnObj[`${prefix}${key}`] = obj[key];
+        }
+      }
+    };
 
-        return returnObj;
-    }
+    flatten(val, "");
 
-    public static flattenArray(val: JSONArray): JSONArray {
-        const returnArr: JSONArray = [];
+    return returnObj;
+  }
 
-        for (const obj of val) {
-            returnArr.push(this.flattenObject(obj as JSONObject));
-        }
+  public static flattenArray(val: JSONArray): JSONArray {
+    const returnArr: JSONArray = [];
 
-        return returnArr;
+    for (const obj of val) {
+      returnArr.push(this.flattenObject(obj as JSONObject));
     }
+
+    return returnArr;
+  }
 }