@oneuptime/common 1.0.0

package/Tests/Types/Countries.test.ts

@@ -0,0 +1,303 @@
+import Countries from '../../Types/Countries';
+
+describe('enum Countries', () => {
+    test('each country should have a valid corresponding name ', () => {
+        expect(Countries['Afghanistan']).toEqual('Afghanistan');
+        expect(Countries['Åland Islands']).toEqual('Åland Islands');
+        expect(Countries['Albania']).toEqual('Albania');
+        expect(Countries['Algeria']).toEqual('Algeria');
+        expect(Countries['American Samoa']).toEqual('American Samoa');
+        expect(Countries['Andorra']).toEqual('Andorra');
+        expect(Countries['Angola']).toEqual('Angola');
+        expect(Countries['Anguilla']).toEqual('Anguilla');
+        expect(Countries['Antarctica']).toEqual('Antarctica');
+        expect(Countries['Antigua and Barbuda']).toEqual('Antigua and Barbuda');
+        expect(Countries['Argentina']).toEqual('Argentina');
+        expect(Countries['Armenia']).toEqual('Armenia');
+        expect(Countries['Aruba']).toEqual('Aruba');
+        expect(Countries['Australia']).toEqual('Australia');
+        expect(Countries['Austria']).toEqual('Austria');
+        expect(Countries['Azerbaijan']).toEqual('Azerbaijan');
+        expect(Countries['Bahamas']).toEqual('Bahamas');
+        expect(Countries['Bahrain']).toEqual('Bahrain');
+        expect(Countries['Bangladesh']).toEqual('Bangladesh');
+        expect(Countries['Barbados']).toEqual('Barbados');
+        expect(Countries['Belarus']).toEqual('Belarus');
+        expect(Countries['Belgium']).toEqual('Belgium');
+        expect(Countries['Belize']).toEqual('Belize');
+        expect(Countries['Benin']).toEqual('Benin');
+        expect(Countries['Bermuda']).toEqual('Bermuda');
+        expect(Countries['Bhutan']).toEqual('Bhutan');
+        expect(Countries['Bolivia']).toEqual('Bolivia');
+        expect(Countries['Bosnia and Herzegovina']).toEqual(
+            'Bosnia and Herzegovina'
+        );
+        expect(Countries['Botswana']).toEqual('Botswana');
+        expect(Countries['Bouvet Island']).toEqual('Bouvet Island');
+        expect(Countries['Brazil']).toEqual('Brazil');
+        expect(Countries['British Indian Ocean Territory']).toEqual(
+            'British Indian Ocean Territory'
+        );
+        expect(Countries['Brunei Darussalam']).toEqual('Brunei Darussalam');
+        expect(Countries['Bulgaria']).toEqual('Bulgaria');
+        expect(Countries['Burkina Faso']).toEqual('Burkina Faso');
+        expect(Countries['Burundi']).toEqual('Burundi');
+        expect(Countries['Cambodia']).toEqual('Cambodia');
+        expect(Countries['Cameroon']).toEqual('Cameroon');
+        expect(Countries['Canada']).toEqual('Canada');
+        expect(Countries['Cape Verde']).toEqual('Cape Verde');
+        expect(Countries['Cayman Islands']).toEqual('Cayman Islands');
+        expect(Countries['Central African Republic']).toEqual(
+            'Central African Republic'
+        );
+        expect(Countries['Chad']).toEqual('Chad');
+        expect(Countries['Chile']).toEqual('Chile');
+        expect(Countries['China']).toEqual('China');
+        expect(Countries['Christmas Island']).toEqual('Christmas Island');
+        expect(Countries['Cocos (Keeling) Islands']).toEqual(
+            'Cocos (Keeling) Islands'
+        );
+        expect(Countries['Colombia']).toEqual('Colombia');
+        expect(Countries['Comoros']).toEqual('Comoros');
+        expect(Countries['Congo']).toEqual('Congo');
+        expect(Countries['Congo, The Democratic Republic of the']).toEqual(
+            'Congo, The Democratic Republic of the'
+        );
+        expect(Countries['Cook Islands']).toEqual('Cook Islands');
+        expect(Countries['Costa Rica']).toEqual('Costa Rica');
+        expect(Countries["Cote d'Ivoire"]).toEqual("Cote d'Ivoire");
+        expect(Countries['Croatia']).toEqual('Croatia');
+        expect(Countries['Cuba']).toEqual('Cuba');
+        expect(Countries['Cyprus']).toEqual('Cyprus');
+        expect(Countries['Czech Republic']).toEqual('Czech Republic');
+        expect(Countries['Denmark']).toEqual('Denmark');
+        expect(Countries['Djibouti']).toEqual('Djibouti');
+        expect(Countries['Dominica']).toEqual('Dominica');
+        expect(Countries['Dominican Republic']).toEqual('Dominican Republic');
+        expect(Countries['Ecuador']).toEqual('Ecuador');
+        expect(Countries['Egypt']).toEqual('Egypt');
+        expect(Countries['El Salvador']).toEqual('El Salvador');
+        expect(Countries['Equatorial Guinea']).toEqual('Equatorial Guinea');
+        expect(Countries['Eritrea']).toEqual('Eritrea');
+        expect(Countries['Estonia']).toEqual('Estonia');
+        expect(Countries['Ethiopia']).toEqual('Ethiopia');
+        expect(Countries['Falkland Islands (Malvinas)']).toEqual(
+            'Falkland Islands (Malvinas)'
+        );
+        expect(Countries['Faroe Islands']).toEqual('Faroe Islands');
+        expect(Countries['Fiji']).toEqual('Fiji');
+        expect(Countries['Finland']).toEqual('Finland');
+        expect(Countries['France']).toEqual('France');
+        expect(Countries['French Guiana']).toEqual('French Guiana');
+        expect(Countries['French Polynesia']).toEqual('French Polynesia');
+        expect(Countries['French Southern Territories']).toEqual(
+            'French Southern Territories'
+        );
+        expect(Countries['Gabon']).toEqual('Gabon');
+        expect(Countries['Gambia']).toEqual('Gambia');
+        expect(Countries['Georgia']).toEqual('Georgia');
+        expect(Countries['Germany']).toEqual('Germany');
+        expect(Countries['Ghana']).toEqual('Ghana');
+        expect(Countries['Gibraltar']).toEqual('Gibraltar');
+        expect(Countries['Greece']).toEqual('Greece');
+        expect(Countries['Greenland']).toEqual('Greenland');
+        expect(Countries['Grenada']).toEqual('Grenada');
+        expect(Countries['Guadeloupe']).toEqual('Guadeloupe');
+        expect(Countries['Guam']).toEqual('Guam');
+        expect(Countries['Guatemala']).toEqual('Guatemala');
+        expect(Countries['Guernsey']).toEqual('Guernsey');
+        expect(Countries['Guinea']).toEqual('Guinea');
+        expect(Countries['Guinea-Bissau']).toEqual('Guinea-Bissau');
+        expect(Countries['Guyana']).toEqual('Guyana');
+        expect(Countries['Haiti']).toEqual('Haiti');
+        expect(Countries['Heard Island and Mcdonald Islands']).toEqual(
+            'Heard Island and Mcdonald Islands'
+        );
+        expect(Countries['Holy See (Vatican City State)']).toEqual(
+            'Holy See (Vatican City State)'
+        );
+        expect(Countries['Honduras']).toEqual('Honduras');
+        expect(Countries['Hong Kong']).toEqual('Hong Kong');
+        expect(Countries['Hungary']).toEqual('Hungary');
+        expect(Countries['Iceland']).toEqual('Iceland');
+        expect(Countries['India']).toEqual('India');
+        expect(Countries['Indonesia']).toEqual('Indonesia');
+        expect(Countries['Iran']).toEqual('Iran');
+        expect(Countries['Iraq']).toEqual('Iraq');
+        expect(Countries['Ireland']).toEqual('Ireland');
+        expect(Countries['Isle of Man']).toEqual('Isle of Man');
+        expect(Countries['Israel']).toEqual('Israel');
+        expect(Countries['Italy']).toEqual('Italy');
+        expect(Countries['Jamaica']).toEqual('Jamaica');
+        expect(Countries['Japan']).toEqual('Japan');
+        expect(Countries['Jersey']).toEqual('Jersey');
+        expect(Countries['Jordan']).toEqual('Jordan');
+        expect(Countries['Kazakhstan']).toEqual('Kazakhstan');
+        expect(Countries['Kenya']).toEqual('Kenya');
+        expect(Countries['Kiribati']).toEqual('Kiribati');
+        expect(Countries['South Korea']).toEqual('South Korea');
+        expect(Countries['North Korea']).toEqual('North Korea');
+        expect(Countries['Kuwait']).toEqual('Kuwait');
+        expect(Countries['Kyrgyzstan']).toEqual('Kyrgyzstan');
+        expect(Countries["Lao People's Democratic Republic"]).toEqual(
+            "Lao People's Democratic Republic"
+        );
+        expect(Countries['Latvia']).toEqual('Latvia');
+        expect(Countries['Lebanon']).toEqual('Lebanon');
+        expect(Countries['Lesotho']).toEqual('Lesotho');
+        expect(Countries['Liberia']).toEqual('Liberia');
+        expect(Countries['Libyan Arab Jamahiriya']).toEqual(
+            'Libyan Arab Jamahiriya'
+        );
+        expect(Countries['Liechtenstein']).toEqual('Liechtenstein');
+        expect(Countries['Lithuania']).toEqual('Lithuania');
+        expect(Countries['Luxembourg']).toEqual('Luxembourg');
+        expect(Countries['Macao']).toEqual('Macao');
+        expect(Countries['Macedonia']).toEqual('Macedonia');
+        expect(Countries['Madagascar']).toEqual('Madagascar');
+        expect(Countries['Malawi']).toEqual('Malawi');
+        expect(Countries['Malaysia']).toEqual('Malaysia');
+        expect(Countries['Maldives']).toEqual('Maldives');
+        expect(Countries['Mali']).toEqual('Mali');
+        expect(Countries['Malta']).toEqual('Malta');
+        expect(Countries['Marshall Islands']).toEqual('Marshall Islands');
+        expect(Countries['Martinique']).toEqual('Martinique');
+        expect(Countries['Mauritania']).toEqual('Mauritania');
+        expect(Countries['Mauritius']).toEqual('Mauritius');
+        expect(Countries['Mayotte']).toEqual('Mayotte');
+        expect(Countries['Mexico']).toEqual('Mexico');
+        expect(Countries['Micronesia']).toEqual('Micronesia');
+        expect(Countries['Moldova']).toEqual('Moldova');
+        expect(Countries['Monaco']).toEqual('Monaco');
+        expect(Countries['Mongolia']).toEqual('Mongolia');
+        expect(Countries['Montserrat']).toEqual('Montserrat');
+        expect(Countries['Morocco']).toEqual('Morocco');
+        expect(Countries['Mozambique']).toEqual('Mozambique');
+        expect(Countries['Myanmar']).toEqual('Myanmar');
+        expect(Countries['Namibia']).toEqual('Namibia');
+        expect(Countries['Nauru']).toEqual('Nauru');
+        expect(Countries['Nepal']).toEqual('Nepal');
+        expect(Countries['Netherlands']).toEqual('Netherlands');
+        expect(Countries['Netherlands Antilles']).toEqual(
+            'Netherlands Antilles'
+        );
+        expect(Countries['New Caledonia']).toEqual('New Caledonia');
+        expect(Countries['New Zealand']).toEqual('New Zealand');
+        expect(Countries['Nicaragua']).toEqual('Nicaragua');
+        expect(Countries['Niger']).toEqual('Niger');
+        expect(Countries['Nigeria']).toEqual('Nigeria');
+        expect(Countries['Niue']).toEqual('Niue');
+        expect(Countries['Norfolk Island']).toEqual('Norfolk Island');
+        expect(Countries['Northern Mariana Islands']).toEqual(
+            'Northern Mariana Islands'
+        );
+        expect(Countries['Norway']).toEqual('Norway');
+        expect(Countries['Oman']).toEqual('Oman');
+        expect(Countries['Pakistan']).toEqual('Pakistan');
+        expect(Countries['Palau']).toEqual('Palau');
+        expect(Countries['Palestine State']).toEqual('Palestine State');
+        expect(Countries['Panama']).toEqual('Panama');
+        expect(Countries['Papua New Guinea']).toEqual('Papua New Guinea');
+        expect(Countries['Paraguay']).toEqual('Paraguay');
+        expect(Countries['Peru']).toEqual('Peru');
+        expect(Countries['Philippines']).toEqual('Philippines');
+        expect(Countries['Pitcairn']).toEqual('Pitcairn');
+        expect(Countries['Poland']).toEqual('Poland');
+        expect(Countries['Portugal']).toEqual('Portugal');
+        expect(Countries['Puerto Rico']).toEqual('Puerto Rico');
+        expect(Countries['Qatar']).toEqual('Qatar');
+        expect(Countries['Reunion']).toEqual('Reunion');
+        expect(Countries['Romania']).toEqual('Romania');
+        expect(Countries['Russian Federation']).toEqual('Russian Federation');
+        expect(Countries['Rwanda']).toEqual('Rwanda');
+        expect(Countries['Saint Helena']).toEqual('Saint Helena');
+        expect(Countries['Saint Kitts and Nevis']).toEqual(
+            'Saint Kitts and Nevis'
+        );
+        expect(Countries['Saint Lucia']).toEqual('Saint Lucia');
+        expect(Countries['Saint Pierre and Miquelon']).toEqual(
+            'Saint Pierre and Miquelon'
+        );
+        expect(Countries['Saint Vincent and the Grenadines']).toEqual(
+            'Saint Vincent and the Grenadines'
+        );
+        expect(Countries['Samoa']).toEqual('Samoa');
+        expect(Countries['San Marino']).toEqual('San Marino');
+        expect(Countries['Sao Tome and Principe']).toEqual(
+            'Sao Tome and Principe'
+        );
+        expect(Countries['Saudi Arabia']).toEqual('Saudi Arabia');
+        expect(Countries['Senegal']).toEqual('Senegal');
+        expect(Countries['Serbia and Montenegro']).toEqual(
+            'Serbia and Montenegro'
+        );
+        expect(Countries['Seychelles']).toEqual('Seychelles');
+        expect(Countries['Sierra Leone']).toEqual('Sierra Leone');
+        expect(Countries['Singapore']).toEqual('Singapore');
+        expect(Countries['Slovakia']).toEqual('Slovakia');
+        expect(Countries['Slovenia']).toEqual('Slovenia');
+        expect(Countries['Solomon Islands']).toEqual('Solomon Islands');
+        expect(Countries['Somalia']).toEqual('Somalia');
+        expect(Countries['South Africa']).toEqual('South Africa');
+        expect(
+            Countries['South Georgia and the South Sandwich Islands']
+        ).toEqual('South Georgia and the South Sandwich Islands');
+        expect(Countries['Spain']).toEqual('Spain');
+        expect(Countries['Sri Lanka']).toEqual('Sri Lanka');
+        expect(Countries['Sudan']).toEqual('Sudan');
+        expect(Countries['Suriname']).toEqual('Suriname');
+        expect(Countries['Svalbard and Jan Mayen']).toEqual(
+            'Svalbard and Jan Mayen'
+        );
+        expect(Countries['Swaziland']).toEqual('Swaziland');
+        expect(Countries['Sweden']).toEqual('Sweden');
+        expect(Countries['Switzerland']).toEqual('Switzerland');
+        expect(Countries['Syrian Arab Republic']).toEqual(
+            'Syrian Arab Republic'
+        );
+        expect(Countries['Taiwan, Province of China']).toEqual(
+            'Taiwan, Province of China'
+        );
+        expect(Countries['Tajikistan']).toEqual('Tajikistan');
+        expect(Countries['Tanzania']).toEqual('Tanzania');
+        expect(Countries['Thailand']).toEqual('Thailand');
+        expect(Countries['Timor-Leste']).toEqual('Timor-Leste');
+        expect(Countries['Togo']).toEqual('Togo');
+        expect(Countries['Tokelau']).toEqual('Tokelau');
+        expect(Countries['Tonga']).toEqual('Tonga');
+        expect(Countries['Trinidad and Tobago']).toEqual('Trinidad and Tobago');
+        expect(Countries['Tunisia']).toEqual('Tunisia');
+        expect(Countries['Turkey']).toEqual('Turkey');
+        expect(Countries['Turkmenistan']).toEqual('Turkmenistan');
+        expect(Countries['Turks and Caicos Islands']).toEqual(
+            'Turks and Caicos Islands'
+        );
+        expect(Countries['Tuvalu']).toEqual('Tuvalu');
+        expect(Countries['Uganda']).toEqual('Uganda');
+        expect(Countries['Ukraine']).toEqual('Ukraine');
+        expect(Countries['United Arab Emirates']).toEqual(
+            'United Arab Emirates'
+        );
+        expect(Countries['United Kingdom']).toEqual('United Kingdom');
+        expect(Countries['United States']).toEqual('United States');
+        expect(Countries['United States Minor Outlying Islands']).toEqual(
+            'United States Minor Outlying Islands'
+        );
+        expect(Countries['Uruguay']).toEqual('Uruguay');
+        expect(Countries['Uzbekistan']).toEqual('Uzbekistan');
+        expect(Countries['Vanuatu']).toEqual('Vanuatu');
+        expect(Countries['Venezuela']).toEqual('Venezuela');
+        expect(Countries['Viet Nam']).toEqual('Viet Nam');
+        expect(Countries['Virgin Islands, British']).toEqual(
+            'Virgin Islands, British'
+        );
+        expect(Countries['Virgin Islands, U.S.']).toEqual(
+            'Virgin Islands, U.S.'
+        );
+        expect(Countries['Wallis and Futuna']).toEqual('Wallis and Futuna');
+        expect(Countries['Western Sahara']).toEqual('Western Sahara');
+        expect(Countries['Yemen']).toEqual('Yemen');
+        expect(Countries['Zambia']).toEqual('Zambia');
+        expect(Countries['Zimbabwe']).toEqual('Zimbabwe');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,22 @@
+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',
+        ]);
+    });
+
+    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();
+    });
+});

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

@@ -0,0 +1,40 @@
+import CompareBase from '../../../Types/Database/CompareBase';
+import BadDataException from '../../../Types/Exception/BadDataException';
+
+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);
+        });
+
+        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);
+        });
+
+        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

@@ -0,0 +1,82 @@
+import DatabaseDate from '../../../Types/Database/Date';
+import moment from 'moment';
+import InBetween from '../../../Types/BaseDatabase/InBetween';
+import { JSONObject } from '../../../Types/JSON';
+
+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',
+            });
+        });
+
+        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 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);
+        });
+    });
+});