@oneuptime/common 7.0.4194 → 7.0.4222

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -131,6 +131,7 @@ import { MigrationName1743692467814 } from "./1743692467814-MigrationName";
 import { MigrationName1743714801105 } from "./1743714801105-MigrationName";
 import { MigrationName1744804990712 } from "./1744804990712-MigrationName";
 import { MigrationName1744809770336 } from "./1744809770336-MigrationName";
+import { MigrationName1747305098533 } from "./1747305098533-MigrationName";
 
 export default [
   InitialMigration,
@@ -266,4 +267,5 @@ export default [
   MigrationName1743714801105,
   MigrationName1744804990712,
   MigrationName1744809770336,
+  MigrationName1747305098533,
 ];

package/Server/Services/Index.ts

@@ -162,7 +162,10 @@ import OnCallDutyPolicyUserOverrideService from "./OnCallDutyPolicyUserOverrideS
 
 import MonitorLogService from "./MonitorLogService";
 
+import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
+
 const services: Array<BaseService> = [
+  OnCallDutyPolicyTimeLogService,
   AcmeCertificateService,
   PromoCodeService,
 

package/Server/Services/OnCallDutyPolicyEscalationRuleTeamService.ts

@@ -19,6 +19,8 @@ import OnCallDutyPolicyFeedService from "./OnCallDutyPolicyFeedService";
 import { OnCallDutyPolicyFeedEventType } from "../../Models/DatabaseModels/OnCallDutyPolicyFeed";
 import { Gray500, Red500 } from "../../Types/BrandColors";
 import Team from "../../Models/DatabaseModels/Team";
+import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
+import OneUptimeDate from "../../Types/Date";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -134,6 +136,17 @@ export class Service extends DatabaseService<Model> {
         eventType:
           NotificationSettingEventType.SEND_WHEN_USER_IS_ADDED_TO_ON_CALL_POLICY,
       });
+
+      // add start log
+      OnCallDutyPolicyTimeLogService.startTimeLogForUser({
+        userId: sendEmailToUserId,
+        onCallDutyPolicyId: createdModel.onCallDutyPolicy!.id!,
+        onCallDutyPolicyEscalationRuleId:
+          createdModel.onCallDutyPolicyEscalationRule!.id!,
+        projectId: createdModel.projectId!,
+        teamId: createdModel.teamId!,
+        startsAt: new Date(),
+      });
     }
 
     // add workspace message.
@@ -304,6 +317,18 @@ export class Service extends DatabaseService<Model> {
           eventType:
             NotificationSettingEventType.SEND_WHEN_USER_IS_REMOVED_FROM_ON_CALL_POLICY,
         });
+
+        // end time log
+        await OnCallDutyPolicyTimeLogService.endTimeLogForUser({
+          userId: sendEmailToUserId,
+          onCallDutyPolicyId: deletedItem.onCallDutyPolicy!.id!,
+          onCallDutyPolicyEscalationRuleId:
+            deletedItem.onCallDutyPolicyEscalationRule!.id!,
+
+          projectId: deletedItem.projectId!,
+          teamId: deletedItem.teamId!,
+          endsAt: OneUptimeDate.getCurrentDate(),
+        });
       }
     }
 

package/Server/Services/OnCallDutyPolicyEscalationRuleUserService.ts

@@ -18,6 +18,9 @@ import { OnCallDutyPolicyFeedEventType } from "../../Models/DatabaseModels/OnCal
 import { Gray500, Red500 } from "../../Types/BrandColors";
 import UserService from "./UserService";
 import User from "../../Models/DatabaseModels/User";
+import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
+import OneUptimeDate from "../../Types/Date";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -141,6 +144,20 @@ export class Service extends DatabaseService<Model> {
           notifyUserId: createdModel.createdByUserId! || undefined,
         },
       });
+
+      // also add on-call duty time log.
+      OnCallDutyPolicyTimeLogService.startTimeLogForUser({
+        projectId: projectId!,
+        onCallDutyPolicyId: onCallDutyPolicyId!,
+        onCallDutyPolicyEscalationRuleId:
+          createdModel.onCallDutyPolicyEscalationRule!.id!,
+        userId: createdModel.user!.id!,
+        startsAt: OneUptimeDate.getCurrentDate(),
+      }).catch((error: Error) => {
+        logger.error(
+          `Error starting time log for user ${createdModel.user?.id}: ${error}`,
+        );
+      });
     }
 
     return createdItem;
