@oneuptime/common 1.0.0

package/Types/API/URL.ts

@@ -0,0 +1,273 @@
+import Protocol from './Protocol';
+import Route from './Route';
+import Hostname from './Hostname';
+import DatabaseProperty from '../Database/DatabaseProperty';
+import { FindOperator } from 'typeorm';
+import Dictionary from '../Dictionary';
+import Typeof from '../Typeof';
+import Email from '../Email';
+import { JSONObject, ObjectType } from '../JSON';
+import BadDataException from '../Exception/BadDataException';
+
+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 _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);
+        }
+
+        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;
+                    }
+                }
+            }
+        }
+    }
+
+    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 &
+            }
+        }
+
+        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://', '');
+        }
+
+        if (url.startsWith('http://')) {
+            protocol = Protocol.HTTP;
+            url = url.replace('http://', '');
+        }
+
+        if (url.startsWith('wss://')) {
+            protocol = Protocol.WSS;
+            url = url.replace('wss://', '');
+        }
+
+        if (url.startsWith('ws://')) {
+            protocol = Protocol.WS;
+            url = url.replace('ws://', '');
+        }
+
+        if (url.startsWith('mongodb://')) {
+            protocol = Protocol.MONGO_DB;
+            url = url.replace('mongodb://', '');
+        }
+
+        if (url.startsWith('mailto:')) {
+            protocol = Protocol.MAIL;
+            url = url.replace('mailto:', '');
+        }
+
+        const hostname: Hostname = new Hostname(url.split('/')[0] || '');
+
+        let route: Route | undefined;
+
+        if (url.split('/').length > 1) {
+            const paths: Array<string> = url.split('/');
+            paths.shift();
+            route = new Route(paths.join('/').split('?')[0]);
+        }
+
+        const queryString: string | undefined = url.split('?')[1] || '';
+
+        return new URL(protocol, hostname, route, queryString);
+    }
+
+    public removeQueryString(): URL {
+        return URL.fromString(this.toString().split('?')[0] || '');
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.URL,
+            value: (this as URL).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): URL {
+        if (json['_type'] === ObjectType.URL) {
+            return URL.fromString((json['value'] as string) || '');
+        }
+
+        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()));
+        }
+
+        if (route instanceof Route) {
+            this.route.addRoute(route);
+        }
+
+        return this;
+    }
+
+    public addQueryParam(
+        paramName: string,
+        value: string,
+        encode?: boolean | undefined
+    ): URL {
+        if (encode) {
+            value = encodeURIComponent(value);
+        }
+
+        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)]
+            );
+        }
+
+        return null;
+    }
+
+    protected static override toDatabase(
+        value: URL | FindOperator<URL>
+    ): string | null {
+        if (value) {
+            if (typeof value === 'string') {
+                value = URL.fromString(value);
+            }
+
+            return value.toString();
+        }
+
+        return null;
+    }
+
+    protected static override fromDatabase(_value: string): URL | null {
+        if (_value) {
+            return URL.fromString(_value);
+        }
+
+        return null;
+    }
+}

package/Types/Alerts/AlertEventType.ts

@@ -0,0 +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',
+}
+
+export default AlertEventType;

package/Types/Alerts/AlertType.ts

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

package/Types/AnalyticsDatabase/AnalyticsTableEngine.ts

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

package/Types/AnalyticsDatabase/TableColumn.ts

