@oneuptime/common 7.0.4313 → 7.0.4337

package/Types/Monitor/CriteriaAlert.ts

@@ -1,4 +1,5 @@
 import ObjectID from "../ObjectID";
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface CriteriaAlert {
   title: string;
@@ -9,3 +10,13 @@ export interface CriteriaAlert {
   id: string;
   onCallPolicyIds?: Array<ObjectID> | undefined;
 }
+
+export const CriteriaAlertSchema: ZodSchema = Zod.object({
+  title: Zod.string(),
+  description: Zod.string(),
+  alertSeverityId: Zod.any().optional(),
+  autoResolveAlert: Zod.boolean().optional(),
+  remediationNotes: Zod.string().optional(),
+  id: Zod.string(),
+  onCallPolicyIds: Zod.array(Zod.any()).optional(),
+});

package/Types/Monitor/CriteriaFilter.ts

@@ -1,3 +1,5 @@
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
+
 export enum CheckOn {
   ResponseTime = "Response Time (in ms)",
   ResponseStatusCode = "Response Status Code",
@@ -179,3 +181,21 @@ export class CriteriaFilterUtil {
     );
   }
 }
+
+export const CriteriaFilterSchema: ZodSchema = Zod.object({
+  checkOn: Zod.string(),
+  serverMonitorOptions: Zod.object({
+    diskPath: Zod.string().optional(),
+  }).optional(),
+  metricMonitorOptions: Zod.object({
+    metricAlias: Zod.string().optional(),
+    metricAggregationType: Zod.string().optional(),
+  }).optional(),
+  filterType: Zod.string().optional(),
+  value: Zod.union([Zod.string(), Zod.number()]).optional(),
+  eveluateOverTime: Zod.boolean().optional(),
+  evaluateOverTimeOptions: Zod.object({
+    timeValueInMinutes: Zod.number().optional(),
+    evaluateOverTimeType: Zod.string().optional(),
+  }).optional(),
+});

package/Types/Monitor/CriteriaIncident.ts

@@ -1,4 +1,5 @@
 import ObjectID from "../ObjectID";
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface CriteriaIncident {
   title: string;
@@ -9,3 +10,13 @@ export interface CriteriaIncident {
   id: string;
   onCallPolicyIds?: Array<ObjectID> | undefined;
 }
+
+export const CriteriaIncidentSchema: ZodSchema = Zod.object({
+  title: Zod.string(),
+  description: Zod.string(),
+  incidentSeverityId: Zod.any().optional(),
+  autoResolveIncident: Zod.boolean().optional(),
+  remediationNotes: Zod.string().optional(),
+  id: Zod.string(),
+  onCallPolicyIds: Zod.array(Zod.any()).optional(),
+});

package/Types/Monitor/MonitorCriteria.ts

@@ -6,6 +6,7 @@ import ObjectID from "../ObjectID";
 import MonitorCriteriaInstance from "./MonitorCriteriaInstance";
 import MonitorType from "./MonitorType";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface MonitorCriteriaType {
   monitorCriteriaInstanceArray: Array<MonitorCriteriaInstance>;
@@ -179,4 +180,27 @@ export default class MonitorCriteria extends DatabaseProperty {
   public override toString(): string {
     return JSON.stringify(this.toJSON());
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.MonitorCriteria),
+      value: Zod.object({
+        monitorCriteriaInstanceArray: Zod.array(
+          MonitorCriteriaInstance.getSchema(),
+        ),
+      }).openapi({
+        type: "object",
+        example: {
+          monitorCriteriaInstanceArray: [],
+        },
+      }),
+    }).openapi({
+      type: "object",
+      description: "MonitorCriteria object",
+      example: {
+        _type: ObjectType.MonitorCriteria,
+        value: { monitorCriteriaInstanceArray: [] },
+      },
+    });
+  }
 }

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -5,17 +5,19 @@ import { JSONObject, ObjectType } from "../JSON";
 import JSONFunctions from "../JSONFunctions";
 import ObjectID from "../ObjectID";
 import Typeof from "../Typeof";
-import { CriteriaAlert } from "./CriteriaAlert";
+import { CriteriaAlert, CriteriaAlertSchema } from "./CriteriaAlert";
 import {
   CheckOn,
   CriteriaFilter,
   FilterType,
   EvaluateOverTimeType,
   CriteriaFilterUtil,
+  CriteriaFilterSchema,
 } from "./CriteriaFilter";
