@oneuptime/common 1.0.0

package/Models/FileModel.ts

@@ -0,0 +1,111 @@
+import { Column } from 'typeorm';
+import ColumnAccessControl from '../Types/Database/AccessControl/ColumnAccessControl';
+import ColumnLength from '../Types/Database/ColumnLength';
+import ColumnType from '../Types/Database/ColumnType';
+import SlugifyColumn from '../Types/Database/SlugifyColumn';
+import TableColumn from '../Types/Database/TableColumn';
+import TableColumnType from '../Types/Database/TableColumnType';
+import MimeType from '../Types/File/MimeType';
+import ObjectID from '../Types/ObjectID';
+import Permission from '../Types/Permission';
+import BaseModel from './BaseModel';
+
+@SlugifyColumn('name', 'slug')
+export default class FileModel extends BaseModel {
+    public constructor(id?: ObjectID) {
+        super(id);
+    }
+
+    public override isFileModel(): boolean {
+        return true;
+    }
+
+    @ColumnAccessControl({
+        create: [Permission.CurrentUser],
+        read: [Permission.CurrentUser],
+        update: [],
+    })
+    @TableColumn({
+        required: true,
+        type: TableColumnType.File,
+        canReadOnRelationQuery: true,
+    })
+    @Column({
+        nullable: false,
+        type: ColumnType.File,
+    })
+    public file?: Buffer = undefined;
+
+    @ColumnAccessControl({
+        create: [Permission.CurrentUser],
+        read: [Permission.CurrentUser],
+        update: [],
+    })
+    @TableColumn({
+        required: true,
+        type: TableColumnType.ShortText,
+        title: 'Name',
+        description: 'Any friendly name of this object',
+        canReadOnRelationQuery: true,
+    })
+    @Column({
+        nullable: false,
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+    })
+    public name?: string = undefined;
+
+    @ColumnAccessControl({
+        create: [Permission.CurrentUser],
+        read: [Permission.CurrentUser],
+        update: [],
+    })
+    @TableColumn({
+        required: true,
+        type: TableColumnType.ShortText,
+        canReadOnRelationQuery: true,
+    })
+    @Column({
+        nullable: false,
+        type: ColumnType.ShortText,
+        length: ColumnLength.ShortText,
+    })
+    public type?: MimeType = undefined;
+
+    @ColumnAccessControl({
+        create: [Permission.CurrentUser],
+        read: [Permission.CurrentUser],
+        update: [],
+    })
+    @TableColumn({
+        required: true,
+        unique: true,
+        type: TableColumnType.Slug,
+        canReadOnRelationQuery: true,
+    })
+    @Column({
+        nullable: false,
+        type: ColumnType.Slug,
+        length: ColumnLength.Slug,
+    })
+    public slug?: string = undefined;
+
+    @ColumnAccessControl({
+        create: [Permission.CurrentUser],
+        read: [Permission.CurrentUser],
+        update: [],
+    })
+    @TableColumn({
+        required: true,
+        isDefaultValueColumn: true,
+        type: TableColumnType.Slug,
+        canReadOnRelationQuery: true,
+    })
+    @Column({
+        nullable: false,
+        default: true,
+        type: ColumnType.Slug,
+        length: ColumnLength.Slug,
+    })
+    public isPublic?: boolean = undefined;
+}

package/Models/GlobalConfig.ts

@@ -0,0 +1,8 @@
+import ObjectID from '../Types/ObjectID';
+import BaseModel from './BaseModel';
+
+export default class GlobalConfig extends BaseModel {
+    public constructor(id?: ObjectID) {
+        super(id);
+    }
+}

package/Models/TenantModel.ts

@@ -0,0 +1,12 @@
+import ObjectID from '../Types/ObjectID';
+import BaseModel from './BaseModel';
+
+export default class TenantModel extends BaseModel {
+    public constructor(id?: ObjectID) {
+        super(id);
+    }
+
+    public override isTenantModel(): boolean {
+        return true;
+    }
+}

package/Models/UserModel.ts