@@ -213,6 +230,18 @@ export class Service extends DatabaseService<Model> {
               notifyUserId: userId || undefined,
             },
           });
+
+          // also remove on-call duty time log.
+          OnCallDutyPolicyTimeLogService.endTimeLogForUser({
+            projectId: projectId,
+            onCallDutyPolicyId: onCallDutyPolicyId,
+            onCallDutyPolicyEscalationRuleId:
+              item.onCallDutyPolicyEscalationRule!.id!,
+            userId: userId,
+            endsAt: OneUptimeDate.getCurrentDate(),
+          }).catch((error: Error) => {
+            logger.error(`Error ending time log for user ${userId}: ${error}`);
+          });
         }
       }
     }

package/Server/Services/OnCallDutyPolicyScheduleService.ts

@@ -31,6 +31,9 @@ import logger from "../Utils/Logger";
 import OnCallDutyPolicyFeedService from "./OnCallDutyPolicyFeedService";
 import { OnCallDutyPolicyFeedEventType } from "../../Models/DatabaseModels/OnCallDutyPolicyFeed";
 import { Green500 } from "../../Types/BrandColors";
+import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnDelete } from "../Types/Database/Hooks";
 
 export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
   private layerUtil = new LayerUtil();
@@ -39,6 +42,38 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
     super(OnCallDutyPolicySchedule);
   }
 
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<OnCallDutyPolicySchedule>,
+  ): Promise<OnDelete<OnCallDutyPolicySchedule>> {
+    const callSchedules: Array<OnCallDutyPolicySchedule> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const schedule of callSchedules) {
+      OnCallDutyPolicyTimeLogService.endTimeForSchedule({
+        projectId: schedule.projectId!,
+        onCallDutyPolicyScheduleId: schedule.id!,
+        endsAt: OneUptimeDate.getCurrentDate(),
+      }).catch((err: Error) => {
+        logger.error(err);
+      });
+    }
+
+    return {
+      deleteBy: deleteBy,
+      carryForward: {},
+    };
+  }
+
   public async getOnCallSchedulesWhereUserIsOnCallDuty(data: {
     projectId: ObjectID;
     userId: ObjectID;
@@ -228,6 +263,25 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
               NotificationSettingEventType.SEND_WHEN_USER_IS_NO_LONGER_ACTIVE_ON_ON_CALL_ROSTER,
           });
 
+          // add end log for user.
+          OnCallDutyPolicyTimeLogService.endTimeLogForUser({
+            userId: sendEmailToUserId,
+            onCallDutyPolicyScheduleId: data.scheduleId,
+            onCallDutyPolicyEscalationRuleId:
+              escalationRule.onCallDutyPolicyEscalationRule!.id!,
+            onCallDutyPolicyId: escalationRule.onCallDutyPolicy!.id!,
+            projectId: projectId,
+            endsAt: OneUptimeDate.getCurrentDate(),
+          }).catch((err: Error) => {
+            logger.error(
+              "Error ending time log for user: " +
+                sendEmailToUserId.toString() +
+                " for schedule: " +
+                data.scheduleId.toString(),
+            );
+            logger.error(err);
+          });
+
           const onCallDutyPolicyId: ObjectID =
             escalationRule.onCallDutyPolicy!.id!;
 
@@ -316,6 +370,25 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
               NotificationSettingEventType.SEND_WHEN_USER_IS_ON_CALL_ROSTER,
           });
 
+          // add start log for user.
+          OnCallDutyPolicyTimeLogService.startTimeLogForUser({
+            userId: sendEmailToUserId,
+            onCallDutyPolicyScheduleId: data.scheduleId,
+            onCallDutyPolicyEscalationRuleId:
+              escalationRule.onCallDutyPolicyEscalationRule!.id!,
+            onCallDutyPolicyId: escalationRule.onCallDutyPolicy!.id!,
+            projectId: projectId,
+            startsAt: OneUptimeDate.getCurrentDate(),
+          }).catch((err: Error) => {
+            logger.error(
+              "Error starting time log for user: " +
+                sendEmailToUserId.toString() +
+                " for schedule: " +
+                data.scheduleId.toString(),
+            );
+            logger.error(err);
+          });
+
           const onCallDutyPolicyId: ObjectID =
             escalationRule.onCallDutyPolicy!.id!;
 

