feat: Implement EqualTo class and related tests for comparison functionality

APIReference/CodeExamples/DataTypes/EqualTo.md

@@ -1,6 +1,8 @@
 {
     "query": {
-        "name": "Hello", 
-        // other filters
+        "age": {
+            "_type": "EqualTo",
+            value: 10
+        }
     }
 }

Common/Tests/Types/Database/EqualTo.test.ts

@@ -0,0 +1,75 @@
+import EqualTo from "../../../Types/BaseDatabase/EqualTo";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("EqualTo", () => {
+  it("should create an EqualTo object with a valid value", () => {
+    const value: string = "oneuptime";
+    const equalObj: EqualTo<string> = new EqualTo<string>(value);
+    expect(equalObj.value).toBe(value);
+  });
+
+  it("should get the value property of an EqualTo object", () => {
+    const value: string = "oneuptime";
+    const equalObj: EqualTo<string> = new EqualTo<string>(value);
+    expect(equalObj.value).toBe(value);
+  });
+
+  it("should set the value property of an EqualTo object", () => {
+    const equalObj: EqualTo<string> = new EqualTo<string>("oldValue");
+    equalObj.value = "newValue";
+    expect(equalObj.value).toBe("newValue");
+  });
+
+  it("should return the correct string representation using toString method", () => {
+    const equalObj: EqualTo<string> = new EqualTo<string>("oneuptime");
+    expect(equalObj.toString()).toBe("oneuptime");
+  });
+
+  it("should generate the correct JSON representation using toJSON method", () => {
+    const equalObj: EqualTo<string> = new EqualTo<string>("oneuptime");
+    const expectedJSON: JSONObject = {
+      _type: "EqualTo",
+      value: "oneuptime",
+    };
+    expect(equalObj.toJSON()).toEqual(expectedJSON);
+  });
+
+  it("should create an EqualTo object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "EqualTo",
+      value: "oneuptime",
+    };
+    const equalObj: EqualTo<string> = EqualTo.fromJSON(jsonInput);
+    expect(equalObj.value).toBe("oneuptime");
+  });
+
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: "oneuptime",
+    };
+    expect(() => {
+      return EqualTo.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
+
+  it("should be a type of EqualTo", () => {
+    const equalObj: EqualTo<string> = new EqualTo("oneuptime");
+    expect(equalObj).toBeInstanceOf(EqualTo);
+  });
+
+  it("should handle numeric values", () => {
+    const value: number = 42;
+    const equalObj: EqualTo<number> = new EqualTo<number>(value);
+    expect(equalObj.value).toBe(value);
+    expect(equalObj.toString()).toBe("42");
+  });
+
+  it("should handle date values", () => {
+    const value: Date = new Date("2023-01-01");
+    const equalObj: EqualTo<Date> = new EqualTo<Date>(value);
+    expect(equalObj.value).toBe(value);
+  });
+});

Common/Tests/Types/JSON.test.ts

@@ -4,6 +4,7 @@ describe("ObjectType", () => {
   const expectedFields: Array<keyof typeof ObjectType> = [
     "ObjectID",
     "Name",
+    "EqualTo",
     "EqualToOrNull",
     "NotEqual",
     "Email",

Common/Types/BaseDatabase/EqualTo.ts

@@ -0,0 +1,31 @@
+import CompareBase, { CompareType } from "../Database/CompareBase";
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+
+export default class EqualTo<T extends CompareType> extends CompareBase<T> {
+  public constructor(value: T) {
+    super(value);
+    this.value = value;
+  }
+
+  public override toString(): string {
+    return this.value.toString();
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.EqualTo,
+      value: (this as EqualTo<T>).toString(),
+    };
+  }
+
+  public static override fromJSON<T extends CompareType>(
+    json: JSONObject,
+  ): EqualTo<T> {
+    if (json["_type"] === ObjectType.EqualTo) {
+      return new EqualTo(json["value"] as T);
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

Common/Types/JSON.ts

@@ -1,6 +1,7 @@
 import Hostname from "./API/Hostname";
 import Route from "./API/Route";
 import URL from "./API/URL";
+import EqualTo from "./BaseDatabase/EqualTo";
 import EqualToOrNull from "./BaseDatabase/EqualToOrNull";
 import GreaterThan from "./BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "./BaseDatabase/GreaterThanOrEqual";
@@ -35,6 +36,7 @@ export enum ObjectType {
   ObjectID = "ObjectID",
   Decimal = "Decimal",
   Name = "Name",
+  EqualTo = "EqualTo",
   EqualToOrNull = "EqualToOrNull",
   MonitorSteps = "MonitorSteps",
   MonitorStep = "MonitorStep",
@@ -115,6 +117,8 @@ export type JSONValue =
   | Domain
   | Array<Domain>
   | Array<Search<string>>
+  | EqualTo<CompareType>
+  | Array<EqualTo<CompareType>>
   | EqualToOrNull<CompareType>
   | Array<EqualToOrNull<CompareType>>
   | NotEqual<CompareType>

Common/Types/SerializableObjectDictionary.ts

@@ -1,6 +1,7 @@
 import Hostname from "./API/Hostname";
 import Route from "./API/Route";
 import URL from "./API/URL";
+import EqualTo from "./BaseDatabase/EqualTo";
 import EqualToOrNull from "./BaseDatabase/EqualToOrNull";
 import GreaterThan from "./BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "./BaseDatabase/GreaterThanOrEqual";
@@ -38,6 +39,7 @@ const SerializableObjectDictionary: Dictionary<any> = {
   [ObjectType.DateTime]: OneUptimeDate,
   [ObjectType.ObjectID]: ObjectID,
   [ObjectType.Name]: Name,
+  [ObjectType.EqualTo]: EqualTo,
   [ObjectType.EqualToOrNull]: EqualToOrNull,
   [ObjectType.MonitorSteps]: MonitorSteps,
   [ObjectType.MonitorStep]: MonitorStep,