@@ -0,0 +1,12 @@
+import ObjectID from '../Types/ObjectID';
+import BaseModel from './BaseModel';
+
+export default class UserModel extends BaseModel {
+    public constructor(id?: ObjectID) {
+        super(id);
+    }
+
+    public override isUserModel(): boolean {
+        return true;
+    }
+}

package/ServiceRoute.ts

@@ -0,0 +1,31 @@
+import Route from './Types/API/Route';
+
+export const homeRoute: Route = new Route('/');
+
+export const AppApiRoute: Route = new Route('/api');
+
+export const IdentityRoute: Route = new Route('/identity');
+
+export const FileRoute: Route = new Route('/file');
+
+export const StatusPageRoute: Route = new Route('/status-page');
+
+export const LinkShortenerRoute: Route = new Route('/l');
+
+export const DashboardRoute: Route = new Route('/dashboard');
+
+export const IntegrationRoute: Route = new Route('/integration');
+
+export const NotificationRoute: Route = new Route('/notification');
+
+export const AccountsRoute: Route = new Route('/accounts');
+
+export const WorkflowRoute: Route = new Route('/workflow');
+
+export const ApiReferenceRoute: Route = new Route('/reference');
+
+export const AdminDashboardRoute: Route = new Route('/admin');
+
+export const IngestorRoute: Route = new Route('/ingestor');
+
+export const RealtimeRoute: Route = new Route('/realtime/socket');

package/Tests/Types/API/ErrorResponse.test.ts

@@ -0,0 +1,16 @@
+import ErrorResponse from '../../../Types/API/HTTPErrorResponse';
+describe('ErrorResponse', () => {
+    test('should return a valid error response object', () => {
+        const errorResponseObject: ErrorResponse = new ErrorResponse(
+            500,
+            {
+                error: 'Internal Server Error',
+            },
+            {}
+        );
+        expect(errorResponseObject.statusCode).toBe(500);
+        expect(errorResponseObject.data).toEqual({
+            error: 'Internal Server Error',
+        });
+    });
+});

package/Tests/Types/API/HTTPErrorResponse.test.ts

@@ -0,0 +1,61 @@
+import HTTPErrorResponse from '../../../Types/API/HTTPErrorResponse';
+
+describe('HTTPErrorResponse', () => {
+    it('should return an empty string when data is null', () => {
+        const httpResponse: HTTPErrorResponse = new HTTPErrorResponse(
+            404,
+            { data: null },
+            {}
+        );
+        expect(httpResponse.message).toBe('');
+    });
+
+    it('should return the message from the "data" property if present', () => {
+        const httpResponse: HTTPErrorResponse = new HTTPErrorResponse(
+            200,
+            { data: 'Data message' },
+            {}
+        );
+        expect(httpResponse.message).toBe('Data message');
+    });
+
+    it('should return the message from the "message" property if present', () => {
+        const httpResponse: HTTPErrorResponse = new HTTPErrorResponse(
+            200,
+            { message: 'Message message' },
+            {}
+        );
+        expect(httpResponse.message).toBe('Message message');
+    });
+
+    it('should return the message from the "error" property if no other message properties are present', () => {
+        const httpResponse: HTTPErrorResponse = new HTTPErrorResponse(
+            500,
+            { error: 'Error message' },
+            {}
+        );
+        expect(httpResponse.message).toBe('Error message');
+    });
+
+    it('should return an empty string when no relevant message properties are present', () => {
+        const httpResponse: HTTPErrorResponse = new HTTPErrorResponse(
+            204,
+            { otherProperty: 'Other message' },
+            {}
+        );
+        expect(httpResponse.message).toBe('');
+    });
+
+    it('should prioritize "data" > "message" > "error" when multiple message properties are present', () => {
+        const httpResponse: HTTPErrorResponse = new HTTPErrorResponse(
+            201,
+            {
+                data: 'Data message',
+                message: 'Message message',
+                error: 'Error message',
+            },
+            {}
+        );
+        expect(httpResponse.message).toBe('Data message');
+    });
+});

package/Tests/Types/API/HTTPMethod.test.ts

