@oneuptime/common 7.0.4312 → 7.0.4337

package/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel.ts

@@ -61,7 +61,7 @@ export default class DatabaseBaseModel extends BaseEntity {
   public _id?: string = undefined;
 
   @TableColumn({
-    title: "Created",
+    title: "Created At",
     type: TableColumnType.Date,
     description: "Date and Time when the object was created.",
   })
@@ -71,7 +71,7 @@ export default class DatabaseBaseModel extends BaseEntity {
   public createdAt?: Date = undefined;
 
   @TableColumn({
-    title: "Updated",
+    title: "Updated At",
     type: TableColumnType.Date,
     description: "Date and Time when the object was updated.",
   })
@@ -81,7 +81,7 @@ export default class DatabaseBaseModel extends BaseEntity {
   public updatedAt?: Date = undefined;
 
   @TableColumn({
-    title: "Deleted",
+    title: "Deleted At",
     type: TableColumnType.Date,
     description: "Date and Time when the object was deleted.",
   })

package/Server/Services/ProjectService.ts

@@ -71,6 +71,7 @@ import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import URL from "../../Types/API/URL";
 import Exception from "../../Types/Exception/Exception";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import DatabaseConfig from "../DatabaseConfig";
 
 export interface CurrentPlan {
   plan: PlanType | null;
@@ -1415,6 +1416,15 @@ export class ProjectService extends DatabaseService<Model> {
     };
   }
 
+  @CaptureSpan()
+  public async getProjectLinkInDashboard(projectId: ObjectID): Promise<URL> {
+    const dashboardUrl: URL = await DatabaseConfig.getDashboardUrl();
+
+    return URL.fromString(dashboardUrl.toString()).addRoute(
+      `/${projectId.toString()}`,
+    );
+  }
+
   @CaptureSpan()
   public async isSMSNotificationsEnabled(
     projectId: ObjectID,

package/Server/Utils/OpenAPI.ts

@@ -4,107 +4,120 @@ import {
 } from "@asteasolutions/zod-to-openapi";
 import DatabaseBaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import Models from "../../Models/DatabaseModels/Index";
-import { JSONObject } from "../../Types/JSON";
+import { JSONObject, JSONValue } from "../../Types/JSON";
+import logger from "./Logger";
+import { ModelSchema, ModelSchemaType } from "../../Utils/Schema/ModelSchema";
+import LocalCache from "../Infrastructure/LocalCache";
+import { Host, HttpProtocol } from "../EnvironmentConfig";
 
 export default class OpenAPIUtil {
   public static generateOpenAPISpec(): JSONObject {
+    // check if the cache is already in LocalCache
+    const cachedSpec: JSONValue | undefined = LocalCache.getJSON(
+      "openapi",
+      "spec",
+    );
+
+    if (cachedSpec) {
+      logger.debug("Returning cached OpenAPI spec");
+      return cachedSpec as JSONObject;
+    }
+
     const registry: OpenAPIRegistry = new OpenAPIRegistry();
 
     // Register schemas and paths for all models
     for (const ModelClass of Models) {
       const model: DatabaseBaseModel = new ModelClass();
-      const modelName: string = model.constructor.name;
-      const basePath: string = `/api/${modelName.toLowerCase()}`;
-      // Use a plain object for paths
-      const paths: Record<string, Record<string, any>> = {};
+      const modelName: string | null = model.tableName;
 
-      // List endpoints (POST and GET)
-      paths[`${basePath}/get-list`] = {
-        post: this.generateListApiSpec({ modelType: ModelClass }),
-        get: this.generateListApiSpec({ modelType: ModelClass }),
-      };
-      // Count endpoint
-      paths[`${basePath}/count`] = {
-        post: this.generateCountApiSpec({ modelType: ModelClass }),
-      };
-      // Create endpoint
-      paths[basePath] = {
-        post: this.generateCreateApiSpec({ modelType: ModelClass }),
-      };
-      // Get item endpoints (POST and GET)
-      paths[`${basePath}/{id}/get-item`] = {
-        post: this.generateGetApiSpec({ modelType: ModelClass }),
-        get: this.generateGetApiSpec({ modelType: ModelClass }),
-      };
-      // Update endpoints (PUT, POST, GET)
-      if (!paths[`${basePath}/{id}`]) {
-        paths[`${basePath}/{id}`] = {};
+      if (!modelName) {
+        continue;
       }
 
-      paths[`${basePath}/{id}`]!["put"] = this.generateUpdateApiSpec({
-        modelType: ModelClass,
-      });
-      paths[`${basePath}/{id}/update-item`] = {
-        post: this.generateUpdateApiSpec({ modelType: ModelClass }),
-        get: this.generateUpdateApiSpec({ modelType: ModelClass }),
-      };
-      // Delete endpoints (DELETE, POST, GET)
-      if (!paths[`${basePath}/{id}`]) {
-        paths[`${basePath}/{id}`] = {};
+      // check if enable documentation is enabled
+
+      if (!model.enableDocumentation) {
+        logger.debug(
+          `Skipping OpenAPI documentation for model ${modelName} as it is disabled.`,
+        );
+        continue;
       }
-      paths[`${basePath}/{id}`]!["delete"] = this.generateDeleteApiSpec({
+
+      if (!model.crudApiPath) {
+        logger.debug(
+          `Skipping OpenAPI documentation for model ${modelName} as it does not have a CRUD API path defined.`,
+        );
+        continue;
+      }
+
+      // register the model schema
+      OpenAPIUtil.registerModelSchemas(registry, model);
+
+      this.generateListApiSpec({
         modelType: ModelClass,
+        registry,
       });
-      paths[`${basePath}/{id}/delete-item`] = {
-        post: this.generateDeleteApiSpec({ modelType: ModelClass }),
-        get: this.generateDeleteApiSpec({ modelType: ModelClass }),
-      };
 
-      // Register the paths in the registry
-      for (const path in paths) {
-        if (paths[path]) {
-          const methods: Record<string, any> | undefined = paths[path];
-          if (typeof methods === "object" && methods !== null) {
-            for (const method in methods) {
-              if (methods[method]) {
-                const spec: any = methods[method];
-                registry.registerPath({
-                  method: method as any,
-                  path,
-                  ...spec,
-                });
-              }
-            }
-          }
-        }
-      }
+      this.generateCountApiSpec({
+        modelType: ModelClass,
+        registry,
+      });
+      this.generateCreateApiSpec({
+        modelType: ModelClass,
+        registry,
+      });
+      this.generateGetApiSpec({
+        modelType: ModelClass,
+        registry,
+      });
+      this.generateUpdateApiSpec({
+        modelType: ModelClass,
+        registry,
+      });
+      this.generateDeleteApiSpec({
+        modelType: ModelClass,
+        registry,
+      });
     }
 
     const generator: OpenApiGeneratorV3 = new OpenApiGeneratorV3(
       registry.definitions,
     );
 
-    const components: Pick<any, "components"> = generator.generateComponents();
-
-    return {
+    const spec: JSONObject = generator.generateDocument({
       openapi: "3.0.0",
       info: {
-        title: "API Documentation",
+        title: "OneUptime OpenAPI Specification",
         version: "1.0.0",
-        description: "API documentation generated from models",
+        description:
+          "OpenAPI specification for OneUptime. This document describes the API endpoints, request and response formats, and other details necessary for developers to interact with the OneUptime API.",
       },
-      components: components,
-    } as unknown as JSONObject;
+      servers: [
+        {
+          url: `${HttpProtocol.toString()}${Host.toString()}/api`,
+          description: "API Server",
+        },
+      ],
+    }) as unknown as JSONObject;
+
+    LocalCache.setJSON("openapi", "spec", spec as JSONObject);
+
+    return spec;
   }
 
   public static generateListApiSpec(data: {
     modelType: new () => DatabaseBaseModel;
-  }): JSONObject {
+    registry: OpenAPIRegistry;
+  }): void {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
-    return {
-      summary: `List ${model.constructor.name}`,
-      description: `Endpoint to list all ${model.constructor.name} items`,
+    const tableName: string = model.tableName || "UnknownModel";
+
+    data.registry.registerPath({
+      method: "post",
+      path: `${model.crudApiPath}/get-list`,
+      summary: `List ${tableName}`,
+      description: `Endpoint to list all ${tableName} items`,
       requestBody: {
         required: false,
         content: {
@@ -132,7 +145,7 @@ export default class OpenAPIUtil {
                   data: {
                     type: "array",
                     items: {
-                      $ref: `#/components/schemas/${model.constructor.name}`,
+                      $ref: `#/components/schemas/${tableName}`,
                     },
                   },
                   count: { type: "number" },
@@ -142,17 +155,21 @@ export default class OpenAPIUtil {
           },
         },
       },
-    };
+    });
   }
 
   public static generateCountApiSpec(data: {
     modelType: new () => DatabaseBaseModel;
-  }): JSONObject {
+    registry: OpenAPIRegistry;
+  }): void {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
-    return {
-      summary: `Count ${model.constructor.name}`,
-      description: `Endpoint to count ${model.constructor.name} items`,
+    const tableName: string = model.tableName || "UnknownModel";
+    data.registry.registerPath({
+      method: "post",
+      path: `${model.crudApiPath}/count`,
+      summary: `Count ${tableName}`,
+      description: `Endpoint to count ${tableName} items`,
       requestBody: {
         required: false,
         content: {
@@ -181,17 +198,21 @@ export default class OpenAPIUtil {
           },
         },
       },
-    };
+    });
   }
 
   public static generateCreateApiSpec(data: {
     modelType: new () => DatabaseBaseModel;
-  }): JSONObject {
+    registry: OpenAPIRegistry;
+  }): void {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
-    return {
-      summary: `Create ${model.constructor.name}`,
-      description: `Endpoint to create a new ${model.constructor.name}`,
+    const tableName: string = model.tableName || "UnknownModel";
+    data.registry.registerPath({
+      method: "post",
+      path: `${model.crudApiPath}`,
+      summary: `Create ${tableName}`,
+      description: `Endpoint to create a new ${tableName}`,
       requestBody: {
         required: true,
         content: {
@@ -200,7 +221,7 @@ export default class OpenAPIUtil {
               type: "object",
               properties: {
                 data: {
-                  $ref: `#/components/schemas/${model.constructor.name}Input`,
+                  $ref: `#/components/schemas/${tableName}Input`,
                 },
                 miscDataProps: { type: "object" },
               },
@@ -218,7 +239,7 @@ export default class OpenAPIUtil {
                 type: "object",
                 properties: {
                   data: {
-                    $ref: `#/components/schemas/${model.constructor.name}`,
+                    $ref: `#/components/schemas/${tableName}`,
                   },
                 },
               },
@@ -229,18 +250,23 @@ export default class OpenAPIUtil {
           description: "Bad request",
         },
       },
-    };
+    });
   }
 
   public static generateGetApiSpec(data: {
     modelType: new () => DatabaseBaseModel;
-  }): JSONObject {
+    registry: OpenAPIRegistry;
+  }): void {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
-    return {
-      summary: `Get ${model.constructor.name}`,
-      description: `Endpoint to retrieve a single ${model.constructor.name} by ID`,
+    const tableName: string = model.tableName || "UnknownModel";
+    data.registry.registerPath({
+      method: "post",
+      path: `${model.crudApiPath}/{id}`,
+      summary: `Get ${tableName}`,
+      description: `Endpoint to retrieve a single ${tableName} by ID`,
       parameters: [
+        ...(OpenAPIUtil.getDefaultApiHeaders() as Array<any>),
         {
           name: "id",
           in: "path",
@@ -249,7 +275,7 @@ export default class OpenAPIUtil {
             type: "string",
             format: "uuid",
           },
-          description: `ID of the ${model.constructor.name} to retrieve`,
+          description: `ID of the ${tableName} to retrieve`,
         },
       ],
       responses: {
@@ -261,7 +287,7 @@ export default class OpenAPIUtil {
                 type: "object",
                 properties: {
                   data: {
-                    $ref: `#/components/schemas/${model.constructor.name}`,
+                    $ref: `#/components/schemas/${tableName}`,
                   },
                 },
               },
@@ -272,18 +298,44 @@ export default class OpenAPIUtil {
           description: "Resource not found",
         },
       },
-    };
+    });
+  }
+
+  public static getDefaultApiHeaders(): Array<JSONObject> {
+    return [
+      {
+        name: "Content-Type",
+        in: "header",
+        required: true,
+        schema: { type: "string" },
+        description: "Content type of the request",
+        example: "application/json",
+      },
+      {
+        name: "APIKey",
+        in: "header",
+        required: true,
+        schema: { type: "string" },
+        description: "API key for authentication",
+        example: "{{apiKey}}",
+      },
+    ];
   }
 
   public static generateUpdateApiSpec(data: {
     modelType: new () => DatabaseBaseModel;
-  }): JSONObject {
+    registry: OpenAPIRegistry;
+  }): void {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
-    return {
-      summary: `Update ${model.constructor.name}`,
-      description: `Endpoint to update an existing ${model.constructor.name}`,
+    const tableName: string = model.tableName || "UnknownModel";
+    data.registry.registerPath({
+      method: "put",
+      path: `${model.crudApiPath}/{id}`,
+      summary: `Update ${tableName}`,
+      description: `Endpoint to update an existing ${tableName}`,
       parameters: [
+        ...(OpenAPIUtil.getDefaultApiHeaders() as Array<any>),
         {
           name: "id",
           in: "path",
@@ -292,7 +344,7 @@ export default class OpenAPIUtil {
             type: "string",
             format: "uuid",
           },
-          description: `ID of the ${model.constructor.name} to update`,
+          description: `ID of the ${tableName} to update`,
         },
       ],
       requestBody: {
@@ -303,7 +355,7 @@ export default class OpenAPIUtil {
               type: "object",
               properties: {
                 data: {
-                  $ref: `#/components/schemas/${model.constructor.name}UpdateInput`,
+                  $ref: `#/components/schemas/${tableName}UpdateInput`,
                 },
               },
               required: ["data"],
@@ -320,7 +372,7 @@ export default class OpenAPIUtil {
                 type: "object",
                 properties: {
                   data: {
-                    $ref: `#/components/schemas/${model.constructor.name}`,
+                    $ref: `#/components/schemas/${tableName}`,
                   },
                 },
               },
@@ -334,18 +386,23 @@ export default class OpenAPIUtil {
           description: "Bad request",
         },
       },
-    };
+    });
   }
 
   public static generateDeleteApiSpec(data: {
     modelType: new () => DatabaseBaseModel;
-  }): JSONObject {
+    registry: OpenAPIRegistry;
+  }): void {
     const modelType: new () => DatabaseBaseModel = data.modelType;
     const model: DatabaseBaseModel = new modelType();
-    return {
-      summary: `Delete ${model.constructor.name}`,
-      description: `Endpoint to delete a ${model.constructor.name}`,
+    const tableName: string = model.tableName || "UnknownModel";
+    data.registry.registerPath({
+      method: "delete",
+      path: `${model.crudApiPath}/{id}`,
+      summary: `Delete ${tableName}`,
+      description: `Endpoint to delete a ${tableName}`,
       parameters: [
+        ...(OpenAPIUtil.getDefaultApiHeaders() as Array<any>),
         {
           name: "id",
           in: "path",
@@ -354,7 +411,7 @@ export default class OpenAPIUtil {
             type: "string",
             format: "uuid",
           },
-          description: `ID of the ${model.constructor.name} to delete`,
+          description: `ID of the ${tableName} to delete`,
         },
       ],
       responses: {
@@ -365,6 +422,17 @@ export default class OpenAPIUtil {
           description: "Resource not found",
         },
       },
-    };
+    });
+  }
+
+  private static registerModelSchemas(
+    registry: OpenAPIRegistry,
+    model: DatabaseBaseModel,
+  ): void {
+    const tableName: string = model.tableName || "UnknownModel";
+    const modelSchema: ModelSchemaType = ModelSchema.getModelSchema({
+      modelType: model.constructor as new () => DatabaseBaseModel,
+    });
+    registry.register(tableName, modelSchema);
   }
 }

package/Types/Billing/SubscriptionStatus.ts

@@ -7,6 +7,7 @@ enum SubscriptionStatus {
   Canceled = "canceled",
   Unpaid = "unpaid",
   Expired = "expired",
+  Paused = "paused",
 }
 
 export class SubscriptionStatusUtil {
@@ -19,7 +20,8 @@ export class SubscriptionStatusUtil {
 
     return (
       status === SubscriptionStatus.Active ||
-      status === SubscriptionStatus.Trialing
+      status === SubscriptionStatus.Trialing ||
+      status === SubscriptionStatus.PastDue
     );
   }
 
@@ -28,6 +30,32 @@ export class SubscriptionStatusUtil {
   ): boolean {
     return !SubscriptionStatusUtil.isSubscriptionActive(status);
   }
+
+  public static isSubscriptionOverdue(
+    status?: SubscriptionStatus | undefined,
+  ): boolean {
+    if (!status) {
+      return false;
+    }
+
+    return status === SubscriptionStatus.PastDue;
+  }
+
+  // is subscription canclled.
+  public static isSubscriptionCancelled(
+    status?: SubscriptionStatus | undefined,
+  ): boolean {
+    if (!status) {
+      return false;
+    }
+
+    return (
+      status === SubscriptionStatus.Canceled ||
+      status === SubscriptionStatus.Unpaid ||
+      status === SubscriptionStatus.Expired ||
+      status === SubscriptionStatus.IncompleteExpired
+    );
+  }
 }
 
 export default SubscriptionStatus;

package/Types/Color.ts

@@ -1,3 +1,4 @@
+import Zod, { ZodSchema } from "../Utils/Schema/Zod";
 import DatabaseProperty from "./Database/DatabaseProperty";
 import BadDataException from "./Exception/BadDataException";
 import { JSONObject, ObjectType } from "./JSON";
@@ -105,4 +106,18 @@ export default class Color extends DatabaseProperty {
     }
     return false;
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.Color),
+      value: Zod.string().openapi({
+        type: "string",
+        example: "#ff0000",
+      }),
+    }).openapi({
+      type: "object",
+      description: "Color object",
+      example: { _type: ObjectType.Color, value: "#ff0000" },
+    });
+  }
 }

package/Types/Database/DatabaseProperty.ts

@@ -1,3 +1,4 @@
+import { ZodSchema } from "zod";
 import NotImplementedException from "../Exception/NotImplementedException";
 import { JSONArray, JSONObject } from "../JSON";
 import SerializableObject from "../SerializableObject";
@@ -51,4 +52,8 @@ export default class DatabaseProperty extends SerializableObject {
       },
     };
   }
