@oneuptime/common 7.0.2513 → 7.0.2550

package/Tests/Types/Database/ColumnLength.test.ts

@@ -1,55 +1,55 @@
-import ColumnLength from '../../../Types/Database/ColumnLength';
+import ColumnLength from "../../../Types/Database/ColumnLength";
 
-describe('enum ColumnLength', () => {
-    test('ColumnLength.Version', () => {
-        expect(ColumnLength.Version).toEqual(30);
-    });
+describe("enum ColumnLength", () => {
+  test("ColumnLength.Version", () => {
+    expect(ColumnLength.Version).toEqual(30);
+  });
 
-    test('ColumnLength.Slug', () => {
-        expect(ColumnLength.Slug).toEqual(100);
-    });
+  test("ColumnLength.Slug", () => {
+    expect(ColumnLength.Slug).toEqual(100);
+  });
 
-    test('ColumnLength.Email', () => {
-        expect(ColumnLength.Email).toEqual(100);
-    });
+  test("ColumnLength.Email", () => {
+    expect(ColumnLength.Email).toEqual(100);
+  });
 
-    test('ColumnLength.Color', () => {
-        expect(ColumnLength.Color).toEqual(7);
-    });
+  test("ColumnLength.Color", () => {
+    expect(ColumnLength.Color).toEqual(7);
+  });
 
-    test('ColumnLength.Name', () => {
-        expect(ColumnLength.Name).toEqual(50);
-    });
+  test("ColumnLength.Name", () => {
+    expect(ColumnLength.Name).toEqual(50);
+  });
 
-    test('ColumnLength.Description', () => {
-        expect(ColumnLength.Description).toEqual(500);
-    });
+  test("ColumnLength.Description", () => {
+    expect(ColumnLength.Description).toEqual(500);
+  });
 
-    test('ColumnLength.LongText', () => {
-        expect(ColumnLength.LongText).toEqual(500);
-    });
+  test("ColumnLength.LongText", () => {
+    expect(ColumnLength.LongText).toEqual(500);
+  });
 
-    test('ColumnLength.Password', () => {
-        expect(ColumnLength.Password).toEqual(500);
-    });
+  test("ColumnLength.Password", () => {
+    expect(ColumnLength.Password).toEqual(500);
+  });
 
-    test('ColumnLength.ShortURL', () => {
-        expect(ColumnLength.ShortURL).toEqual(100);
-    });
+  test("ColumnLength.ShortURL", () => {
+    expect(ColumnLength.ShortURL).toEqual(100);
+  });
 
-    test('ColumnLength.ShortText', () => {
-        expect(ColumnLength.ShortText).toEqual(100);
-    });
+  test("ColumnLength.ShortText", () => {
+    expect(ColumnLength.ShortText).toEqual(100);
+  });
 
-    test('ColumnLength.HashedString', () => {
-        expect(ColumnLength.HashedString).toEqual(64);
-    });
+  test("ColumnLength.HashedString", () => {
+    expect(ColumnLength.HashedString).toEqual(64);
+  });
 
-    test('ColumnLength.Phone', () => {
-        expect(ColumnLength.Phone).toEqual(30);
-    });
+  test("ColumnLength.Phone", () => {
+    expect(ColumnLength.Phone).toEqual(30);
+  });
 
-    test('ColumnLength.OTP', () => {
-        expect(ColumnLength.OTP).toEqual(8);
-    });
+  test("ColumnLength.OTP", () => {
+    expect(ColumnLength.OTP).toEqual(8);
+  });
 });

package/Tests/Types/Database/ColumnType.test.ts

@@ -1,103 +1,103 @@
-import ColumnType from '../../../Types/Database/ColumnType';
+import ColumnType from "../../../Types/Database/ColumnType";
 
-describe('enum ColumnType', () => {
-    test('ColumnType.Color should be varchar', () => {
-        expect(ColumnType.Color).toEqual('varchar');
-    });
+describe("enum ColumnType", () => {
+  test("ColumnType.Color should be varchar", () => {
+    expect(ColumnType.Color).toEqual("varchar");
+  });
 
-    test('ColumnType.Version', () => {
-        expect(ColumnType.Version).toEqual('varchar');
-    });
+  test("ColumnType.Version", () => {
+    expect(ColumnType.Version).toEqual("varchar");
+  });
 
-    test('ColumnType.Phone', () => {
-        expect(ColumnType.Phone).toEqual('varchar');
-    });
+  test("ColumnType.Phone", () => {
+    expect(ColumnType.Phone).toEqual("varchar");
+  });
 
-    test('ColumnType.HashedString', () => {
-        expect(ColumnType.HashedString).toEqual('varchar');
-    });
+  test("ColumnType.HashedString", () => {
+    expect(ColumnType.HashedString).toEqual("varchar");
+  });
 
-    test('ColumnType.Password', () => {
-        expect(ColumnType.Password).toEqual('varchar');
-    });
+  test("ColumnType.Password", () => {
+    expect(ColumnType.Password).toEqual("varchar");
+  });
 
-    test('ColumnType.Email', () => {
-        expect(ColumnType.Email).toEqual('varchar');
-    });
+  test("ColumnType.Email", () => {
+    expect(ColumnType.Email).toEqual("varchar");
+  });
 
-    test('ColumnType.Slug', () => {
-        expect(ColumnType.Slug).toEqual('varchar');
-    });
+  test("ColumnType.Slug", () => {
+    expect(ColumnType.Slug).toEqual("varchar");
+  });
 
-    test('ColumnType.Name', () => {
-        expect(ColumnType.Name).toEqual('varchar');
-    });
+  test("ColumnType.Name", () => {
+    expect(ColumnType.Name).toEqual("varchar");
+  });
 
-    test('ColumnType.Description', () => {
-        expect(ColumnType.Description).toEqual('varchar');
-    });
+  test("ColumnType.Description", () => {
+    expect(ColumnType.Description).toEqual("varchar");
+  });
 
-    test('ColumnType.ObjectID', () => {
-        expect(ColumnType.ObjectID).toEqual('uuid');
-    });
+  test("ColumnType.ObjectID", () => {
+    expect(ColumnType.ObjectID).toEqual("uuid");
+  });
 
-    test('ColumnType.ShortURL', () => {
-        expect(ColumnType.ShortURL).toEqual('varchar');
-    });
+  test("ColumnType.ShortURL", () => {
+    expect(ColumnType.ShortURL).toEqual("varchar");
+  });
 
-    test('ColumnType.LongURL', () => {
-        expect(ColumnType.LongURL).toEqual('text');
-    });
+  test("ColumnType.LongURL", () => {
+    expect(ColumnType.LongURL).toEqual("text");
+  });
 
-    test('ColumnType.ShortText', () => {
-        expect(ColumnType.ShortText).toEqual('varchar');
-    });
+  test("ColumnType.ShortText", () => {
+    expect(ColumnType.ShortText).toEqual("varchar");
+  });
 
-    test('ColumnType.OTP', () => {
-        expect(ColumnType.OTP).toEqual('varchar');
-    });
+  test("ColumnType.OTP", () => {
+    expect(ColumnType.OTP).toEqual("varchar");
+  });
 
-    test('ColumnType.LongText', () => {
-        expect(ColumnType.LongText).toEqual('varchar');
-    });
+  test("ColumnType.LongText", () => {
+    expect(ColumnType.LongText).toEqual("varchar");
+  });
 
-    test('ColumnType.VeryLongText', () => {
-        expect(ColumnType.VeryLongText).toEqual('text');
-    });
+  test("ColumnType.VeryLongText", () => {
+    expect(ColumnType.VeryLongText).toEqual("text");
+  });
 
-    test('ColumnType.Date', () => {
-        expect(ColumnType.Date).toEqual('timestamptz');
-    });
+  test("ColumnType.Date", () => {
+    expect(ColumnType.Date).toEqual("timestamptz");
+  });
 
-    test('ColumnType.Boolean', () => {
-        expect(ColumnType.Boolean).toEqual('boolean');
-    });
+  test("ColumnType.Boolean", () => {
+    expect(ColumnType.Boolean).toEqual("boolean");
+  });
 
-    test('ColumnType.Array', () => {
-        expect(ColumnType.Array).toEqual('simple-array');
-    });
+  test("ColumnType.Array", () => {
+    expect(ColumnType.Array).toEqual("simple-array");
+  });
 
-    test('ColumnType.SmallPositiveNumber', () => {
-        expect(ColumnType.SmallPositiveNumber).toEqual('smallint');
-    });
+  test("ColumnType.SmallPositiveNumber", () => {
+    expect(ColumnType.SmallPositiveNumber).toEqual("smallint");
+  });
 
-    test('ColumnType.PositiveNumber', () => {
-        expect(ColumnType.PositiveNumber).toEqual('integer');
-    });
+  test("ColumnType.PositiveNumber", () => {
+    expect(ColumnType.PositiveNumber).toEqual("integer");
+  });
 
-    test('ColumnType.BigPositiveNumber', () => {
-        expect(ColumnType.BigPositiveNumber).toEqual('bigint');
-    });
+  test("ColumnType.BigPositiveNumber", () => {
+    expect(ColumnType.BigPositiveNumber).toEqual("bigint");
+  });
 
-    test('ColumnType.SmallNumber', () => {
-        expect(ColumnType.SmallNumber).toEqual('smallint');
-    });
+  test("ColumnType.SmallNumber", () => {
+    expect(ColumnType.SmallNumber).toEqual("smallint");
+  });
 
-    test('ColumnType.Number', () => {
-        expect(ColumnType.Number).toEqual('integer');
-    });
+  test("ColumnType.Number", () => {
+    expect(ColumnType.Number).toEqual("integer");
+  });
 
-    test('ColumnType.BigNumber', () => {
-        expect(ColumnType.BigNumber).toEqual('bigint');
-    });
+  test("ColumnType.BigNumber", () => {
+    expect(ColumnType.BigNumber).toEqual("bigint");
+  });
 });

package/Tests/Types/Database/Columns.test.ts

@@ -1,22 +1,22 @@
-import Columns from '../../../Types/Database/Columns';
+import Columns from "../../../Types/Database/Columns";
 
-describe('class Columns', () => {
-    test('it should return a valid object if Columns is valid', () => {
-        expect(new Columns(['col1', 'col2'])).toBeInstanceOf(Columns);
-        expect(new Columns(['col1', 'col2']).columns).toStrictEqual([
-            'col1',
-            'col2',
-        ]);
-    });
+describe("class Columns", () => {
+  test("it should return a valid object if Columns is valid", () => {
+    expect(new Columns(["col1", "col2"])).toBeInstanceOf(Columns);
+    expect(new Columns(["col1", "col2"]).columns).toStrictEqual([
+      "col1",
+      "col2",
+    ]);
+  });
 
-    test('it should add column', () => {
-        const cols: Array<string> = ['col1', 'col2'];
-        new Columns(cols).addColumn('col3');
-        expect(new Columns(cols).columns).toContain('col3');
-    });
+  test("it should add column", () => {
+    const cols: Array<string> = ["col1", "col2"];
+    new Columns(cols).addColumn("col3");
+    expect(new Columns(cols).columns).toContain("col3");
+  });
 
-    test('it should return true if column is included', () => {
-        const cols: Array<string> = ['col1', 'col2'];
-        expect(new Columns(cols).hasColumn('col2')).toBeTruthy();
-    });
+  test("it should return true if column is included", () => {
+    const cols: Array<string> = ["col1", "col2"];
+    expect(new Columns(cols).hasColumn("col2")).toBeTruthy();
+  });
 });

package/Tests/Types/Database/CompareBase.test.ts

@@ -1,41 +1,41 @@
-import CompareBase from '../../../Types/Database/CompareBase';
-import BadDataException from '../../../Types/Exception/BadDataException';
-import { describe, expect, it } from '@jest/globals';
+import CompareBase from "../../../Types/Database/CompareBase";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { describe, expect, it } from "@jest/globals";
 
-describe('CompareBase', () => {
-    describe('toString', () => {
-        it('should return string representation of value', () => {
-            const compareBase: CompareBase = new CompareBase(10);
-            expect(compareBase.toString()).toBe('10');
-        });
+describe("CompareBase", () => {
+  describe("toString", () => {
+    it("should return string representation of value", () => {
+      const compareBase: CompareBase = new CompareBase(10);
+      expect(compareBase.toString()).toBe("10");
     });
+  });
 
-    describe('toNumber', () => {
-        it('should return value as number if it is a number', () => {
-            const compareBase: CompareBase = new CompareBase(10);
-            expect(compareBase.toNumber()).toBe(10);
-        });
+  describe("toNumber", () => {
+    it("should return value as number if it is a number", () => {
+      const compareBase: CompareBase = new CompareBase(10);
+      expect(compareBase.toNumber()).toBe(10);
+    });
 
-        it('should throw BadDataException if value is not a number', () => {
-            const compareBase: CompareBase = new CompareBase(new Date());
-            expect(() => {
-                return compareBase.toNumber();
-            }).toThrow(BadDataException);
-        });
+    it("should throw BadDataException if value is not a number", () => {
+      const compareBase: CompareBase = new CompareBase(new Date());
+      expect(() => {
+        return compareBase.toNumber();
+      }).toThrow(BadDataException);
     });
+  });
 
-    describe('toDate', () => {
-        it('should return value as date object if it is a date object', () => {
-            const date: Date = new Date();
-            const compareBase: CompareBase = new CompareBase(date);
-            expect(compareBase.toDate()).toBe(date);
-        });
+  describe("toDate", () => {
+    it("should return value as date object if it is a date object", () => {
+      const date: Date = new Date();
+      const compareBase: CompareBase = new CompareBase(date);
+      expect(compareBase.toDate()).toBe(date);
+    });
 
-        it('should throw BadDataException if value is not a date object', () => {
-            const compareBase: CompareBase = new CompareBase(10);
-            expect(() => {
-                return compareBase.toDate();
-            }).toThrow(BadDataException);
-        });
+    it("should throw BadDataException if value is not a date object", () => {
+      const compareBase: CompareBase = new CompareBase(10);
+      expect(() => {
+        return compareBase.toDate();
+      }).toThrow(BadDataException);
     });
+  });
 });

package/Tests/Types/Database/Date.test.ts

@@ -1,83 +1,81 @@
-import InBetween from '../../../Types/BaseDatabase/InBetween';
-import DatabaseDate from '../../../Types/Database/Date';
-import { JSONObject } from '../../../Types/JSON';
-import { describe, expect, it } from '@jest/globals';
-import moment from 'moment';
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import DatabaseDate from "../../../Types/Database/Date";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+import moment from "moment";
 
-describe('DatabaseDate', () => {
-    describe('asDateStartOfTheDayEndOfTheDayForDatabaseQuery', () => {
-        it('should return InBetween object for a valid Date input', () => {
-            const inputDate: Date = new Date('2023-10-24T12:00:00Z');
-            const result: JSONObject =
-                DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
-                    inputDate
-                ).toJSON();
+describe("DatabaseDate", () => {
+  describe("asDateStartOfTheDayEndOfTheDayForDatabaseQuery", () => {
+    it("should return InBetween object for a valid Date input", () => {
+      const inputDate: Date = new Date("2023-10-24T12:00:00Z");
+      const result: JSONObject =
+        DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
+          inputDate,
+        ).toJSON();
 
-            const expectedStart: string = moment(inputDate)
-                .startOf('day')
-                .format('YYYY-MM-DD HH:mm:ss');
-            const expectedEnd: string = moment(inputDate)
-                .endOf('day')
-                .format('YYYY-MM-DD HH:mm:ss');
-            expect(result).toEqual({
-                startValue: expectedStart,
-                endValue: expectedEnd,
-                _type: 'InBetween',
-            });
-        });
+      const expectedStart: string = moment(inputDate)
+        .startOf("day")
+        .format("YYYY-MM-DD HH:mm:ss");
+      const expectedEnd: string = moment(inputDate)
+        .endOf("day")
+        .format("YYYY-MM-DD HH:mm:ss");
+      expect(result).toEqual({
+        startValue: expectedStart,
+        endValue: expectedEnd,
+        _type: "InBetween",
+      });
+    });
 
-        it('should return InBetween object for a valid Date string input', () => {
-            const inputDate: string = '2023-10-24T12:00:00Z';
-            const result: JSONObject =
-                DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
-                    inputDate
-                ).toJSON();
-            const expectedStart: string = moment(inputDate)
-                .startOf('day')
-                .format('YYYY-MM-DD HH:mm:ss');
-            const expectedEnd: string = moment(inputDate)
-                .endOf('day')
-                .format('YYYY-MM-DD HH:mm:ss');
-            expect(result).toEqual({
-                startValue: expectedStart,
-                endValue: expectedEnd,
-                _type: 'InBetween',
-            });
-        });
+    it("should return InBetween object for a valid Date string input", () => {
+      const inputDate: string = "2023-10-24T12:00:00Z";
+      const result: JSONObject =
+        DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
+          inputDate,
+        ).toJSON();
+      const expectedStart: string = moment(inputDate)
+        .startOf("day")
+        .format("YYYY-MM-DD HH:mm:ss");
+      const expectedEnd: string = moment(inputDate)
+        .endOf("day")
+        .format("YYYY-MM-DD HH:mm:ss");
+      expect(result).toEqual({
+        startValue: expectedStart,
+        endValue: expectedEnd,
+        _type: "InBetween",
+      });
+    });
 
-        it('should handle invalid date string gracefully', () => {
-            const inputDate: string = 'invalid-date';
-            const result: JSONObject =
-                DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
-                    inputDate
-                ).toJSON();
-            expect(result).toEqual({
-                startValue: 'Invalid date',
-                endValue: 'Invalid date',
-                _type: 'InBetween',
-            });
-        });
+    it("should handle invalid date string gracefully", () => {
+      const inputDate: string = "invalid-date";
+      const result: JSONObject =
+        DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
+          inputDate,
+        ).toJSON();
+      expect(result).toEqual({
+        startValue: "Invalid date",
+        endValue: "Invalid date",
+        _type: "InBetween",
+      });
+    });
 
-        it('should handle empty string input gracefully', () => {
-            const inputDate: string = '';
-            const result: JSONObject =
-                DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
-                    inputDate
-                ).toJSON();
-            expect(result).toEqual({
-                startValue: 'Invalid date',
-                endValue: 'Invalid date',
-                _type: 'InBetween',
-            });
-        });
+    it("should handle empty string input gracefully", () => {
+      const inputDate: string = "";
+      const result: JSONObject =
+        DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
+          inputDate,
+        ).toJSON();
+      expect(result).toEqual({
+        startValue: "Invalid date",
+        endValue: "Invalid date",
+        _type: "InBetween",
+      });
+    });
 
-        it('should be a type of InBetween', () => {
-            const inputDate: string = '2023-10-24T12:00:00Z';
-            const result: InBetween =
-                DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
-                    inputDate
-                );
-            expect(result).toBeInstanceOf(InBetween);
-        });
+    it("should be a type of InBetween", () => {
+      const inputDate: string = "2023-10-24T12:00:00Z";
+      const result: InBetween =
+        DatabaseDate.asDateStartOfTheDayEndOfTheDayForDatabaseQuery(inputDate);
+      expect(result).toBeInstanceOf(InBetween);
     });
+  });
 });