@oneuptime/common 7.0.2525 → 7.0.2570

package/Models/FileModel.ts

@@ -1,111 +1,111 @@
-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';
-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";
+import { Column } from "typeorm";
 
-@SlugifyColumn('name', 'slug')
+@SlugifyColumn("name", "slug")
 export default class FileModel extends BaseModel {
-    public constructor(id?: ObjectID) {
-        super(id);
-    }
+  public constructor(id?: ObjectID) {
+    super(id);
+  }
 
-    public override isFileModel(): boolean {
-        return true;
-    }
+  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.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,
+    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,
+    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,
+    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;
+  @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

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

package/Models/TenantModel.ts

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

package/Models/UserModel.ts

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

package/ServiceRoute.ts

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

package/Tests/MockType.ts

@@ -0,0 +1,9 @@
+export type MockFunction = jest.Mock<any, any>;
+
+type GetJestMockFunction = () => MockFunction;
+
+const getJestMockFunction: GetJestMockFunction = (): MockFunction => {
+  return jest.fn() as MockFunction;
+};
+
+export default getJestMockFunction;

package/Tests/Spy.ts

@@ -0,0 +1,11 @@
+type GetJestSpyOnFunction = (
+  obj: any,
+  method: string,
+) => jest.SpyInstance<any, any>;
+
+export const getJestSpyOn: GetJestSpyOnFunction = (
+  obj: any,
+  method: string,
+): jest.SpyInstance<any, any> => {
+  return jest.spyOn(obj, method) as jest.SpyInstance<any, any>;
+};

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

@@ -1,17 +1,17 @@
-import ErrorResponse from '../../../Types/API/HTTPErrorResponse';
+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',
-        });
+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

@@ -1,62 +1,62 @@
-import HTTPErrorResponse from '../../../Types/API/HTTPErrorResponse';
-import { describe, expect, it } from '@jest/globals';
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import { describe, expect, it } from "@jest/globals";
 
-describe('HTTPErrorResponse', () => {
-    it('should return an empty string when data is null', () => {
-        const httpResponse: HTTPErrorResponse = new HTTPErrorResponse(
-            404,
-            { data: null },
-            {}
-        );
-        expect(httpResponse.message).toBe('');
-    });
+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 "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 "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 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 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');
-    });
+  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

@@ -1,16 +1,16 @@
-import HTTPMethod from '../../../Types/API/HTTPMethod';
+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');
-    });
+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

@@ -1,15 +1,15 @@
-import Headers from '../../../Types/API/Headers';
-import Faker from '../../../Utils/Faker';
+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);
-    });
+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

@@ -1,22 +1,22 @@
-import Hostname from '../../../Types/API/Hostname';
-import BadDataException from '../../../Types/Exception/BadDataException';
+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');
-    });
+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");
+  });
 });