@@ -0,0 +1,16 @@
+import HTTPMethod from '../../../Types/API/HTTPMethod';
+
+describe('HTTPMethod', () => {
+    test('HTTPMethod.GET should be GET', () => {
+        expect(HTTPMethod.GET).toBe('GET');
+    });
+    test('HTTPMethod.POST should be POST', () => {
+        expect(HTTPMethod.POST).toBe('POST');
+    });
+    test('HTTPMethod.PUT should be PUT', () => {
+        expect(HTTPMethod.PUT).toBe('PUT');
+    });
+    test('HTTPMethod.DELETE should be DELETE', () => {
+        expect(HTTPMethod.DELETE).toBe('DELETE');
+    });
+});

package/Tests/Types/API/Headers.test.ts

@@ -0,0 +1,14 @@
+import Headers from '../../../Types/API/Headers';
+import Faker from '../../../Utils/Faker';
+describe('Headers', () => {
+    test('should compile', () => {
+        const apiKey: string = Faker.randomNumbers(16);
+        const headers: Headers = {
+            accept: 'application/json',
+            'x-api-key': apiKey,
+        };
+        expect(headers['accept']).toBe('application/json');
+        expect(headers['x-api-key']).toEqual(apiKey);
+        expect(headers['undefined']).toBe(undefined);
+    });
+});

package/Tests/Types/API/Hostname.test.ts

@@ -0,0 +1,21 @@
+import Hostname from '../../../Types/API/Hostname';
+import BadDataException from '../../../Types/Exception/BadDataException';
+describe('Hostname', () => {
+    test('new Hostname(hostname) should throw an error if invalid hostname is given', () => {
+        expect(() => {
+            return new Hostname('undefined undefined');
+        }).toThrowError(BadDataException);
+        expect(() => {
+            return new Hostname('localhost 5000');
+        }).toThrow(BadDataException);
+        expect(() => {
+            new Hostname('localhost:5000').hostname = 'localhost 6000';
+        }).toThrow(BadDataException);
+    });
+    test('new Hostname(hostname) should return a valid object', () => {
+        const hostnameObject: Hostname = new Hostname('localhost:5000');
+        expect(hostnameObject.hostname).toBeTruthy();
+        expect(hostnameObject.hostname).toBe('localhost:5000');
+        expect(hostnameObject.toString()).toBe('localhost:5000');
+    });
+});

package/Tests/Types/API/Protocal.test.ts

@@ -0,0 +1,19 @@
+import Protocol from '../../../Types/API/Protocol';
+
+describe('Protocol', () => {
+    test('Protocol.HTTPS should be https://', () => {
+        expect(Protocol.HTTPS).toBe('https://');
+    });
+    test('Protocol.HTTP should be https://', () => {
+        expect(Protocol.HTTP).toBe('http://');
+    });
+    test('Protocol.WS should be ws://', () => {
+        expect(Protocol.WS).toBe('ws://');
+    });
+    test('Protocol.WSS should be ws://', () => {
+        expect(Protocol.WSS).toBe('wss://');
+    });
+    test('Protocol.MONGO_DB should be mongodb://', () => {
+        expect(Protocol.MONGO_DB).toBe('mongodb://');
+    });
+});

package/Tests/Types/API/Response.test.ts

@@ -0,0 +1,21 @@
+import Response from '../../../Types/API/HTTPResponse';
+import { JSONObject } from '../../../Types/JSON';
+
+describe('Response()', () => {
+    test('should return a valid response object', () => {
+        const responseObject: Response<JSONObject> = new Response(
+            200,
+            {
+                welcome: 'here',
+            },
+            {}
+        );
+        expect(responseObject.statusCode).toBe(200);
+        expect(responseObject.data).toEqual({ welcome: 'here' });
+        const responseObjectArray: Response<Array<JSONObject>> = new Response<
+            Array<JSONObject>
+        >(200, [{ welcome: 'here' }], {});
+        expect(responseObjectArray.statusCode).toBe(200);
+        expect(responseObjectArray.data).toEqual([{ welcome: 'here' }]);
+    });
+});

package/Tests/Types/API/ResponseType.test.ts