@@ -0,0 +1,163 @@
+import { ColumnAccessControl } from '../BaseDatabase/AccessControl';
+import ColumnBillingAccessControl from '../BaseDatabase/ColumnBillingAccessControl';
+import TableColumnType from '../AnalyticsDatabase/TableColumnType';
+import { JSONValue } from '../JSON';
+import NestedModel from '../../AnalyticsModels/NestedModel';
+
+export default class AnalyticsTableColumn {
+    private _key: string = 'id';
+
+    public get key(): string {
+        return this._key;
+    }
+    public set key(v: string) {
+        this._key = v;
+    }
+
+    private _title: string = '';
+    public get title(): string {
+        return this._title;
+    }
+    public set title(v: string) {
+        this._title = v;
+    }
+
+    private _description: string = '';
+    public get description(): string {
+        return this._description;
+    }
+    public set description(v: string) {
+        this._description = v;
+    }
+
+    private _required: boolean = false;
+    public get required(): boolean {
+        return this._required;
+    }
+    public set required(v: boolean) {
+        this._required = v;
+    }
+
+    private _isTenantId: boolean = false;
+    public get isTenantId(): boolean {
+        return this._isTenantId;
+    }
+    public set isTenantId(v: boolean) {
+        this._isTenantId = v;
+    }
+
+    private _type: TableColumnType = TableColumnType.Text;
+    public get type(): TableColumnType {
+        return this._type;
+    }
+    public set type(v: TableColumnType) {
+        this._type = v;
+    }
+
+    private _forceGetDefaultValueOnCreate?:
+        | (() => Date | string | number | boolean)
+        | undefined;
+    public get forceGetDefaultValueOnCreate():
+        | (() => Date | string | number | boolean)
+        | undefined {
+        return this._forceGetDefaultValueOnCreate;
+    }
+    public set forceGetDefaultValueOnCreate(
+        v: (() => Date | string | number | boolean) | undefined
+    ) {
+        this._forceGetDefaultValueOnCreate = v;
+    }
+
+    private _defaultValue: JSONValue | undefined;
+    public get defaultValue(): JSONValue {
+        return this._defaultValue;
+    }
+    public set defaultValue(v: JSONValue) {
+        this._defaultValue = v;
+    }
+
+    public get isDefaultValueColumn(): boolean {
+        return Boolean(this.defaultValue !== undefined);
+    }
+
+    private _billingAccessControl?: ColumnBillingAccessControl | undefined;
+    public get billingAccessControl(): ColumnBillingAccessControl | undefined {
+        return this._billingAccessControl;
+    }
+    public set billingAccessControl(v: ColumnBillingAccessControl | undefined) {
+        this._billingAccessControl = v;
+    }
+
+    private _allowAccessIfSubscriptionIsUnpaid: boolean = false;
+    public get allowAccessIfSubscriptionIsUnpaid(): boolean {
+        return this._allowAccessIfSubscriptionIsUnpaid;
+    }
+    public set allowAccessIfSubscriptionIsUnpaid(v: boolean) {
+        this._allowAccessIfSubscriptionIsUnpaid = v;
+    }
+
+    private _accessControl: ColumnAccessControl | undefined;
+    public get accessControl(): ColumnAccessControl | undefined {
+        return this._accessControl;
+    }
+    public set accessControl(v: ColumnAccessControl | undefined) {
+        this._accessControl = v;
+    }
+
+    private _nestedModel?: NestedModel | undefined;
+    public get nestedModel(): NestedModel | undefined {
+        return this._nestedModel;
+    }
+    public set nestedModel(v: NestedModel | undefined) {
+        this._nestedModel = v;
+    }
+
+    private _nestedModelType?: { new (): NestedModel } | undefined;
+    public get nestedModelType(): { new (): NestedModel } | undefined {
+        return this._nestedModelType;
+    }
+    public set nestedModelType(v: { new (): NestedModel } | undefined) {
+        this._nestedModelType = v;
+    }
+
+    public constructor(data: {
+        key: string;
+        nestedModelType?: { new (): NestedModel } | undefined;
+        title: string;
+        description: string;
+        required: boolean;
+        defaultValue?: JSONValue | undefined;
+        type: TableColumnType;
+        billingAccessControl?: ColumnBillingAccessControl | undefined;
+        isTenantId?: boolean | undefined;
+        accessControl?: ColumnAccessControl | undefined;
+        allowAccessIfSubscriptionIsUnpaid?: boolean | undefined;
+        forceGetDefaultValueOnCreate?:
+            | (() => Date | string | number | boolean)
+            | undefined;
+    }) {
+        if (
+            data.type === TableColumnType.NestedModel &&
+            !data.nestedModelType
+        ) {
+            throw new Error('NestedModel is required when type is NestedModel');
+        }
+
+        this.accessControl = data.accessControl;
+        this.key = data.key;
+        this.title = data.title;
+        this.description = data.description;
+        this.required = data.required;
+        this.type = data.type;
+        this.isTenantId = data.isTenantId || false;
+        this.forceGetDefaultValueOnCreate = data.forceGetDefaultValueOnCreate;
+        this.defaultValue = data.defaultValue;
+        this.billingAccessControl = data.billingAccessControl;
+        this.allowAccessIfSubscriptionIsUnpaid =
+            data.allowAccessIfSubscriptionIsUnpaid || false;
+        if (data.nestedModelType) {
+            this.nestedModel = new data.nestedModelType();
+            this.nestedModelType = data.nestedModelType;
+        }
+    }
+}

