@oneuptime/common 1.0.0

package/Types/Infrastructure/OSType.ts

@@ -0,0 +1,8 @@
+enum OSType {
+    Windows = 'Windows',
+    Linux = 'Linux',
+    MacOS = 'MacOS',
+    Unknown = 'Unknown',
+}
+
+export default OSType;

package/Types/JSON.ts

@@ -0,0 +1,151 @@
+import ObjectID from './ObjectID';
+import Version from './Version';
+import Email from './Email';
+import Phone from './Phone';
+import Color from './Color';
+import Route from './API/Route';
+import URL from './API/URL';
+import Name from './Name';
+import Permission from './Permission';
+import Search from './BaseDatabase/Search';
+import Port from './Port';
+import Hostname from './API/Hostname';
+import HashedString from './HashedString';
+import GreaterThan from './BaseDatabase/GreaterThan';
+import GreaterThanOrEqual from './BaseDatabase/GreaterThanOrEqual';
+import LessThan from './BaseDatabase/LessThan';
+import LessThanOrEqual from './BaseDatabase/LessThanOrEqual';
+import InBetween from './BaseDatabase/InBetween';
+import Domain from './Domain';
+import NotNull from './BaseDatabase/NotNull';
+import { BaseEntity } from 'typeorm';
+import EqualToOrNull from './BaseDatabase/EqualToOrNull';
+import NotEqual from './BaseDatabase/NotEqual';
+import { CheckOn, FilterType } from './Monitor/CriteriaFilter';
+import CallRequest from './Call/CallRequest';
+import PositiveNumber from './PositiveNumber';
+import StartAndEndTime from './Time/StartAndEndTime';
+import Includes from './BaseDatabase/Includes';
+
+export enum ObjectType {
+    ObjectID = 'ObjectID',
+    Decimal = 'Decimal',
+    Name = 'Name',
+    EqualToOrNull = 'EqualToOrNull',
+    MonitorSteps = 'MonitorSteps',
+    MonitorStep = 'MonitorStep',
+    Recurring = 'Recurring',
+    RestrictionTimes = 'RestrictionTimes',
+    MonitorCriteria = 'MonitorCriteria',
+    PositiveNumber = 'PositiveNumber',
+    MonitorCriteriaInstance = 'MonitorCriteriaInstance',
+    NotEqual = 'NotEqual',
+    Email = 'Email',
+    Phone = 'Phone',
+    Color = 'Color',
+    Domain = 'Domain',
+    Version = 'Version',
+    IP = 'IP',
+    Route = 'Route',
+    URL = 'URL',
+    Permission = 'Permission',
+    Search = 'Search',
+    GreaterThan = 'GreaterThan',
+    GreaterThanOrEqual = 'GreaterThanOrEqual',
+    LessThan = 'LessThan',
+    LessThanOrEqual = 'LessThanOrEqual',
+    Port = 'Port',
+    Hostname = 'Hostname',
+    HashedString = 'HashedString',
+    DateTime = 'DateTime',
+    Buffer = 'Buffer',
+    InBetween = 'InBetween',
+    NotNull = 'NotNull',
+    IsNull = 'IsNull',
+    Includes = 'Includes',
+}
+
+export type JSONValue =
+    | Array<string>
+    | string
+    | Array<number>
+    | number
+    | Array<boolean>
+    | boolean
+    | JSONObject
+    | Uint8Array
+    | JSONArray
+    | Date
+    | Array<Date>
+    | ObjectID
+    | Array<ObjectID>
+    | BaseEntity
+    | Array<BaseEntity>
+    | Name
+    | Array<Name>
+    | Email
+    | Array<Email>
+    | Color
+    | Array<Color>
+    | Phone
+    | Array<Phone>
+    | Route
+    | Array<Route>
+    | URL
+    | Array<URL>
+    | Array<Version>
+    | Version
+    | Buffer
+    | Permission
+    | Array<Permission>
+    | CheckOn
+    | Array<CheckOn>
+    | FilterType
+    | Array<FilterType>
+    | Search
+    | Domain
+    | Array<Domain>
+    | Array<Search>
+    | EqualToOrNull
+    | Array<EqualToOrNull>
+    | NotEqual
+    | Array<NotEqual>
+    | GreaterThan
+    | Array<GreaterThan>
+    | GreaterThanOrEqual
+    | Array<GreaterThanOrEqual>
+    | PositiveNumber
+    | Array<PositiveNumber>
+    | LessThan
+    | Array<LessThan>
+    | InBetween
+    | Array<InBetween>
+    | NotNull
+    | Array<NotNull>
+    | LessThanOrEqual
+    | Array<LessThanOrEqual>
+    | Port
+    | Array<Port>
+    | HashedString
+    | Array<HashedString>
+    | Hostname
+    | Array<Hostname>
+    | Array<JSONValue>
+    | Array<Permission>
+    | Array<JSONValue>
+    | Array<ObjectID>
+    | CallRequest
+    | undefined
+    | null
+    | StartAndEndTime
+    | Array<StartAndEndTime>
+    | Includes
+    | Array<Includes>;
+
+export interface JSONObject {
+    [x: string]: JSONValue;
+}
+
+export type JSONArray = Array<JSONObject>;
+
+export type JSONObjectOrArray = JSONObject | JSONArray;