+
+  public static getSchema(): ZodSchema {
+    throw new NotImplementedException();
+  }
 }

package/Types/Domain.ts

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

package/Types/Email/EmailTemplateType.ts

@@ -55,6 +55,8 @@ enum EmailTemplateType {
   UserCurrentlyOnOnCallRoster = "UserCurrentlyOnOnCallRoster.hbs",
   UserNextOnOnCallRoster = "UserNextOnOnCallRoster.hbs",
   UserNoLongerActiveOnOnCallRoster = "UserNoLongerActiveOnOnCallRoster.hbs",
+
+  ProjectSubscriptionOverdue = "ProjectSubscriptionOverdue.hbs",
 }
 
 export default EmailTemplateType;

package/Types/Email.ts

@@ -3,6 +3,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";
 
 const nonBusinessEmailDomains: Array<string> = [
   "gmail",
@@ -123,4 +124,19 @@ export default class Email extends DatabaseProperty {
 
     return null;
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.Email),
+      value: Zod.string().email().openapi({
+        type: "string",
+        format: "email",
+        example: "user@example.com",
+      }),
+    }).openapi({
+      type: "object",
+      description: "Email object",
+      example: { _type: ObjectType.Email, value: "user@example.com" },
+    });
+  }
 }

package/Types/IP/IP.ts

@@ -4,6 +4,7 @@ import { JSONObject, ObjectType } from "../JSON";
 import Typeof from "../Typeof";
 import IPType from "./IPType";
 import { FindOperator } from "typeorm";
+import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export default class IP extends DatabaseProperty {
   private _ip: string = "";
@@ -199,4 +200,18 @@ export default class IP extends DatabaseProperty {
     }
     return null;
   }
+
+  public static override getSchema(): ZodSchema {
+    return Zod.object({
+      _type: Zod.literal(ObjectType.IP),
+      value: Zod.string().openapi({
+        type: "string",
+        example: "192.168.1.1",
+      }),
+    }).openapi({
+      type: "object",
+      description: "IP object",
+      example: { _type: ObjectType.IP, value: "192.168.1.1" },
+    });
+  }
 }