-import { CriteriaIncident } from "./CriteriaIncident";
+import { CriteriaIncident, CriteriaIncidentSchema } from "./CriteriaIncident";
 import MonitorType from "./MonitorType";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface MonitorCriteriaInstanceType {
   monitorStatusId: ObjectID | undefined;
@@ -1018,6 +1020,53 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
     return monitorCriteriaInstance;
   }
 
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.MonitorCriteriaInstance),
+      value: Zod.object({
+        id: Zod.string(),
+        monitorStatusId: Zod.any(),
+        filterCondition: Zod.any(),
+        filters: Zod.array(CriteriaFilterSchema),
+        incidents: Zod.array(CriteriaIncidentSchema),
+        alerts: Zod.array(CriteriaAlertSchema),
+        name: Zod.string(),
+        description: Zod.string(),
+        changeMonitorStatus: Zod.boolean().optional(),
+        createIncidents: Zod.boolean().optional(),
+        createAlerts: Zod.boolean().optional(),
+      }).openapi({
+        type: "object",
+        example: {
+          id: "id",
+          monitorStatusId: "statusId",
+          filterCondition: "All",
+          filters: [],
+          incidents: [],
+          alerts: [],
+          name: "Criteria Name",
+          description: "Description",
+        },
+      }),
+    }).openapi({
+      type: "object",
+      description: "MonitorCriteriaInstance object",
+      example: {
+        _type: ObjectType.MonitorCriteriaInstance,
+        value: {
+          id: "id",
+          monitorStatusId: "statusId",
+          filterCondition: "All",
+          filters: [],
+          incidents: [],
+          alerts: [],
+          name: "Criteria Name",
+          description: "Description",
+        },
+      },
+    });
+  }
+
   public static isValid(_json: JSONObject): boolean {
     return true;
   }

package/Types/Monitor/MonitorStep.ts

@@ -23,6 +23,7 @@ import MonitorStepTraceMonitor, {
 import MonitorStepMetricMonitor, {
   MonitorStepMetricMonitorUtil,
 } from "./MonitorStepMetricMonitor";
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface MonitorStepType {
   id: string;
@@ -425,6 +426,48 @@ export default class MonitorStep extends DatabaseProperty {
     return monitorStep;
   }
 
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.MonitorStep),
+      value: Zod.object({
+        id: Zod.string(),
+        monitorDestination: Zod.any().optional(),
+        monitorCriteria: Zod.any(),
+        requestType: Zod.any(),
+        requestHeaders: Zod.any().optional(),
+        requestBody: Zod.string().optional(),
+        doNotFollowRedirects: Zod.boolean().optional(),
+        monitorDestinationPort: Zod.any().optional(),
+        customCode: Zod.string().optional(),
+        screenSizeTypes: Zod.any().optional(),
+        browserTypes: Zod.any().optional(),
+        logMonitor: Zod.any().optional(),
+        traceMonitor: Zod.any().optional(),
+        metricMonitor: Zod.any().optional(),
+      }).openapi({
+        type: "object",
+        example: {
+          id: "stepId",
+          monitorDestination: undefined,
+          monitorCriteria: {},
+          requestType: "GET",
+        },
+      }),
+    }).openapi({
+      type: "object",
+      description: "MonitorStep object",
+      example: {
+        _type: ObjectType.MonitorStep,
+        value: {
+          id: "stepId",
+          monitorDestination: undefined,
+          monitorCriteria: {},
+          requestType: "GET",
+        },
+      },
+    });
+  }
+
   public isValid(): boolean {
     return true;
   }

package/Types/Monitor/MonitorSteps.ts

@@ -6,6 +6,7 @@ import ObjectID from "../ObjectID";
 import MonitorStep from "./MonitorStep";
 import MonitorType from "./MonitorType";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface MonitorStepsType {
   monitorStepsInstanceArray: Array<MonitorStep>;
@@ -192,4 +193,30 @@ export default class MonitorSteps extends DatabaseProperty {
   public override toString(): string {
     return JSON.stringify(this.toJSON());
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.MonitorSteps),
+      value: Zod.object({
+        monitorStepsInstanceArray: Zod.array(MonitorStep.getSchema()),
+        defaultMonitorStatusId: Zod.string().optional(),
+      }).openapi({
+        type: "object",
+        example: {
+          monitorStepsInstanceArray: [],
+          defaultMonitorStatusId: undefined,
+        },
+      }),
+    }).openapi({
+      type: "object",
+      description: "MonitorSteps object",
+      example: {
+        _type: ObjectType.MonitorSteps,
+        value: {
+          monitorStepsInstanceArray: [],
+          defaultMonitorStatusId: undefined,
+        },
+      },
+    });
+  }
 }

package/Types/Name.ts

@@ -2,6 +2,7 @@ import DatabaseProperty from "./Database/DatabaseProperty";
 import BadDataException from "./Exception/BadDataException";
 import { JSONObject, ObjectType } from "./JSON";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../Utils/Schema/Zod";
 
 export default class Name extends DatabaseProperty {
   private _title: string = "";
@@ -83,4 +84,18 @@ export default class Name extends DatabaseProperty {
 
     return null;
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.Name),
+      value: Zod.string().openapi({
+        type: "string",
+        example: "John Doe",
+      }),
+    }).openapi({
+      type: "object",
+      description: "Name object",
+      example: { _type: ObjectType.Name, value: "John Doe" },
+    });
+  }
 }