package/Types/AnalyticsDatabase/TableColumnType.ts

@@ -0,0 +1,15 @@
+enum ColumnType {
+    ObjectID = 'Object ID',
+    Date = 'Date',
+    Boolean = 'Boolean',
+    Number = 'Number',
+    Text = 'Text',
+    NestedModel = 'Nested Model',
+    JSON = 'JSON',
+    Decimal = 'Decimal',
+    ArrayNumber = 'Array of Numbers',
+    ArrayText = 'Array of Text',
+    LongNumber = 'Long Number',
+}
+
+export default ColumnType;

package/Types/AppEnvironment.ts

@@ -0,0 +1,7 @@
+enum AppEnvironment {
+    Production = 'production',
+    Development = 'development',
+    Test = 'test',
+}
+
+export default AppEnvironment;

package/Types/ApplicationLog/ApplicationLogType.ts

@@ -0,0 +1,7 @@
+enum ApplicationLogType {
+    Info = 'Info',
+    Error = 'Error',
+    Warning = 'Warning',
+}
+
+export default ApplicationLogType;

package/Types/ArrayUtil.ts

@@ -0,0 +1,54 @@
+export default class ArrayUtil {
+    public static isEqual(a: Array<any>, b: Array<any>): boolean {
+        // Check if the arrays have the same length
+        if (a.length !== b.length) {
+            return false;
+        }
+
+        // Sort both arrays by their JSON representation
+        const sortedArr1: string = JSON.stringify([...a].sort());
+        const sortedArr2: string = JSON.stringify([...b].sort());
+
+        // Compare the sorted arrays
+        return sortedArr1 === sortedArr2;
+    }
+
+    public static sortByFieldName(
+        fieldName: string
+    ): (a: any, b: any) => number {
+        return (a: any, b: any): number => {
+            if (a[fieldName] < b[fieldName]) {
+                return -1;
+            }
+            if (a[fieldName] > b[fieldName]) {
+                return 1;
+            }
+            return 0;
+        };
+    }
+
+    public static distinctByFieldName(
+        array: Array<any>,
+        fieldName: string
+    ): Array<any> {
+        // Get the distinct values by field name of the array
+        const distinctValues: Array<any> = array
+            .map((item: any) => {
+                return item[fieldName];
+            })
+            .filter((value: any, index: number, self: Array<any>) => {
+                return self.indexOf(value) === index;
+            });
+
+        // Create a new array with the distinct values
+        const distinctArray: Array<any> = [];
+        for (const value of distinctValues) {
+            const item: any = array.find((item: any) => {
+                return item[fieldName] === value;
+            });
+            distinctArray.push(item);
+        }
+
+        return distinctArray;
+    }
+}

package/Types/BaseDatabase/AccessControl.ts

@@ -0,0 +1,11 @@
+import Permission from '../Permission';
+
+export interface ColumnAccessControl {
+    read: Array<Permission>;
+    create: Array<Permission>;
+    update: Array<Permission>;
+}
+
+export interface TableAccessControl extends ColumnAccessControl {
+    delete: Array<Permission>;
+}

package/Types/BaseDatabase/ColumnBillingAccessControl.ts

@@ -0,0 +1,7 @@
+import { PlanSelect } from '../Billing/SubscriptionPlan';
+
+export default interface ColumnBillingAccessControl {
+    create: PlanSelect;
+    read: PlanSelect;
+    update: PlanSelect;
+}

package/Types/BaseDatabase/DatabaseCommonInteractionProps.ts