@@ -0,0 +1,12 @@
+import ResponseType from '../../../Types/API/ResponseType';
+describe('ResponseType', () => {
+    test('ResponseType.CSV to be csv', () => {
+        expect(ResponseType.CSV).toBe('csv');
+    });
+    test('ResponseType.HTML to be json', () => {
+        expect(ResponseType.HTML).toBe('html');
+    });
+    test('ResponseType.HTML to be', () => {
+        expect(ResponseType.JSON).toBe('json');
+    });
+});

package/Tests/Types/API/Route.test.ts

@@ -0,0 +1,29 @@
+import Route from '../../../Types/API/Route';
+import BadDataException from '../../../Types/Exception/BadDataException';
+describe('Route', () => {
+    test('new Route() should throw an error if invalid route is passed', () => {
+        expect(() => {
+            return new Route('api test');
+        }).toThrowError(BadDataException);
+        expect(() => {
+            return new Route('api\test');
+        }).toThrowError(BadDataException);
+        expect(() => {
+            return new Route('api`test');
+        }).toThrowError(BadDataException);
+        expect(() => {
+            return new Route('/api|test');
+        }).toThrowError(BadDataException);
+    });
+    test('new Route() should throw an error if invalid route is passed', () => {
+        const route: Route = new Route('/api/test');
+        expect(() => {
+            route.route = 'api`test';
+        }).toThrowError(BadDataException);
+    });
+    test('Route.toString() should return valid string', () => {
+        expect(new Route('/api/test').toString()).toBe('/api/test');
+        expect(new Route('/api#test').toString()).toBe('/api#test');
+        expect(new Route('/api-test').toString()).toBe('/api-test');
+    });
+});

package/Tests/Types/API/StatusCode.test.ts

@@ -0,0 +1,25 @@
+import StatusCode from '../../../Types/API/StatusCode';
+import BadDataException from '../../../Types/Exception/BadDataException';
+describe('Route', () => {
+    test('new StatusCode should throw if number is not passed', () => {
+        expect(() => {
+            return new StatusCode('invalid');
+        }).toThrowError(BadDataException);
+        expect(() => {
+            return new StatusCode(-400);
+        }).toThrowError(BadDataException);
+        expect(() => {
+            return new StatusCode('-400');
+        }).toThrowError(BadDataException);
+    });
+    test('Route.toString() should return valid  statuscode string', () => {
+        expect(new StatusCode('200').toString()).toEqual('200');
+        expect(new StatusCode('100').toString()).toEqual('100');
+        expect(new StatusCode(400).toString()).toEqual('400');
+    });
+    test('Route.toNumber() should return valid  statuscode number', () => {
+        expect(new StatusCode('200').toNumber()).toEqual(200);
+        expect(new StatusCode('100').toNumber()).toEqual(100);
+        expect(new StatusCode('500').toNumber()).toEqual(500);
+    });
+});

package/Tests/Types/API/URL.test.ts

@@ -0,0 +1,42 @@
+import Hostname from '../../../Types/API/Hostname';
+import Protocol from '../../../Types/API/Protocol';
+import Route from '../../../Types/API/Route';
+import URL from '../../../Types/API/URL';
+
+describe('URL', () => {
+    test('new URL() should return a valid object', () => {
+        const url: URL = new URL(
+            Protocol.HTTPS,
+            new Hostname('localhost:5000'),
+            new Route('/api/test')
+        );
+        expect(url.hostname).toBeInstanceOf(Hostname);
+        expect(url.protocol).toBe('https://');
+        expect(url.route).toBeInstanceOf(Route);
+        expect(url.isHttps()).toBe(true);
+        expect(url.toString).toBeTruthy();
+    });
+    test('URL.fromString should create URL object', () => {
+        let url: URL = URL.fromString('https://localhost:5000/api/test');
+        expect(url).toBeInstanceOf(URL);
+        expect(url.protocol).toBe('https://');
+        url = URL.fromString('mongodb://localhost:27017/test');
+        expect(url).toBeInstanceOf(URL);
+        expect(url.protocol).toBe('mongodb://');
+        url = URL.fromString('ws://localhost:5000/api/test');
+        expect(url).toBeInstanceOf(URL);
+        expect(url.protocol).toBe('ws://');
+        url = URL.fromString('wss://localhost:5000/api/test');
+        expect(url).toBeInstanceOf(URL);
+        expect(url.protocol).toBe('wss://');
+    });
+
+    test('URL.toString should return a valid URL', () => {
+        const url: URL = new URL(
+            Protocol.HTTPS,
+            new Hostname('localhost:5000'),
+            new Route('/api/test')
+        );
+        expect(url.toString()).toBe('https://localhost:5000/api/test');
+    });
+});