package/Types/JSONFunctions.ts

@@ -0,0 +1,265 @@
+import Typeof from './Typeof';
+import DatabaseProperty from './Database/DatabaseProperty';
+import OneUptimeDate from './Date';
+import BaseModel from '../Models/BaseModel';
+import { JSONArray, JSONObject, JSONValue, ObjectType } from './JSON';
+import SerializableObject from './SerializableObject';
+import SerializableObjectDictionary from './SerializableObjectDictionary';
+import JSON5 from 'json5';
+
+export default class JSONFunctions {
+    public static isEmptyObject(
+        obj: JSONObject | BaseModel | null | undefined
+    ): boolean {
+        if (!obj) {
+            return true;
+        }
+
+        return Object.keys(obj).length === 0;
+    }
+
+    public static toCompressedString(val: JSONValue): string {
+        return JSON.stringify(val, null, 2);
+    }
+
+    public static toString(val: JSONValue): string {
+        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;
+            }
+        }
+
+        return returnValue as JSONValue;
+    }
+
+    // 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);
+            }
+        }
+
+        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);
+        }
+
+        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;
+        }
+
+        return val;
+    }
+
+    public static deserializeArray(array: JSONArray): JSONArray {
+        const returnArr: JSONArray = [];
+
+        for (const obj of array) {
+            returnArr.push(this.deserialize(obj));
+        }
+
+        return returnArr;
+    }
+
+    public static serializeArray(array: JSONArray): JSONArray {
+        const returnArr: JSONArray = [];
+
+        for (const obj of array) {
+            returnArr.push(this.serialize(obj));
+        }
+
+        return returnArr;
+    }
+
+    public static parse(val: string): JSONObject | JSONArray {
+        return JSON5.parse(val);
+    }
+
+    public static parseJSONObject(val: string): JSONObject {
+        const result: JSONObject | JSONArray = this.parse(val);
+
+        if (Array.isArray(result)) {
+            throw new Error('Expected JSONObject, but got JSONArray');
+        }
+
+        return result;
+    }
+
+    public static parseJSONArray(val: string): JSONArray {
+        const result: JSONObject | JSONArray = this.parse(val);
+
+        if (!Array.isArray(result)) {
+            throw new Error('Expected JSONArray, but got JSONObject');
+        }
+
+        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));
+                }
+
+                newVal[key] = arraySerialize;
+            } else {
+                newVal[key] = this.deserializeValue(val[key] as JSONValue);
+            }
+        }
+
+        return newVal;
+    }
+
+    public static anyObjectToJSONObject(val: any): JSONObject {
+        return JSON.parse(JSON.stringify(val));
+    }
+
+    public static flattenObject(val: JSONObject): JSONObject {
+        const returnObj: JSONObject = {};
+
+        type FlattenFunction = (obj: JSONObject, prefix: string) => void;
+
+        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];
+                }
+            }
+        };
+
+        flatten(val, '');
+
+        return returnObj;
+    }
+}

package/Types/JsonWebTokenData.ts

@@ -0,0 +1,13 @@
+import Email from './Email';
+import { JSONObject } from './JSON';
+import Name from './Name';
+import ObjectID from './ObjectID';
+
+export default interface JSONWebTokenData extends JSONObject {
+    userId: ObjectID;
+    email: Email;
+    name?: Name | undefined;
+    isMasterAdmin: boolean;
+    statusPageId?: ObjectID | undefined; // for status page logins.
+    projectId?: ObjectID | undefined; // for SSO logins.
+}

package/Types/Link.ts

@@ -0,0 +1,8 @@
+import Route from './API/Route';
+import URL from './API/URL';
+
+export default interface Link {
+    title: string;
+    to: Route | URL;
+    openInNewTab?: boolean | undefined;
+}

package/Types/ListData.ts

