@oneuptime/common 7.0.2513 → 7.0.2550

package/Types/API/StatusCode.ts

@@ -1,45 +1,42 @@
-import PositiveNumber from '../PositiveNumber';
-import Typeof from '../Typeof';
+import PositiveNumber from "../PositiveNumber";
+import Typeof from "../Typeof";
 
 export default class StatusCode {
-    private _statusCode: PositiveNumber = new PositiveNumber(200);
-    public get statusCode(): PositiveNumber {
-        return this._statusCode;
-    }
-    public set statusCode(v: PositiveNumber) {
-        this._statusCode = v;
-    }
+  private _statusCode: PositiveNumber = new PositiveNumber(200);
+  public get statusCode(): PositiveNumber {
+    return this._statusCode;
+  }
+  public set statusCode(v: PositiveNumber) {
+    this._statusCode = v;
+  }
 
-    public constructor(statusCode: number | string) {
-        if (statusCode) {
-            this.statusCode = new PositiveNumber(statusCode);
-        }
+  public constructor(statusCode: number | string) {
+    if (statusCode) {
+      this.statusCode = new PositiveNumber(statusCode);
     }
+  }
 
-    public toString(): string {
-        return this.statusCode.toString();
-    }
+  public toString(): string {
+    return this.statusCode.toString();
+  }
 
-    public toNumber(): number {
-        return this.statusCode.toNumber();
-    }
+  public toNumber(): number {
+    return this.statusCode.toNumber();
+  }
 
-    public static isValidStatusCode(statusCode: number | string): boolean {
-        try {
-            if (typeof statusCode === Typeof.String) {
-                statusCode = parseInt(statusCode as string);
-            }
+  public static isValidStatusCode(statusCode: number | string): boolean {
+    try {
+      if (typeof statusCode === Typeof.String) {
+        statusCode = parseInt(statusCode as string);
+      }
 
-            if (
-                (statusCode as number) >= 100 &&
-                (statusCode as number) <= 599
-            ) {
-                return true;
-            }
+      if ((statusCode as number) >= 100 && (statusCode as number) <= 599) {
+        return true;
+      }
 
-            return false;
-        } catch (err) {
-            return false;
-        }
+      return false;
+    } catch (err) {
+      return false;
     }
+  }
 }

package/Types/API/URL.ts

@@ -1,273 +1,269 @@
-import DatabaseProperty from '../Database/DatabaseProperty';
-import Dictionary from '../Dictionary';
-import Email from '../Email';
-import BadDataException from '../Exception/BadDataException';
-import { JSONObject, ObjectType } from '../JSON';
-import Typeof from '../Typeof';
-import Hostname from './Hostname';
-import Protocol from './Protocol';
-import Route from './Route';
-import { FindOperator } from 'typeorm';
+import DatabaseProperty from "../Database/DatabaseProperty";
+import Dictionary from "../Dictionary";
+import Email from "../Email";
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import Typeof from "../Typeof";
+import Hostname from "./Hostname";
+import Protocol from "./Protocol";
+import Route from "./Route";
+import { FindOperator } from "typeorm";
 
 export default class URL extends DatabaseProperty {
-    private _route: Route = new Route();
-    public get route(): Route {
-        return this._route;
-    }
-    public set route(v: Route) {
-        this._route = v;
-    }
-
-    private _params: Dictionary<string> = {};
-    public get params(): Dictionary<string> {
-        return this._params;
-    }
-    public set params(v: Dictionary<string>) {
-        this._params = v;
-    }
-
-    private _email!: Email;
-    public get email(): Email {
-        return this._email;
-    }
-    public set email(v: Email) {
-        this._email = v;
+  private _route: Route = new Route();
+  public get route(): Route {
+    return this._route;
+  }
+  public set route(v: Route) {
+    this._route = v;
+  }
+
+  private _params: Dictionary<string> = {};
+  public get params(): Dictionary<string> {
+    return this._params;
+  }
+  public set params(v: Dictionary<string>) {
+    this._params = v;
+  }
+
+  private _email!: Email;
+  public get email(): Email {
+    return this._email;
+  }
+  public set email(v: Email) {
+    this._email = v;
+  }
+
+  private _hostname!: Hostname;
+  public get hostname(): Hostname {
+    return this._hostname;
+  }
+  public set hostname(v: Hostname) {
+    this._hostname = v;
+  }
+
+  private _protocol: Protocol = Protocol.HTTPS;
+  public get protocol(): Protocol {
+    return this._protocol;
+  }
+  public set protocol(v: Protocol) {
+    this._protocol = v;
+  }
+
+  public constructor(
+    protocol: Protocol,
+    hostname: Hostname | string | Email,
+    route?: Route,
+    queryString?: string,
+  ) {
+    super();
+
+    if (
+      typeof hostname === Typeof.String &&
+      Email.isValid(hostname as string)
+    ) {
+      this.email = new Email(hostname as string);
+    } else if (hostname instanceof Email) {
+      this.email = hostname;
+    } else if (hostname instanceof Hostname) {
+      this.hostname = hostname;
+    } else if (typeof hostname === Typeof.String) {
+      this.hostname = Hostname.fromString(hostname);
     }
 
-    private _hostname!: Hostname;
-    public get hostname(): Hostname {
-        return this._hostname;
-    }
-    public set hostname(v: Hostname) {
-        this._hostname = v;
-    }
+    this.protocol = protocol;
 
-    private _protocol: Protocol = Protocol.HTTPS;
-    public get protocol(): Protocol {
-        return this._protocol;
-    }
-    public set protocol(v: Protocol) {
-        this._protocol = v;
+    if (route) {
+      this.route = route;
     }
 
-    public constructor(
-        protocol: Protocol,
-        hostname: Hostname | string | Email,
-        route?: Route,
-        queryString?: string
-    ) {
-        super();
-
-        if (
-            typeof hostname === Typeof.String &&
-            Email.isValid(hostname as string)
-        ) {
-            this.email = new Email(hostname as string);
-        } else if (hostname instanceof Email) {
-            this.email = hostname;
-        } else if (hostname instanceof Hostname) {
-            this.hostname = hostname;
-        } else if (typeof hostname === Typeof.String) {
-            this.hostname = Hostname.fromString(hostname);
-        }
-
-        this.protocol = protocol;
-
-        if (route) {
-            this.route = route;
+    if (queryString) {
+      const keyValues: Array<string> = queryString.split("&");
+      for (const keyValue of keyValues) {
+        if (keyValue.split("=")[0] && keyValue.split("=")[1]) {
+          const key: string | undefined = keyValue.split("=")[0];
+          const value: string | undefined = keyValue.split("=")[1];
+          if (key && value) {
+            this._params[key] = value;
+          }
         }
-
-        if (queryString) {
-            const keyValues: Array<string> = queryString.split('&');
-            for (const keyValue of keyValues) {
-                if (keyValue.split('=')[0] && keyValue.split('=')[1]) {
-                    const key: string | undefined = keyValue.split('=')[0];
-                    const value: string | undefined = keyValue.split('=')[1];
-                    if (key && value) {
-                        this._params[key] = value;
-                    }
-                }
-            }
-        }
-    }
-
-    public isHttps(): boolean {
-        return this.protocol === Protocol.HTTPS;
+      }
     }
-
-    public override toString(): string {
-        let urlString: string = `${this.protocol}${
-            this.hostname || this.email
-        }`;
-        if (!this.email && !urlString.startsWith('mailto:')) {
-            if (this.route && this.route.toString().startsWith('/')) {
-                if (urlString.endsWith('/')) {
-                    urlString = urlString.substring(0, urlString.length - 1);
-                }
-                urlString += this.route.toString();
-            } else {
-                if (urlString.endsWith('/')) {
-                    urlString = urlString.substring(0, urlString.length - 1);
-                }
-                urlString += '/' + this.route.toString();
-            }
-
-            if (Object.keys(this.params).length > 0) {
-                urlString += '?';
-
-                for (const key of Object.keys(this.params)) {
-                    urlString += key + '=' + this.params[key] + '&';
-                }
-
-                urlString = urlString.substring(0, urlString.length - 1); // remove last &
-            }
+  }
+
+  public isHttps(): boolean {
+    return this.protocol === Protocol.HTTPS;
+  }
+
+  public override toString(): string {
+    let urlString: string = `${this.protocol}${this.hostname || this.email}`;
+    if (!this.email && !urlString.startsWith("mailto:")) {
+      if (this.route && this.route.toString().startsWith("/")) {
+        if (urlString.endsWith("/")) {
+          urlString = urlString.substring(0, urlString.length - 1);
         }
-
-        return urlString;
-    }
-
-    public static fromURL(url: URL): URL {
-        return URL.fromString(url.toString());
-    }
-
-    public static fromString(url: string): URL {
-        let protocol: Protocol = Protocol.HTTPS;
-
-        if (url.startsWith('https://')) {
-            protocol = Protocol.HTTPS;
-            url = url.replace('https://', '');
+        urlString += this.route.toString();
+      } else {
+        if (urlString.endsWith("/")) {
+          urlString = urlString.substring(0, urlString.length - 1);
         }
+        urlString += "/" + this.route.toString();
+      }
 
-        if (url.startsWith('http://')) {
-            protocol = Protocol.HTTP;
-            url = url.replace('http://', '');
-        }
+      if (Object.keys(this.params).length > 0) {
+        urlString += "?";
 
-        if (url.startsWith('wss://')) {
-            protocol = Protocol.WSS;
-            url = url.replace('wss://', '');
+        for (const key of Object.keys(this.params)) {
+          urlString += key + "=" + this.params[key] + "&";
         }
 
-        if (url.startsWith('ws://')) {
-            protocol = Protocol.WS;
-            url = url.replace('ws://', '');
-        }
+        urlString = urlString.substring(0, urlString.length - 1); // remove last &
+      }
+    }
 
-        if (url.startsWith('mongodb://')) {
-            protocol = Protocol.MONGO_DB;
-            url = url.replace('mongodb://', '');
-        }
+    return urlString;
+  }
 
-        if (url.startsWith('mailto:')) {
-            protocol = Protocol.MAIL;
-            url = url.replace('mailto:', '');
-        }
+  public static fromURL(url: URL): URL {
+    return URL.fromString(url.toString());
+  }
 
-        const hostname: Hostname = new Hostname(url.split('/')[0] || '');
+  public static fromString(url: string): URL {
+    let protocol: Protocol = Protocol.HTTPS;
 
-        let route: Route | undefined;
+    if (url.startsWith("https://")) {
+      protocol = Protocol.HTTPS;
+      url = url.replace("https://", "");
+    }
 
-        if (url.split('/').length > 1) {
-            const paths: Array<string> = url.split('/');
-            paths.shift();
-            route = new Route(paths.join('/').split('?')[0]);
-        }
+    if (url.startsWith("http://")) {
+      protocol = Protocol.HTTP;
+      url = url.replace("http://", "");
+    }
 
-        const queryString: string | undefined = url.split('?')[1] || '';
+    if (url.startsWith("wss://")) {
+      protocol = Protocol.WSS;
+      url = url.replace("wss://", "");
+    }
 
-        return new URL(protocol, hostname, route, queryString);
+    if (url.startsWith("ws://")) {
+      protocol = Protocol.WS;
+      url = url.replace("ws://", "");
     }
 
-    public removeQueryString(): URL {
-        return URL.fromString(this.toString().split('?')[0] || '');
+    if (url.startsWith("mongodb://")) {
+      protocol = Protocol.MONGO_DB;
+      url = url.replace("mongodb://", "");
     }
 
-    public override toJSON(): JSONObject {
-        return {
-            _type: ObjectType.URL,
-            value: (this as URL).toString(),
-        };
+    if (url.startsWith("mailto:")) {
+      protocol = Protocol.MAIL;
+      url = url.replace("mailto:", "");
     }
 
-    public static override fromJSON(json: JSONObject): URL {
-        if (json['_type'] === ObjectType.URL) {
-            return URL.fromString((json['value'] as string) || '');
-        }
+    const hostname: Hostname = new Hostname(url.split("/")[0] || "");
 
-        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    let route: Route | undefined;
+
+    if (url.split("/").length > 1) {
+      const paths: Array<string> = url.split("/");
+      paths.shift();
+      route = new Route(paths.join("/").split("?")[0]);
     }
 
-    public addRoute(route: Route | string): URL {
-        if (typeof route === Typeof.String) {
-            this.route.addRoute(new Route(route.toString()));
-        }
+    const queryString: string | undefined = url.split("?")[1] || "";
 
-        if (route instanceof Route) {
-            this.route.addRoute(route);
-        }
+    return new URL(protocol, hostname, route, queryString);
+  }
 
-        return this;
-    }
+  public removeQueryString(): URL {
+    return URL.fromString(this.toString().split("?")[0] || "");
+  }
 
-    public addQueryParam(
-        paramName: string,
-        value: string,
-        encode?: boolean | undefined
-    ): URL {
-        if (encode) {
-            value = encodeURIComponent(value);
-        }
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.URL,
+      value: (this as URL).toString(),
+    };
+  }
 
-        this.params[paramName] = value;
-        return this;
+  public static override fromJSON(json: JSONObject): URL {
+    if (json["_type"] === ObjectType.URL) {
+      return URL.fromString((json["value"] as string) || "");
     }
 
-    public getQueryParam(paramName: string): string | null {
-        return this.params[paramName] || null;
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+
+  public addRoute(route: Route | string): URL {
+    if (typeof route === Typeof.String) {
+      this.route.addRoute(new Route(route.toString()));
     }
 
-    public addQueryParams(params: Dictionary<string>): URL {
-        this.params = {
-            ...this.params,
-            ...params,
-        };
-        return this;
+    if (route instanceof Route) {
+      this.route.addRoute(route);
     }
 
-    public getLastRoute(getFromLastRoute?: number): Route | null {
-        const paths: Array<string> = this.route.toString().split('/');
+    return this;
+  }
 
-        if (paths.length > 0) {
-            if (!getFromLastRoute) {
-                return new Route('/' + paths[paths.length - 1]);
-            }
-            return new Route(
-                '/' + paths[paths.length - (1 + getFromLastRoute)]
-            );
-        }
+  public addQueryParam(
+    paramName: string,
+    value: string,
+    encode?: boolean | undefined,
+  ): URL {
+    if (encode) {
+      value = encodeURIComponent(value);
+    }
 
-        return null;
+    this.params[paramName] = value;
+    return this;
+  }
+
+  public getQueryParam(paramName: string): string | null {
+    return this.params[paramName] || null;
+  }
+
+  public addQueryParams(params: Dictionary<string>): URL {
+    this.params = {
+      ...this.params,
+      ...params,
+    };
+    return this;
+  }
+
+  public getLastRoute(getFromLastRoute?: number): Route | null {
+    const paths: Array<string> = this.route.toString().split("/");
+
+    if (paths.length > 0) {
+      if (!getFromLastRoute) {
+        return new Route("/" + paths[paths.length - 1]);
+      }
+      return new Route("/" + paths[paths.length - (1 + getFromLastRoute)]);
     }
 
-    protected static override toDatabase(
-        value: URL | FindOperator<URL>
-    ): string | null {
-        if (value) {
-            if (typeof value === 'string') {
-                value = URL.fromString(value);
-            }
+    return null;
+  }
 
-            return value.toString();
-        }
+  protected static override toDatabase(
+    value: URL | FindOperator<URL>,
+  ): string | null {
+    if (value) {
+      if (typeof value === "string") {
+        value = URL.fromString(value);
+      }
 
-        return null;
+      return value.toString();
     }
 
-    protected static override fromDatabase(_value: string): URL | null {
-        if (_value) {
-            return URL.fromString(_value);
-        }
+    return null;
+  }
 
-        return null;
+  protected static override fromDatabase(_value: string): URL | null {
+    if (_value) {
+      return URL.fromString(_value);
     }
+
+    return null;
+  }
 }

package/Types/Alerts/AlertEventType.ts

@@ -1,14 +1,14 @@
 enum AlertEventType {
-    Identified = 'Identified',
-    Acknowledged = 'Acknowledged',
-    Resolved = 'Resolved',
-    InvestigationNoteCreated = 'Investigation note created',
-    InvestigationNoteUpdated = 'Investigation note updated',
-    ScheduledMaintenanceCreated = 'Scheduled maintenance created',
-    ScheduledMaintenanceNoteCreated = 'Scheduled maintenance note created',
-    ScheduledMaintenanceResolved = 'Scheduled maintenance resolved',
-    ScheduledMaintenanceCancelled = 'Scheduled maintenance cancelled',
-    AnnouncementNotificationCreated = 'Announcement notification created',
+  Identified = "Identified",
+  Acknowledged = "Acknowledged",
+  Resolved = "Resolved",
+  InvestigationNoteCreated = "Investigation note created",
+  InvestigationNoteUpdated = "Investigation note updated",
+  ScheduledMaintenanceCreated = "Scheduled maintenance created",
+  ScheduledMaintenanceNoteCreated = "Scheduled maintenance note created",
+  ScheduledMaintenanceResolved = "Scheduled maintenance resolved",
+  ScheduledMaintenanceCancelled = "Scheduled maintenance cancelled",
+  AnnouncementNotificationCreated = "Announcement notification created",
 }
 
 export default AlertEventType;

package/Types/Alerts/AlertType.ts

@@ -1,9 +1,9 @@
 enum AlertType {
-    Webhook = 'Webhook',
-    Email = 'Email',
-    SMS = 'SMS',
-    Call = 'Call',
-    PushNotification = 'PushNotification',
+  Webhook = "Webhook",
+  Email = "Email",
+  SMS = "SMS",
+  Call = "Call",
+  PushNotification = "PushNotification",
 }
 
 export default AlertType;

package/Types/AnalyticsDatabase/AnalyticsTableEngine.ts

@@ -1,5 +1,5 @@
 enum AnalyticsTableEngine {
-    MergeTree = 'MergeTree',
+  MergeTree = "MergeTree",
 }
 
 export default AnalyticsTableEngine;