package/Tests/Types/Alerts/AlertEventType.test.ts

@@ -0,0 +1,49 @@
+import AlertEventType from '../../../Types/Alerts/AlertEventType';
+
+describe('AlertEventType', () => {
+    test('AlertEventType.Identified to be Identified', () => {
+        expect(AlertEventType.Identified).toBe('Identified');
+    });
+    test('AlertEventType.Acknowledged to Acknowledged', () => {
+        expect(AlertEventType.Acknowledged).toBe('Acknowledged');
+    });
+    test('AlertEventType.Resolved to Resolved', () => {
+        expect(AlertEventType.Resolved).toBe('Resolved');
+    });
+    test('AlertEventType.InvestigationNoteCreated to Investigation note created', () => {
+        expect(AlertEventType.InvestigationNoteCreated).toBe(
+            'Investigation note created'
+        );
+    });
+    test('AlertEventType.InvestigationNoteUpdated to Investigation note updated', () => {
+        expect(AlertEventType.InvestigationNoteUpdated).toBe(
+            'Investigation note updated'
+        );
+    });
+    test('AlertEventType.ScheduledMaintenanceCreated to Scheduled maintenance created', () => {
+        expect(AlertEventType.ScheduledMaintenanceCreated).toBe(
+            'Scheduled maintenance created'
+        );
+    });
+    test('AlertEventType.ScheduledMaintenanceNoteCreated to Scheduled maintenance note Created', () => {
+        expect(AlertEventType.ScheduledMaintenanceNoteCreated).toBe(
+            'Scheduled maintenance note created'
+        );
+    });
+
+    test('AlertEventType.ScheduledMaintenanceResolved to scheduled maintenance resolved', () => {
+        expect(AlertEventType.ScheduledMaintenanceResolved).toBe(
+            'Scheduled maintenance resolved'
+        );
+    });
+    test('AlertEventType.Acknowledged to Scheduled maintenance cancelled', () => {
+        expect(AlertEventType.ScheduledMaintenanceCancelled).toBe(
+            'Scheduled maintenance cancelled'
+        );
+    });
+    test('AlertEventType.AnnouncementNotificationCreated to Announcement notification created', () => {
+        expect(AlertEventType.AnnouncementNotificationCreated).toBe(
+            'Announcement notification created'
+        );
+    });
+});

package/Tests/Types/Alerts/AlertType.test.ts

@@ -0,0 +1,19 @@
+import AlertType from '../../../Types/Alerts/AlertType';
+
+describe('AlertType', () => {
+    test('AlertType.Email to be Email', () => {
+        expect(AlertType.Webhook).toBe('Webhook');
+    });
+    test('AlertType.Acknowledged to Acknowledged', () => {
+        expect(AlertType.Email).toBe('Email');
+    });
+    test('AlertType.SMS to SMS', () => {
+        expect(AlertType.SMS).toBe('SMS');
+    });
+    test('AlertType.Call to Call', () => {
+        expect(AlertType.Call).toBe('Call');
+    });
+    test('AlertType.PushNotification to PushNotification', () => {
+        expect(AlertType.PushNotification).toBe('PushNotification');
+    });
+});

package/Tests/Types/AppEnvironment.test.ts

@@ -0,0 +1,12 @@
+import AppEnvironment from '../../Types/AppEnvironment';
+describe('AppEnvironment', () => {
+    test('AppEnvironment.Production should be production', () => {
+        expect(AppEnvironment.Production).toEqual('production');
+    });
+    test('AppEnvironment.Development should be production', () => {
+        expect(AppEnvironment.Development).toEqual('development');
+    });
+    test('AppEnvironment.Test should be test', () => {
+        expect(AppEnvironment.Test).toEqual('test');
+    });
+});