package/Types/ObjectID.ts

@@ -4,6 +4,7 @@ import DatabaseProperty from "./Database/DatabaseProperty";
 import BadDataException from "./Exception/BadDataException";
 import { JSONObject, ObjectType } from "./JSON";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../Utils/Schema/Zod";
 
 export default class ObjectID extends DatabaseProperty {
   private _id: string = "";
@@ -110,4 +111,21 @@ export default class ObjectID extends DatabaseProperty {
   public static fromString(id: string): ObjectID {
     return new ObjectID(id);
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.ObjectID),
+      value: Zod.string().openapi({
+        type: "string",
+        example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+      }),
+    }).openapi({
+      type: "object",
+      description: "ObjectID object",
+      example: {
+        _type: ObjectType.ObjectID,
+        value: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+      },
+    });
+  }
 }

package/Types/Phone.ts

@@ -2,6 +2,7 @@ import DatabaseProperty from "./Database/DatabaseProperty";
 import BadDataException from "./Exception/BadDataException";
 import { JSONObject, ObjectType } from "./JSON";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../Utils/Schema/Zod";
 
 export default class Phone extends DatabaseProperty {
   private _phone: string = "";
@@ -131,4 +132,18 @@ export default class Phone extends DatabaseProperty {
 
     return null;
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.Phone),
+      value: Zod.string().openapi({
+        type: "string",
+        example: "+1-555-123-4567",
+      }),
+    }).openapi({
+      type: "object",
+      description: "Phone object",
+      example: { _type: ObjectType.Phone, value: "+1-555-123-4567" },
+    });
+  }
 }

package/Types/Port.ts

@@ -4,6 +4,7 @@ import { JSONObject, ObjectType } from "./JSON";
 import PositiveNumber from "./PositiveNumber";
 import Typeof from "./Typeof";
 import { FindOperator } from "typeorm/find-options/FindOperator";
+import Zod, { ZodSchema } from "../Utils/Schema/Zod";
 
 export default class Port extends DatabaseProperty {
   private _port: PositiveNumber = new PositiveNumber(0);
@@ -89,4 +90,18 @@ export default class Port extends DatabaseProperty {
   public toNumber(): number {
     return this.port.toNumber();
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.Port),
+      value: Zod.number().int().min(0).max(65535).openapi({
+        type: "number",
+        example: 8080,
+      }),
+    }).openapi({
+      type: "object",
+      description: "Port object",
+      example: { _type: ObjectType.Port, value: 8080 },
+    });
+  }
 }

package/Types/Version.ts

@@ -2,6 +2,7 @@ import DatabaseProperty from "./Database/DatabaseProperty";
 import BadDataException from "./Exception/BadDataException";
 import { JSONObject, ObjectType } from "./JSON";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../Utils/Schema/Zod";
 
 export default class Version extends DatabaseProperty {
   private _version: string = "";
@@ -63,4 +64,18 @@ export default class Version extends DatabaseProperty {
 
     return null;
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.Version),
+      value: Zod.string().openapi({
+        type: "string",
+        example: "1.0.0",
+      }),
+    }).openapi({
+      type: "object",
+      description: "Version object",
+      example: { _type: ObjectType.Version, value: "1.0.0" },
+    });
+  }
 }

package/UI/Utils/Project.ts

@@ -37,7 +37,7 @@ export default class ProjectUtil {
     return null;
   }
 
-  public static setIsSubscriptionInactive(data: {
+  public static setIsSubscriptionInactiveOrOverdue(data: {
     paymentProviderMeteredSubscriptionStatus: SubscriptionStatus;
     paymentProviderSubscriptionStatus: SubscriptionStatus;
   }): boolean {
@@ -52,13 +52,26 @@ export default class ProjectUtil {
         data.paymentProviderSubscriptionStatus,
       );
 
+    const isSubscriptionOverdue: boolean =
+      SubscriptionStatusUtil.isSubscriptionOverdue(
+        data.paymentProviderMeteredSubscriptionStatus,
+      ) ||
+      SubscriptionStatusUtil.isSubscriptionOverdue(
+        data.paymentProviderSubscriptionStatus,
+      );
+
     // save this to local storage
     LocalStorage.setItem(
       currentProjectId?.toString() + "_isSubscriptionInactive",
       isSubscriptionInactive,
     );
 
-    return isSubscriptionInactive;
+    LocalStorage.setItem(
+      currentProjectId?.toString() + "_isSubscriptionOverdue",
+      isSubscriptionOverdue,
+    );
+
+    return isSubscriptionInactive || isSubscriptionOverdue;
   }
 
   public static isSubscriptionInactive(): boolean {