@oneuptime/common 7.0.2525 → 7.0.2570

package/Types/Monitor/MonitorType.ts

@@ -1,186 +1,181 @@
-import BadDataException from '../Exception/BadDataException';
+import BadDataException from "../Exception/BadDataException";
 
 enum MonitorType {
-    Manual = 'Manual',
-    Website = 'Website',
-    API = 'API',
-    Ping = 'Ping',
-    Kubernetes = 'Kubernetes',
-    IP = 'IP',
-    IncomingRequest = 'Incoming Request',
-    Port = 'Port',
-    Server = 'Server',
-    SSLCertificate = 'SSL Certificate',
-
-    // These two monitor types are same but we are keeping them separate for now - this is for marketing purposes
-    SyntheticMonitor = 'Synthetic Monitor',
-    CustomJavaScriptCode = 'Custom JavaScript Code',
+  Manual = "Manual",
+  Website = "Website",
+  API = "API",
+  Ping = "Ping",
+  Kubernetes = "Kubernetes",
+  IP = "IP",
+  IncomingRequest = "Incoming Request",
+  Port = "Port",
+  Server = "Server",
+  SSLCertificate = "SSL Certificate",
+
+  // These two monitor types are same but we are keeping them separate for now - this is for marketing purposes
+  SyntheticMonitor = "Synthetic Monitor",
+  CustomJavaScriptCode = "Custom JavaScript Code",
 }
 
 export default MonitorType;
 
 export interface MonitorTypeProps {
-    monitorType: MonitorType;
-    description: string;
-    title: string;
+  monitorType: MonitorType;
+  description: string;
+  title: string;
 }
 
 export class MonitorTypeHelper {
-    public static getAllMonitorTypeProps(): Array<MonitorTypeProps> {
-        const monitorTypeProps: Array<MonitorTypeProps> = [
-            {
-                monitorType: MonitorType.API,
-                title: 'API',
-                description:
-                    'This monitor type lets you monitor any API - GET, POST, PUT, DELETE or more.',
-            },
-            {
-                monitorType: MonitorType.Manual,
-                title: 'Manual',
-                description:
-                    'This monitor is a static monitor and will not actually monitor anything. It will however help you to integrate OneUptime with external monitoring tools and utilities.',
-            },
-            {
-                monitorType: MonitorType.Website,
-                title: 'Website',
-                description:
-                    'This monitor type lets you monitor landing pages like home page of your company / blog or more.',
-            },
-            {
-                monitorType: MonitorType.Ping,
-                title: 'Ping',
-                description:
-                    'This monitor type does the basic ping test of an endpoint.',
-            },
-            // {
-            //     monitorType: MonitorType.Kubernetes,
-            //     title: 'Kubernetes',
-            //     description:
-            //         'This monitor types lets you monitor Kubernetes clusters.',
-            // },
-            {
-                monitorType: MonitorType.IP,
-                title: 'IP',
-                description:
-                    'This monitor type lets you monitor any IPv4 or IPv6 addresses.',
-            },
-            {
-                monitorType: MonitorType.IncomingRequest,
-                title: 'Incoming Request',
-                description:
-                    'This monitor type lets you ping OneUptime from any external device or service with a custom payload.',
-            },
-            {
-                monitorType: MonitorType.Port,
-                title: 'Port',
-                description:
-                    'This monitor type lets you monitor any TCP or UDP port.',
-            },
-            {
-                monitorType: MonitorType.Server,
-                title: 'Server / VM',
-                description:
-                    'This monitor type lets you monitor any server, VM, or any machine.',
-            },
-            {
-                monitorType: MonitorType.SSLCertificate,
-                title: 'SSL Certificate',
-                description:
-                    'This monitor type lets you monitor SSL certificates of any domain.',
-            },
-            {
-                monitorType: MonitorType.SyntheticMonitor,
-                title: 'Synthetic Monitor',
-                description:
-                    'This monitor type lets you monitor your web application UI.',
-            },
-            {
-                monitorType: MonitorType.CustomJavaScriptCode,
-                title: 'Custom JavaScript Code',
-                description:
-                    'This monitor type lets you run custom JavaScript code on a schedule.',
-            },
-        ];
-
-        return monitorTypeProps;
+  public static getAllMonitorTypeProps(): Array<MonitorTypeProps> {
+    const monitorTypeProps: Array<MonitorTypeProps> = [
+      {
+        monitorType: MonitorType.API,
+        title: "API",
+        description:
+          "This monitor type lets you monitor any API - GET, POST, PUT, DELETE or more.",
+      },
+      {
+        monitorType: MonitorType.Manual,
+        title: "Manual",
+        description:
+          "This monitor is a static monitor and will not actually monitor anything. It will however help you to integrate OneUptime with external monitoring tools and utilities.",
+      },
+      {
+        monitorType: MonitorType.Website,
+        title: "Website",
+        description:
+          "This monitor type lets you monitor landing pages like home page of your company / blog or more.",
+      },
+      {
+        monitorType: MonitorType.Ping,
+        title: "Ping",
+        description:
+          "This monitor type does the basic ping test of an endpoint.",
+      },
+      // {
+      //     monitorType: MonitorType.Kubernetes,
+      //     title: 'Kubernetes',
+      //     description:
+      //         'This monitor types lets you monitor Kubernetes clusters.',
+      // },
+      {
+        monitorType: MonitorType.IP,
+        title: "IP",
+        description:
+          "This monitor type lets you monitor any IPv4 or IPv6 addresses.",
+      },
+      {
+        monitorType: MonitorType.IncomingRequest,
+        title: "Incoming Request",
+        description:
+          "This monitor type lets you ping OneUptime from any external device or service with a custom payload.",
+      },
+      {
+        monitorType: MonitorType.Port,
+        title: "Port",
+        description: "This monitor type lets you monitor any TCP or UDP port.",
+      },
+      {
+        monitorType: MonitorType.Server,
+        title: "Server / VM",
+        description:
+          "This monitor type lets you monitor any server, VM, or any machine.",
+      },
+      {
+        monitorType: MonitorType.SSLCertificate,
+        title: "SSL Certificate",
+        description:
+          "This monitor type lets you monitor SSL certificates of any domain.",
+      },
+      {
+        monitorType: MonitorType.SyntheticMonitor,
+        title: "Synthetic Monitor",
+        description:
+          "This monitor type lets you monitor your web application UI.",
+      },
+      {
+        monitorType: MonitorType.CustomJavaScriptCode,
+        title: "Custom JavaScript Code",
+        description:
+          "This monitor type lets you run custom JavaScript code on a schedule.",
+      },
+    ];
+
+    return monitorTypeProps;
+  }
+
+  public static getDescription(monitorType: MonitorType): string {
+    const monitorTypeProps: Array<MonitorTypeProps> =
+      this.getAllMonitorTypeProps().filter((item: MonitorTypeProps) => {
+        return item.monitorType === monitorType;
+      });
+
+    if (!monitorTypeProps[0]) {
+      throw new BadDataException(
+        `${monitorType} does not have monitorType props`,
+      );
     }
 
-    public static getDescription(monitorType: MonitorType): string {
-        const monitorTypeProps: Array<MonitorTypeProps> =
-            this.getAllMonitorTypeProps().filter((item: MonitorTypeProps) => {
-                return item.monitorType === monitorType;
-            });
+    return monitorTypeProps[0].description;
+  }
 
-        if (!monitorTypeProps[0]) {
-            throw new BadDataException(
-                `${monitorType} does not have monitorType props`
-            );
-        }
+  public static getTitle(monitorType: MonitorType): string {
+    const monitorTypeProps: Array<MonitorTypeProps> =
+      this.getAllMonitorTypeProps().filter((item: MonitorTypeProps) => {
+        return item.monitorType === monitorType;
+      });
 
-        return monitorTypeProps[0].description;
+    if (!monitorTypeProps[0]) {
+      throw new BadDataException(
+        `${monitorType} does not have monitorType props`,
+      );
     }
 
-    public static getTitle(monitorType: MonitorType): string {
-        const monitorTypeProps: Array<MonitorTypeProps> =
-            this.getAllMonitorTypeProps().filter((item: MonitorTypeProps) => {
-                return item.monitorType === monitorType;
-            });
-
-        if (!monitorTypeProps[0]) {
-            throw new BadDataException(
-                `${monitorType} does not have monitorType props`
-            );
-        }
-
-        return monitorTypeProps[0].title;
-    }
-
-    public static isProbableMonitors(monitorType: MonitorType): boolean {
-        const isProbeableMonitor: boolean =
-            monitorType === MonitorType.API ||
-            monitorType === MonitorType.Website ||
-            monitorType === MonitorType.IP ||
-            monitorType === MonitorType.Ping ||
-            monitorType === MonitorType.Port ||
-            monitorType === MonitorType.SSLCertificate ||
-            monitorType === MonitorType.SyntheticMonitor ||
-            monitorType === MonitorType.CustomJavaScriptCode;
-        return isProbeableMonitor;
-    }
-
-    public static getActiveMonitorTypes(): Array<MonitorType> {
-        return [
-            MonitorType.API,
-            MonitorType.Website,
-            MonitorType.IP,
-            MonitorType.Ping,
-            MonitorType.Port,
-            MonitorType.SSLCertificate,
-            MonitorType.SyntheticMonitor,
-            MonitorType.CustomJavaScriptCode,
-            MonitorType.IncomingRequest,
-            MonitorType.Server,
-        ];
-    }
-
-    public static doesMonitorTypeHaveDocumentation(
-        monitorType: MonitorType
-    ): boolean {
-        return (
-            monitorType === MonitorType.IncomingRequest ||
-            monitorType === MonitorType.Server
-        );
-    }
-
-    public static doesMonitorTypeHaveInterval(
-        monitorType: MonitorType
-    ): boolean {
-        return this.isProbableMonitors(monitorType);
-    }
-
-    public static doesMonitorTypeHaveCriteria(
-        monitorType: MonitorType
-    ): boolean {
-        return monitorType !== MonitorType.Manual;
-    }
+    return monitorTypeProps[0].title;
+  }
+
+  public static isProbableMonitors(monitorType: MonitorType): boolean {
+    const isProbeableMonitor: boolean =
+      monitorType === MonitorType.API ||
+      monitorType === MonitorType.Website ||
+      monitorType === MonitorType.IP ||
+      monitorType === MonitorType.Ping ||
+      monitorType === MonitorType.Port ||
+      monitorType === MonitorType.SSLCertificate ||
+      monitorType === MonitorType.SyntheticMonitor ||
+      monitorType === MonitorType.CustomJavaScriptCode;
+    return isProbeableMonitor;
+  }
+
+  public static getActiveMonitorTypes(): Array<MonitorType> {
+    return [
+      MonitorType.API,
+      MonitorType.Website,
+      MonitorType.IP,
+      MonitorType.Ping,
+      MonitorType.Port,
+      MonitorType.SSLCertificate,
+      MonitorType.SyntheticMonitor,
+      MonitorType.CustomJavaScriptCode,
+      MonitorType.IncomingRequest,
+      MonitorType.Server,
+    ];
+  }
+
+  public static doesMonitorTypeHaveDocumentation(
+    monitorType: MonitorType,
+  ): boolean {
+    return (
+      monitorType === MonitorType.IncomingRequest ||
+      monitorType === MonitorType.Server
+    );
+  }
+
+  public static doesMonitorTypeHaveInterval(monitorType: MonitorType): boolean {
+    return this.isProbableMonitors(monitorType);
+  }
+
+  public static doesMonitorTypeHaveCriteria(monitorType: MonitorType): boolean {
+    return monitorType !== MonitorType.Manual;
+  }
 }

package/Types/Monitor/SSLMonitor/SslMonitorResponse.ts

@@ -1,14 +1,14 @@
 export default interface SslMonitorResponse {
-    isSelfSigned?: boolean;
-    createdAt?: Date;
-    expiresAt?: Date;
-    commonName?: string;
-    organizationalUnit?: string;
-    organization?: string;
-    locality?: string;
-    state?: string;
-    country?: string;
-    serialNumber?: string;
-    fingerprint?: string;
-    fingerprint256?: string;
+  isSelfSigned?: boolean;
+  createdAt?: Date;
+  expiresAt?: Date;
+  commonName?: string;
+  organizationalUnit?: string;
+  organization?: string;
+  locality?: string;
+  state?: string;
+  country?: string;
+  serialNumber?: string;
+  fingerprint?: string;
+  fingerprint256?: string;
 }

package/Types/Monitor/ServerMonitor/ServerMonitorResponse.ts

@@ -1,16 +1,16 @@
-import BasicInfrastructureMetrics from '../../Infrastructure/BasicMetrics';
-import ObjectID from '../../ObjectID';
+import BasicInfrastructureMetrics from "../../Infrastructure/BasicMetrics";
+import ObjectID from "../../ObjectID";
 
 export interface ServerProcess {
-    pid: number;
-    name: string;
-    command: string;
+  pid: number;
+  name: string;
+  command: string;
 }
 
 export default interface ServerMonitorResponse {
-    monitorId: ObjectID;
-    basicInfrastructureMetrics?: BasicInfrastructureMetrics | undefined;
-    requestReceivedAt: Date;
-    onlyCheckRequestReceivedAt: boolean;
-    processes?: ServerProcess[] | undefined;
+  monitorId: ObjectID;
+  basicInfrastructureMetrics?: BasicInfrastructureMetrics | undefined;
+  requestReceivedAt: Date;
+  onlyCheckRequestReceivedAt: boolean;
+  processes?: ServerProcess[] | undefined;
 }

package/Types/Monitor/SyntheticMonitors/BrowserType.ts

@@ -1,3 +1,3 @@
-import BrowserType from '../../BrowserType';
+import BrowserType from "../../BrowserType";
 
 export default BrowserType;

package/Types/Monitor/SyntheticMonitors/ScreenSizeType.ts

@@ -1,3 +1,3 @@
-import ScreenSizeType from '../../ScreenSizeType';
+import ScreenSizeType from "../../ScreenSizeType";
 
 export default ScreenSizeType;

package/Types/Monitor/SyntheticMonitors/Screenshot.ts

@@ -1,4 +1,4 @@
-import Dictionary from '../../Dictionary';
+import Dictionary from "../../Dictionary";
 
 export type Screenshot = string; // base 64 encoded screenshots
 

package/Types/Monitor/SyntheticMonitors/SyntheticMonitorResponse.ts

@@ -1,11 +1,11 @@
-import CustomCodeMonitorResponse from '../CustomCodeMonitor/CustomCodeMonitorResponse';
-import BrowserType from './BrowserType';
-import ScreenSizeType from './ScreenSizeType';
-import Screenshots from './Screenshot';
+import CustomCodeMonitorResponse from "../CustomCodeMonitor/CustomCodeMonitorResponse";
+import BrowserType from "./BrowserType";
+import ScreenSizeType from "./ScreenSizeType";
+import Screenshots from "./Screenshot";
 
 export default interface SyntheticMonitorResponse
-    extends CustomCodeMonitorResponse {
-    screenshots?: Screenshots | undefined; // base 64 encoded screenshots
-    browserType: BrowserType;
-    screenSizeType: ScreenSizeType;
+  extends CustomCodeMonitorResponse {
+  screenshots?: Screenshots | undefined; // base 64 encoded screenshots
+  browserType: BrowserType;
+  screenSizeType: ScreenSizeType;
 }

package/Types/Name.ts

@@ -1,86 +1,86 @@
-import DatabaseProperty from './Database/DatabaseProperty';
-import BadDataException from './Exception/BadDataException';
-import { JSONObject, ObjectType } from './JSON';
-import { FindOperator } from 'typeorm';
+import DatabaseProperty from "./Database/DatabaseProperty";
+import BadDataException from "./Exception/BadDataException";
+import { JSONObject, ObjectType } from "./JSON";
+import { FindOperator } from "typeorm";
 
 export default class Name extends DatabaseProperty {
-    private _title: string = '';
-    public get title(): string {
-        return this._title;
-    }
-    public set title(v: string) {
-        this._title = v;
-    }
-
-    private _name: string = '';
-    public get name(): string {
-        return this._name;
-    }
-    public set name(v: string) {
-        this._name = v;
-    }
+  private _title: string = "";
+  public get title(): string {
+    return this._title;
+  }
+  public set title(v: string) {
+    this._title = v;
+  }
 
-    public constructor(name: string) {
-        super();
-        this.name = name;
-    }
+  private _name: string = "";
+  public get name(): string {
+    return this._name;
+  }
+  public set name(v: string) {
+    this._name = v;
+  }
 
-    public getFirstName(): string {
-        return this.name.split(' ')[0] || '';
-    }
+  public constructor(name: string) {
+    super();
+    this.name = name;
+  }
 
-    public getLastName(): string {
-        if (this.name.split(' ').length > 1) {
-            return this.name.split(' ')[this.name.split(' ').length - 1] || '';
-        }
-        return '';
-    }
+  public getFirstName(): string {
+    return this.name.split(" ")[0] || "";
+  }
 
-    public getMiddleName(): string {
-        if (this.name.split(' ').length > 2) {
-            return this.name.split(' ')[1] || '';
-        }
-        return '';
+  public getLastName(): string {
+    if (this.name.split(" ").length > 1) {
+      return this.name.split(" ")[this.name.split(" ").length - 1] || "";
     }
+    return "";
+  }
 
-    public override toString(): string {
-        return this.name;
+  public getMiddleName(): string {
+    if (this.name.split(" ").length > 2) {
+      return this.name.split(" ")[1] || "";
     }
+    return "";
+  }
 
-    public static override toDatabase(
-        value: Name | FindOperator<Name>
-    ): string | null {
-        if (value) {
-            if (typeof value === 'string') {
-                value = new Name(value);
-            }
+  public override toString(): string {
+    return this.name;
+  }
 
-            return value.toString();
-        }
+  public static override toDatabase(
+    value: Name | FindOperator<Name>,
+  ): string | null {
+    if (value) {
+      if (typeof value === "string") {
+        value = new Name(value);
+      }
 
-        return null;
+      return value.toString();
     }
 
-    public override toJSON(): JSONObject {
-        return {
-            _type: ObjectType.Name,
-            value: (this as Name).toString(),
-        };
-    }
+    return null;
+  }
 
-    public static override fromJSON(json: JSONObject): Name {
-        if (json['_type'] === ObjectType.Name) {
-            return new Name((json['value'] as string) || '');
-        }
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.Name,
+      value: (this as Name).toString(),
+    };
+  }
 
-        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+  public static override fromJSON(json: JSONObject): Name {
+    if (json["_type"] === ObjectType.Name) {
+      return new Name((json["value"] as string) || "");
     }
 
-    public static override fromDatabase(_value: string): Name | null {
-        if (_value) {
-            return new Name(_value);
-        }
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
 
-        return null;
+  public static override fromDatabase(_value: string): Name | null {
+    if (_value) {
+      return new Name(_value);
     }
+
+    return null;
+  }
 }

package/Types/NotificationRule/NotificationRuleType.ts

@@ -1,7 +1,7 @@
 enum NotificationRuleType {
-    ON_CALL_INCIDENT_CREATED = 'When incident is created during on call',
-    WHEN_USER_GOES_ON_CALL = 'When user goes on call',
-    WHEN_USER_GOES_OFF_CALL = 'When user goes off call',
+  ON_CALL_INCIDENT_CREATED = "When incident is created during on call",
+  WHEN_USER_GOES_ON_CALL = "When user goes on call",
+  WHEN_USER_GOES_OFF_CALL = "When user goes off call",
 }
 
 export default NotificationRuleType;