package/Tests/Types/ApplicationLog/ApplicationLogType.test.ts

@@ -0,0 +1,13 @@
+import ApplicationLogType from '../../../Types/ApplicationLog/ApplicationLogType';
+
+describe('ApplicationLogType', () => {
+    test('ApplicationLogType.Info to be Info', () => {
+        expect(ApplicationLogType.Info).toBe('Info');
+    });
+    test('ApplicationLogType.Error to Error', () => {
+        expect(ApplicationLogType.Error).toBe('Error');
+    });
+    test('ApplicationLogType.Warning to Warning', () => {
+        expect(ApplicationLogType.Warning).toBe('Warning');
+    });
+});

package/Tests/Types/ArrayUtil.test.ts

@@ -0,0 +1,90 @@
+import ArrayUtil from '../../Types/ArrayUtil';
+
+describe('ArrayUtil.isEqual', () => {
+    const equalArrays: Array<[Array<any>, Array<any>]> = [
+        [[], []],
+        [[1], [1]],
+        [
+            [1, 2],
+            [1, 2],
+        ],
+        [
+            [1, 2, 3],
+            [3, 2, 1], // different order
+        ],
+        [
+            [undefined, function () {}],
+            [null, null],
+        ],
+        [
+            [true, true, false],
+            [true, false, true],
+        ],
+        [[new Map([['foo', 'bar']])], [{}]],
+        [[[1]], [[1]]],
+        [[{ a: 1 }], [{ a: 1 }]],
+        [[{ a: undefined, b: function () {} }], [{}]],
+        [[new Date(2000, 1, 1)], [new Date(2000, 1, 1)]],
+    ];
+
+    test.each(equalArrays)('isEqual(%p, %p) is true', (a: any[], b: any[]) => {
+        expect(ArrayUtil.isEqual(a, b)).toBe(true);
+        expect(ArrayUtil.isEqual(b, a)).toBe(true);
+    });
+
+    const nonEqualArrays: Array<[Array<any>, Array<any>]> = [
+        [[1], []],
+        [[1], [2]],
+        [
+            [1, 2],
+            [2, 3],
+        ],
+        [[[1]], [[2]]],
+        [
+            [true, true, false],
+            [true, false, false],
+        ],
+        [[{ a: 1 }], [{ a: 2 }]],
+        [[{ a: 1, b: 2 }], [{ b: 2, a: 1 }]], // JSON.stringify maintains key order
+        [[new Date(2000, 1, 1)], [new Date(2000, 1, 2)]],
+    ];
+
+    test.each(nonEqualArrays)(
+        'isEqual(%p, %p) is false',
+        (a: any[], b: any[]) => {
+            expect(ArrayUtil.isEqual(a, b)).toBe(false);
+            expect(ArrayUtil.isEqual(b, a)).toBe(false);
+        }
+    );
+
+    test('should not mutate arguments', () => {
+        const a: Array<number> = [3, 1, 2];
+        const b: Array<number> = [1, 3, 2];
+
+        expect(ArrayUtil.isEqual(a, b)).toBe(true);
+
+        // Jest does not sort elements before performing the equality test
+        expect(a).toEqual([3, 1, 2]);
+        expect(b).toEqual([1, 3, 2]);
+    });
+});
+
+describe('ArrayUtil.sortByFieldName', () => {
+    type compareFn = (a: any, b: any) => number;
+
+    test('should return a compare function that sorts an array of objects by field name', () => {
+        const sortByFoo: compareFn = ArrayUtil.sortByFieldName('foo');
+        type Foo = {
+            foo: number;
+        };
+
+        const items: Array<Foo> = [{ foo: 42 }, { foo: 1 }, { foo: 13 }];
+        items.sort(sortByFoo);
+
+        expect(
+            items.map((v: Foo) => {
+                return v.foo;
+            })
+        ).toEqual([1, 13, 42]);
+    });
+});