@@ -0,0 +1,24 @@
+import { PlanSelect } from '../Billing/SubscriptionPlan';
+import Dictionary from '../Dictionary';
+import ObjectID from '../ObjectID';
+import {
+    UserGlobalAccessPermission,
+    UserTenantAccessPermission,
+} from '../Permission';
+import UserType from '../UserType';
+
+export default interface DatabaseCommonInteractionProps {
+    userId?: ObjectID | undefined;
+    userGlobalAccessPermission?: UserGlobalAccessPermission | undefined;
+    userTenantAccessPermission?:
+        | Dictionary<UserTenantAccessPermission> // tenantId <-> UserTenantAccessPermission
+        | undefined;
+    userType?: UserType | undefined;
+    tenantId?: ObjectID | undefined;
+    isRoot?: boolean | undefined;
+    isMultiTenantRequest?: boolean | undefined;
+    ignoreHooks?: boolean | undefined;
+    currentPlan?: PlanSelect | undefined;
+    isSubscriptionUnpaid?: boolean | undefined;
+    isMasterAdmin?: boolean | undefined;
+}

package/Types/BaseDatabase/DatabaseCommonInteractionPropsUtil.ts

@@ -0,0 +1,73 @@
+import Permission, { UserPermission } from '../Permission';
+import DatabaseCommonInteractionProps from './DatabaseCommonInteractionProps';
+
+export default class DatabaseCommonInteractionPropsUtil {
+    public static getUserPermissions(
+        props: DatabaseCommonInteractionProps
+    ): Array<UserPermission> {
+        // Check first if the user has Global Permissions.
+        // Global permissions includes all the tenantId user has access to.
+        // and it includes all the global permissions that applies to all the tenant, like PUBLIC.
+        if (!props.userGlobalAccessPermission) {
+            props.userGlobalAccessPermission = {
+                globalPermissions: [Permission.Public],
+                projectIds: [],
+                _type: 'UserGlobalAccessPermission',
+            };
+        }
+
+        // If the PUBLIC Permission is not found in global permissions, include it.
+        if (
+            props.userGlobalAccessPermission &&
+            !props.userGlobalAccessPermission.globalPermissions.includes(
+                Permission.Public
+            )
+        ) {
+            props.userGlobalAccessPermission.globalPermissions.push(
+                Permission.Public
+            ); // add public permission if not already.
+        }
+
+        // If the CurrentUser Permission is not found in global permissions, include it.
+        if (
+            props.userId &&
+            props.userGlobalAccessPermission &&
+            !props.userGlobalAccessPermission.globalPermissions.includes(
+                Permission.CurrentUser
+            )
+        ) {
+            props.userGlobalAccessPermission.globalPermissions.push(
+                Permission.CurrentUser
+            );
+        }
+
+        let userPermissions: Array<UserPermission> = [];
+
+        // Include global permission in userPermissions.
+
+        if (props.userGlobalAccessPermission) {
+            /// take global permissions.
+            userPermissions =
+                props.userGlobalAccessPermission.globalPermissions.map(
+                    (permission: Permission) => {
+                        return {
+                            permission: permission,
+                            labelIds: [],
+                            _type: 'UserPermission',
+                        };
+                    }
+                );
+        }
+
+        if (props.tenantId && props.userTenantAccessPermission) {
+            // Include Tenant Permission in userPermissions.
+            userPermissions = [
+                ...userPermissions,
+                ...(props.userTenantAccessPermission[props.tenantId.toString()]
+                    ?.permissions || []),
+            ];
+        }
+
+        return userPermissions;
+    }
+}

package/Types/BaseDatabase/DatabaseType.ts

@@ -0,0 +1,6 @@
+enum DatabaseType {
+    Database = 'Database',
+    AnalyticsDatabase = 'AnalyticsDatabase',
+}
+
+export default DatabaseType;

package/Types/BaseDatabase/EnableWorkflowOn.ts

@@ -0,0 +1,6 @@
+export default interface EnableWorkflowOn {
+    create?: boolean | undefined;
+    update?: boolean | undefined;
+    delete?: boolean | undefined;
+    read?: boolean | undefined;
+}