package/Server/Services/OnCallDutyPolicyTimeLogService.ts

@@ -0,0 +1,175 @@
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/OnCallDutyPolicyTimeLog";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async startTimeLogForUser(data: {
+    projectId: ObjectID;
+    onCallDutyPolicyId: ObjectID;
+    onCallDutyPolicyEscalationRuleId: ObjectID;
+    userId: ObjectID;
+    teamId?: ObjectID;
+    onCallDutyPolicyScheduleId?: ObjectID;
+    startsAt: Date;
+  }): Promise<Model> {
+    const {
+      onCallDutyPolicyId,
+      userId,
+      teamId,
+      onCallDutyPolicyScheduleId,
+      startsAt,
+    } = data;
+
+    // check if the time log already exists for the user.
+
+    const existingTimeLog: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        onCallDutyPolicyId,
+        onCallDutyPolicyEscalationRuleId: data.onCallDutyPolicyEscalationRuleId,
+        userId,
+        ...(teamId && { teamId }),
+        ...(onCallDutyPolicyScheduleId && { onCallDutyPolicyScheduleId }),
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (existingTimeLog) {
+      return existingTimeLog;
+    }
+
+    const timeLog: Model = new Model();
+    timeLog.onCallDutyPolicyId = onCallDutyPolicyId;
+    timeLog.userId = userId;
+    if (teamId) {
+      timeLog.teamId = teamId;
+    }
+    timeLog.onCallDutyPolicyEscalationRuleId =
+      data.onCallDutyPolicyEscalationRuleId;
+    if (onCallDutyPolicyScheduleId) {
+      timeLog.onCallDutyPolicyScheduleId = onCallDutyPolicyScheduleId;
+    }
+    timeLog.projectId = data.projectId;
+    timeLog.startsAt = startsAt;
+
+    return await this.create({
+      data: timeLog,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  public async endTimeForSchedule(data: {
+    projectId: ObjectID;
+    onCallDutyPolicyScheduleId: ObjectID;
+    endsAt: Date;
+  }): Promise<void> {
+    const { endsAt, onCallDutyPolicyScheduleId } = data;
+    await this.updateBy({
+      query: {
+        projectId: data.projectId,
+        onCallDutyPolicyScheduleId,
+      },
+      data: {
+        endsAt: endsAt,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  public async endTimeForTeam(data: {
+    projectId: ObjectID;
+    teamId: ObjectID;
+    endsAt: Date;
+  }): Promise<void> {
+    const { endsAt, teamId } = data;
+    await this.updateBy({
+      query: {
+        projectId: data.projectId,
+        teamId,
+      },
+
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      data: {
+        endsAt: endsAt,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  public async endTimeForUser(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    endsAt: Date;
+  }): Promise<void> {
+    const { endsAt, userId } = data;
+    await this.updateBy({
+      query: {
+        projectId: data.projectId,
+        userId,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      data: {
+        endsAt: endsAt,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  public async endTimeLogForUser(data: {
+    projectId: ObjectID;
+    onCallDutyPolicyId: ObjectID;
+    onCallDutyPolicyEscalationRuleId: ObjectID;
+    userId: ObjectID;
+    teamId?: ObjectID;
+    onCallDutyPolicyScheduleId?: ObjectID;
+    endsAt: Date;
+  }): Promise<void> {
+    const {
+      onCallDutyPolicyId,
+      userId,
+      teamId,
+      onCallDutyPolicyScheduleId,
+      endsAt,
+    } = data;
+
+    await this.updateBy({
+      query: {
+        projectId: data.projectId,
+        onCallDutyPolicyId,
+        onCallDutyPolicyEscalationRuleId: data.onCallDutyPolicyEscalationRuleId,
+        userId,
+        ...(teamId && { teamId }),
+        ...(onCallDutyPolicyScheduleId && { onCallDutyPolicyScheduleId }),
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      data: {
+        endsAt: endsAt,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+}
+
+export default new Service();

package/Server/Services/TeamMemberService.ts

@@ -34,6 +34,8 @@ import Project from "Common/Models/DatabaseModels/Project";
 import TeamMember from "Common/Models/DatabaseModels/TeamMember";
 import User from "Common/Models/DatabaseModels/User";
 import ProjectUserService from "./ProjectUserService";
+import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
+import OneUptimeDate from "../../Types/Date";
 
 export class TeamMemberService extends DatabaseService<TeamMember> {
   public constructor() {
@@ -280,6 +282,14 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
 
     // check if there's one member in the team.
     for (const member of members) {
+      OnCallDutyPolicyTimeLogService.endTimeForUser({
+        projectId: member.projectId!,
+        userId: member.userId!,
+        endsAt: OneUptimeDate.getCurrentDate(),
+      }).catch((err: Error) => {
+        logger.error(err);
+      });
+
       if (member.team?.shouldHaveAtLeastOneMember) {
         if (!member.hasAcceptedInvitation) {
           continue;

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -1541,7 +1541,7 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         [NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels]:
           undefined,
         [NotificationRuleConditionCheckOn.Monitors]: [
-          alert.monitor?.id!.toString() || "",
+          alert.monitor!.id!.toString() || "",
         ],
 
         [NotificationRuleConditionCheckOn.OnCallDutyPolicyName]: undefined,

package/Server/Types/Database/QueryHelper.ts

@@ -313,6 +313,21 @@ export default class QueryHelper {
     ) as FindWhereProperty<T>;
   }
 
+  @CaptureSpan()
+  public static lessThanOrNull<T extends number | Date>(
+    value: T,
+  ): FindWhereProperty<T> {
+    const rid: string = Text.generateRandomText(10);
+    return Raw(
+      (alias: string) => {
+        return `(${alias} < :${rid} or ${alias} IS NULL)`;
+      },
+      {
+        [rid]: value,
+      },
+    ) as FindWhereProperty<T>;
+  }
+
   @CaptureSpan()
   public static lessThanEqualToOrNull<T extends number | Date>(
     value: T,

package/Server/Types/Database/QueryUtil.ts

@@ -20,6 +20,8 @@ import Typeof from "Common/Types/Typeof";
 import { FindOperator } from "typeorm/find-options/FindOperator";
 import { CompareType } from "../../../Types/Database/CompareBase";
 import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
+import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
+import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
 
 export default class QueryUtil {
   @CaptureSpan()
@@ -160,6 +162,22 @@ export default class QueryUtil {
         query[key] = QueryHelper.lessThanEqualTo(
           (query[key] as LessThanOrEqual<CompareType>).toString() as any,
         ) as any;
+      } else if (
+        query[key] &&
+        query[key] instanceof LessThanOrNull &&
+        tableColumnMetadata
+      ) {
+        query[key] = QueryHelper.lessThanOrNull(
+          (query[key] as LessThanOrNull<CompareType>).toString() as any,
+        ) as any;
+      } else if (
+        query[key] &&
+        query[key] instanceof GreaterThanOrNull &&
+        tableColumnMetadata
+      ) {
+        query[key] = QueryHelper.greaterThanOrNull(
+          (query[key] as LessThanOrNull<CompareType>).toString() as any,
+        ) as any;
       } else if (
         query[key] &&
         Array.isArray(query[key]) &&

package/Server/Utils/AnalyticsDatabase/Statement.ts

@@ -7,6 +7,8 @@ import GreaterThanOrEqual from "Common/Types/BaseDatabase/GreaterThanOrEqual";
 import Includes from "Common/Types/BaseDatabase/Includes";
 import LessThan from "Common/Types/BaseDatabase/LessThan";
 import LessThanOrEqual from "Common/Types/BaseDatabase/LessThanOrEqual";
+import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
+import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
 import Search from "Common/Types/BaseDatabase/Search";
 import OneUptimeDate from "Common/Types/Date";
 import Dictionary from "Common/Types/Dictionary";
@@ -99,7 +101,9 @@ export class Statement implements BaseQueryParams {
       v.value instanceof LessThan ||
       v.value instanceof LessThanOrEqual ||
       v.value instanceof GreaterThan ||
-      v.value instanceof GreaterThanOrEqual
+      v.value instanceof GreaterThanOrEqual ||
+      v.value instanceof LessThanOrNull ||
+      v.value instanceof GreaterThanOrNull
     ) {
       finalValue = v.value.value;
     } else if (v.value instanceof Includes) {

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -20,6 +20,8 @@ import Includes from "Common/Types/BaseDatabase/Includes";
 import IsNull from "Common/Types/BaseDatabase/IsNull";
 import LessThan from "Common/Types/BaseDatabase/LessThan";
 import LessThanOrEqual from "Common/Types/BaseDatabase/LessThanOrEqual";
+import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
+import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
 import NotEqual from "Common/Types/BaseDatabase/NotEqual";
 import Search from "Common/Types/BaseDatabase/Search";
 import SortOrder from "Common/Types/BaseDatabase/SortOrder";
@@ -382,6 +384,20 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             type: tableColumn.type,
           }}`,
         );
+      } else if (value instanceof LessThanOrNull) {
+        whereStatement.append(
+          SQL`AND (${key} <= ${{
+            value: value,
+            type: tableColumn.type,
+          }} OR ${key} IS NULL)`,
+        );
+      } else if (value instanceof GreaterThanOrNull) {
+        whereStatement.append(
+          SQL`AND (${key} >= ${{
+            value: value,
+            type: tableColumn.type,
+          }} OR ${key} IS NULL)`,
+        );
       } else if (value instanceof GreaterThanOrEqual) {
         whereStatement.append(
           SQL`AND ${key} >= ${{

package/Tests/Types/JSON.test.ts

@@ -19,6 +19,8 @@ describe("ObjectType", () => {
     "GreaterThanOrEqual",
     "LessThan",
     "LessThanOrEqual",
+    "LessThanOrNull",
+    "GreaterThanOrNull",
     "Port",
     "Hostname",
     "HashedString",

package/Types/BaseDatabase/GreaterThan.ts

@@ -1,4 +1,5 @@
 import CompareBase, { CompareType } from "../Database/CompareBase";
+import OneUptimeDate from "../Date";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
@@ -14,6 +15,16 @@ export default class GreaterThan<T extends CompareType> extends CompareBase<T> {
     };
   }
 
+  public override toString(): string {
+    let value: T = this.value;
+
+    if (value instanceof Date) {
+      value = OneUptimeDate.asDateForDatabaseQuery(value) as T;
+    }
+
+    return value.toString();
+  }
+
   public static override fromJSON<T extends CompareType>(
     json: JSONObject,
   ): GreaterThan<T> {

package/Types/BaseDatabase/GreaterThanOrEqual.ts

@@ -1,4 +1,5 @@
 import CompareBase, { CompareType } from "../Database/CompareBase";
+import OneUptimeDate from "../Date";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
@@ -16,6 +17,16 @@ export default class GreaterThanOrEqual<
     };
   }
 
+  public override toString(): string {
+    let value: T = this.value;
+
+    if (value instanceof Date) {
+      value = OneUptimeDate.asDateForDatabaseQuery(value) as T;
+    }
+
+    return value.toString();
+  }
+
   public static override fromJSON<T extends CompareType>(
     json: JSONObject,
   ): GreaterThanOrEqual<T> {

package/Types/BaseDatabase/GreaterThanOrNull.ts

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

package/Types/BaseDatabase/LessThan.ts

@@ -1,4 +1,5 @@
 import CompareBase, { CompareType } from "../Database/CompareBase";
+import OneUptimeDate from "../Date";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
@@ -14,6 +15,16 @@ export default class LessThan<T extends CompareType> extends CompareBase<T> {
     };
   }
 
+  public override toString(): string {
+    let value: T = this.value;
+
+    if (value instanceof Date) {
+      value = OneUptimeDate.asDateForDatabaseQuery(value) as T;
+    }
+
+    return value.toString();
+  }
+
   public static override fromJSON<T extends CompareType>(
     json: JSONObject,
   ): LessThan<T> {

package/Types/BaseDatabase/LessThanOrEqual.ts

@@ -1,4 +1,5 @@
 import CompareBase, { CompareType } from "../Database/CompareBase";
+import OneUptimeDate from "../Date";
 import BadDataException from "../Exception/BadDataException";
 import { JSONObject, ObjectType } from "../JSON";
 
@@ -16,6 +17,16 @@ export default class LessThanOrEqual<
     };
   }
 
+  public override toString(): string {
+    let value: T = this.value;
+
+    if (value instanceof Date) {
+      value = OneUptimeDate.asDateForDatabaseQuery(value) as T;
+    }
+
+    return value.toString();
+  }
+
   public static override fromJSON<T extends CompareType>(
     json: JSONObject,
   ): LessThanOrEqual<T> {