@@ -0,0 +1,32 @@
+import { JSONArray, JSONObject } from './JSON';
+import PositiveNumber from './PositiveNumber';
+
+export default class ListData {
+    public constructor(obj: {
+        data: JSONArray;
+        count: PositiveNumber;
+        skip: PositiveNumber;
+        limit: PositiveNumber;
+    }) {
+        this.data = obj.data;
+        this.count = obj.count;
+        this.skip = obj.skip;
+        this.limit = obj.limit;
+    }
+
+    public data: JSONArray;
+    public count: PositiveNumber;
+    public skip: PositiveNumber;
+    public limit: PositiveNumber;
+
+    public toJSON(): JSONObject {
+        const json: JSONObject = {
+            data: this.data,
+            count: this.count.toNumber(),
+            skip: this.skip.toNumber(),
+            limit: this.limit.toNumber(),
+        };
+
+        return json;
+    }
+}

package/Types/Mail/MailStatus.ts

@@ -0,0 +1,6 @@
+enum MailStatus {
+    Success = 'Success',
+    Error = 'Error',
+}
+
+export default MailStatus;

package/Types/Mixins.ts

@@ -0,0 +1,5 @@
+// https://www.typescriptlang.org/docs/handbook/mixins.html
+
+import GenericObject from './GenericObject';
+
+export type GConstructor<T = GenericObject> = new (...args: any[]) => T;

package/Types/Monitor/CriteriaFilter.ts

@@ -0,0 +1,52 @@
+export enum CheckOn {
+    ResponseTime = 'Response Time (in ms)',
+    ResponseStatusCode = 'Response Status Code',
+    ResponseHeader = 'Response Header',
+    ResponseHeaderValue = 'Response Header Value',
+    ResponseBody = 'Response Body',
+    IsOnline = 'Is Online',
+    IncomingRequest = 'Incoming Request',
+    RequestBody = 'Request Body',
+    RequestHeader = 'Request Header',
+    RequestHeaderValue = 'Request Header Value',
+    JavaScriptExpression = 'JavaScript Expression',
+    DiskUsagePercent = 'Disk Usage (in %)',
+    CPUUsagePercent = 'CPU Usage (in %)',
+    MemoryUsagePercent = 'Memory Usage (in %)',
+}
+
+export interface ServerMonitorOptions {
+    diskPath?: string | undefined;
+}
+
+export interface CriteriaFilter {
+    checkOn: CheckOn;
+    serverMonitorOptions?: ServerMonitorOptions | undefined;
+    filterType: FilterType | undefined;
+    value: string | number | undefined;
+}
+
+export enum FilterType {
+    EqualTo = 'Equal To',
+    NotEqualTo = 'Not Equal To',
+    GreaterThan = 'Greater Than',
+    LessThan = 'Less Than',
+    GreaterThanOrEqualTo = 'Greater Than Or Equal To',
+    LessThanOrEqualTo = 'Less Than Or Equal To',
+    Contains = 'Contains',
+    NotContains = 'Not Contains',
+    StartsWith = 'Starts With',
+    EndsWith = 'Ends With',
+    IsEmpty = 'Is Empty',
+    IsNotEmpty = 'Is Not Empty',
+    True = 'True',
+    False = 'False',
+    NotRecievedInMinutes = 'Not Recieved In Minutes',
+    RecievedInMinutes = 'Recieved In Minutes',
+    EvaluatesToTrue = 'Evaluates To True',
+}
+
+export enum FilterCondition {
+    All = 'All',
+    Any = 'Any',
+}

package/Types/Monitor/CriteriaIncident.ts

@@ -0,0 +1,10 @@
+import ObjectID from '../ObjectID';
+
+export interface CriteriaIncident {
+    title: string;
+    description: string;
+    incidentSeverityId?: ObjectID | undefined;
+    autoResolveIncident?: boolean | undefined;
+    id: string;
+    onCallPolicyIds?: Array<ObjectID> | undefined;
+}

package/Types/Monitor/IncomingMonitor/IncomingMonitorRequest.ts

@@ -0,0 +1,11 @@
+import Dictionary from '../../Dictionary';
+import { JSONObject } from '../../JSON';
+import ObjectID from '../../ObjectID';
+
+export default interface IncomingMonitorRequest {
+    monitorId: ObjectID;
+    requestHeaders?: Dictionary<string> | undefined;
+    requestBody?: string | JSONObject | undefined;
+    incomingRequestReceivedAt: Date;
+    onlyCheckForIncomingRequestReceivedAt?: boolean | undefined;
+}