@oneuptime/common 8.0.5493 → 8.0.5513

package/Models/DatabaseModels/EnterpriseLicense.ts

@@ -0,0 +1,104 @@
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import IconProp from "../../Types/Icon/IconProp";
+import { Column, Entity, Index } from "typeorm";
+
+@TableAccessControl({
+  create: [],
+  read: [],
+  update: [],
+  delete: [],
+})
+@CrudApiEndpoint(new Route("/enterprise-license"))
+@TableMetadata({
+  tableName: "EnterpriseLicense",
+  singularName: "Enterprise License",
+  pluralName: "Enterprise Licenses",
+  icon: IconProp.Lock,
+  tableDescription: "Enterprise license keys issued by OneUptime.",
+})
+@Entity({
+  name: "EnterpriseLicense",
+})
+export default class EnterpriseLicense extends BaseModel {
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "Company Name",
+    description: "Company name associated with this license.",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public companyName?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "License Key",
+    description: "Enterprise license key.",
+    unique: true,
+  })
+  @Index({ unique: true })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    unique: true,
+  })
+  public licenseKey?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.Date,
+    title: "Expires At",
+    description: "Expiration date of this license.",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.Date,
+  })
+  public expiresAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Annual Contract Value",
+    description: "Annual contract value (in USD) for this license.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Number,
+  })
+  public annualContractValue?: number = undefined;
+}

package/Models/DatabaseModels/GlobalConfig.ts

@@ -497,4 +497,75 @@ export default class GlobalConfig extends GlobalConfigModel {
     transformer: Email.getDatabaseTransformer(),
   })
   public adminNotificationEmail?: Email = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    title: "Enterprise Company Name",
+    description:
+      "Company name associated with the validated enterprise license.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+    unique: true,
+  })
+  public enterpriseCompanyName?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    title: "Enterprise License Key",
+    description: "Enterprise license key stored after successful validation.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+    unique: true,
+  })
+  public enterpriseLicenseKey?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "Enterprise License Expires At",
+    description: "Expiration date of the validated enterprise license.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+    unique: true,
+  })
+  public enterpriseLicenseExpiresAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.VeryLongText,
+    title: "Enterprise License Token",
+    description: "Signed JWT returned from license validation.",
+  })
+  @Column({
+    type: ColumnType.VeryLongText,
+    nullable: true,
+    unique: true,
+  })
+  public enterpriseLicenseToken?: string = undefined;
 }

package/Models/DatabaseModels/Index.ts

@@ -81,6 +81,7 @@ import ProjectSmtpConfig from "./ProjectSmtpConfig";
 //SSO
 import ProjectSSO from "./ProjectSso";
 import PromoCode from "./PromoCode";
+import EnterpriseLicense from "./EnterpriseLicense";
 import Reseller from "./Reseller";
 import ResellerPlan from "./ResellerPlan";
 // ScheduledMaintenances
@@ -331,6 +332,7 @@ const AllModelTypes: Array<{
   ResellerPlan,
 
   PromoCode,
+  EnterpriseLicense,
 
   GlobalConfig,
 

package/Server/API/EnterpriseLicenseAPI.ts

@@ -0,0 +1,102 @@
+import EnterpriseLicense from "../../Models/DatabaseModels/EnterpriseLicense";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONObject } from "../../Types/JSON";
+import EnterpriseLicenseService, {
+  Service as EnterpriseLicenseServiceType,
+} from "../Services/EnterpriseLicenseService";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import JSONWebToken from "../Utils/JsonWebToken";
+import Response from "../Utils/Response";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import BaseAPI from "./BaseAPI";
+// import { Host } from "../EnvironmentConfig";
+
+export default class EnterpriseLicenseAPI extends BaseAPI<
+  EnterpriseLicense,
+  EnterpriseLicenseServiceType
+> {
+  public constructor() {
+    super(EnterpriseLicense, EnterpriseLicenseService);
+
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/validate`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const licenseKey: string | undefined = req.body["licenseKey"];
+
+          if (!licenseKey) {
+            throw new BadDataException("License key is required");
+          }
+
+          //const serverHost: string = Host.toString();
+
+          /*
+           * if (!serverHost.includes("oneuptime.com")) {
+           *   throw new BadDataException(
+           *     "Enterprise license validation is only available on oneuptime.com",
+           *   );
+           * }
+           */
+
+          const license: EnterpriseLicense | null =
+            await EnterpriseLicenseService.findOneBy({
+              query: {
+                licenseKey: licenseKey,
+              },
+              select: {
+                companyName: true,
+                expiresAt: true,
+                licenseKey: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!license) {
+            throw new BadDataException("License key is invalid");
+          }
+
+          if (!license.expiresAt) {
+            throw new BadDataException("License expiration is not set");
+          }
+
+          const now: number = Date.now();
+          const expiresAtMs: number = license.expiresAt.getTime();
+          const secondsUntilExpiry: number = Math.floor(
+            (expiresAtMs - now) / 1000,
+          );
+
+          if (secondsUntilExpiry <= 0) {
+            throw new BadDataException("License key has expired");
+          }
+
+          const payload: JSONObject = {
+            companyName: license.companyName || "",
+            expiresAt: license.expiresAt.toISOString(),
+            licenseKey: license.licenseKey || "",
+          };
+
+          const token: string = JSONWebToken.signJsonPayload(
+            payload,
+            Math.max(secondsUntilExpiry, 1),
+          );
+
+          return Response.sendJsonObjectResponse(req, res, {
+            companyName: payload["companyName"] as string,
+            expiresAt: payload["expiresAt"] as string,
+            licenseKey: payload["licenseKey"] as string,
+            token,
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+}

package/Server/API/GlobalConfigAPI.ts

@@ -9,6 +9,15 @@ import {
 import Response from "../Utils/Response";
 import BaseAPI from "./BaseAPI";
 import GlobalConfig from "../../Models/DatabaseModels/GlobalConfig";
+import ObjectID from "../../Types/ObjectID";
+import { JSONObject } from "../../Types/JSON";
+import BadDataException from "../../Types/Exception/BadDataException";
+import API from "../../Utils/API";
+import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../Types/API/HTTPResponse";
+import PartialEntity from "../../Types/Database/PartialEntity";
+import { EnterpriseLicenseValidationUrl } from "../EnvironmentConfig";
+import UserMiddleware from "../Middleware/UserAuthorization";
 
 export default class GlobalConfigAPI extends BaseAPI<
   GlobalConfig,
@@ -45,5 +54,164 @@ export default class GlobalConfigAPI extends BaseAPI<
         }
       },
     );
+
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/license`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const config: GlobalConfig | null =
+            await GlobalConfigService.findOneById({
+              id: ObjectID.getZeroObjectID(),
+              select: {
+                enterpriseCompanyName: true,
+                enterpriseLicenseExpiresAt: true,
+                enterpriseLicenseKey: true,
+                enterpriseLicenseToken: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          const responseBody: JSONObject = {
+            companyName: config?.enterpriseCompanyName || null,
+            expiresAt: config?.enterpriseLicenseExpiresAt
+              ? config.enterpriseLicenseExpiresAt.toISOString()
+              : null,
+            licenseKey: config?.enterpriseLicenseKey || null,
+            token: config?.enterpriseLicenseToken || null,
+          };
+
+          return Response.sendJsonObjectResponse(req, res, responseBody);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/license`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const licenseKey: string =
+            (req.body["licenseKey"] as string | undefined)?.trim() || "";
+
+          if (!licenseKey) {
+            throw new BadDataException("License key is required");
+          }
+
+          const validationResponse:
+            | HTTPResponse<JSONObject>
+            | HTTPErrorResponse = await API.post<JSONObject>({
+            url: EnterpriseLicenseValidationUrl,
+            data: {
+              licenseKey,
+            },
+          });
+
+          if (!validationResponse.isSuccess()) {
+            const errorMessage: string =
+              validationResponse instanceof HTTPErrorResponse
+                ? validationResponse.message ||
+                  "Failed to validate license key."
+                : "Failed to validate license key.";
+            throw new BadDataException(errorMessage);
+          }
+
+          const payload: JSONObject = validationResponse.data as JSONObject;
+
+          const companyNameRaw: string =
+            (payload["companyName"] as string | undefined)?.trim() || "";
+          const expiresAtRaw: string =
+            (payload["expiresAt"] as string | undefined) || "";
+          const licenseKeyRaw: string =
+            (payload["licenseKey"] as string | undefined)?.trim() || licenseKey;
+          const licenseToken: string =
+            (payload["token"] as string | undefined) || "";
+
+          let licenseExpiry: Date | undefined = undefined;
+          if (expiresAtRaw) {
+            const parsedDate: Date = new Date(expiresAtRaw);
+
+            if (Number.isNaN(parsedDate.getTime())) {
+              throw new BadDataException(
+                "License expiration returned from server is invalid.",
+              );
+            }
+
+            licenseExpiry = parsedDate;
+          }
+
+          const updatePayload: PartialEntity<GlobalConfig> = {
+            enterpriseCompanyName: companyNameRaw || null,
+            enterpriseLicenseKey: licenseKeyRaw || null,
+            enterpriseLicenseExpiresAt: licenseExpiry || null,
+            enterpriseLicenseToken: licenseToken || null,
+          };
+
+          const globalConfigId: ObjectID = ObjectID.getZeroObjectID();
+
+          const existingConfig: GlobalConfig | null =
+            await GlobalConfigService.findOneById({
+              id: globalConfigId,
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+                ignoreHooks: true,
+              },
+            });
+
+          if (existingConfig) {
+            await GlobalConfigService.updateOneById({
+              id: globalConfigId,
+              data: updatePayload,
+              props: {
+                isRoot: true,
+                ignoreHooks: true,
+              },
+            });
+          } else {
+            const newConfig: GlobalConfig = new GlobalConfig();
+            newConfig.id = globalConfigId;
+
+            if (companyNameRaw) {
+              newConfig.enterpriseCompanyName = companyNameRaw;
+            }
+
+            if (licenseKeyRaw) {
+              newConfig.enterpriseLicenseKey = licenseKeyRaw;
+            }
+
+            if (licenseToken) {
+              newConfig.enterpriseLicenseToken = licenseToken;
+            }
+
+            if (licenseExpiry) {
+              newConfig.enterpriseLicenseExpiresAt = licenseExpiry;
+            }
+
+            await GlobalConfigService.create({
+              data: newConfig,
+              props: {
+                isRoot: true,
+                ignoreHooks: true,
+              },
+            });
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            companyName: companyNameRaw || null,
+            expiresAt: licenseExpiry ? licenseExpiry.toISOString() : null,
+            licenseKey: licenseKeyRaw || null,
+            token: licenseToken || null,
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
   }
 }

package/Server/EnvironmentConfig.ts

@@ -365,6 +365,9 @@ export const DocsClientUrl: URL = new URL(
 export const DisableTelemetry: boolean =
   process.env["DISABLE_TELEMETRY"] === "true";
 
+export const IsEnterpriseEdition: boolean =
+  process.env["IS_ENTERPRISE_EDITION"] === "true";
+
 export const AverageSpanRowSizeInBytes: number = parsePositiveNumberFromEnv(
   "AVERAGE_SPAN_ROW_SIZE_IN_BYTES",
   1024,
@@ -405,3 +408,7 @@ export const VapidPrivateKey: string | undefined =
 
 export const VapidSubject: string =
   process.env["VAPID_SUBJECT"] || "mailto:support@oneuptime.com";
+
+export const EnterpriseLicenseValidationUrl: URL = URL.fromString(
+  "https://oneuptime.com/api/enterprise-license/validate",
+);

package/Server/Infrastructure/Postgres/SchemaMigrations/1762181014879-MigrationName.ts

@@ -0,0 +1,69 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1762181014879 implements MigrationInterface {
+  public name = "MigrationName1762181014879";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "EnterpriseLicense" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "companyName" character varying(100) NOT NULL, "licenseKey" character varying(100) NOT NULL, "expiresAt" TIMESTAMP WITH TIME ZONE NOT NULL, "annualContractValue" integer, CONSTRAINT "UQ_d35e76999092d8a16a66e84c17c" UNIQUE ("licenseKey"), CONSTRAINT "PK_731aa4437672f250fd51ec04166" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "IDX_d35e76999092d8a16a66e84c17" ON "EnterpriseLicense" ("licenseKey") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseCompanyName" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD CONSTRAINT "UQ_46983cb1a59503dc09fc84bbe0c" UNIQUE ("enterpriseCompanyName")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseKey" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD CONSTRAINT "UQ_89f80e8a18c3372ee150a3812c1" UNIQUE ("enterpriseLicenseKey")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseExpiresAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD CONSTRAINT "UQ_a361278e9ce4056d59e8fb13319" UNIQUE ("enterpriseLicenseExpiresAt")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseToken" text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD CONSTRAINT "UQ_b0b9322c111c0cc629fedbb4eb3" UNIQUE ("enterpriseLicenseToken")`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP CONSTRAINT "UQ_b0b9322c111c0cc629fedbb4eb3"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseToken"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP CONSTRAINT "UQ_a361278e9ce4056d59e8fb13319"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseExpiresAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP CONSTRAINT "UQ_89f80e8a18c3372ee150a3812c1"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseKey"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP CONSTRAINT "UQ_46983cb1a59503dc09fc84bbe0c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseCompanyName"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d35e76999092d8a16a66e84c17"`,
+    );
+    await queryRunner.query(`DROP TABLE "EnterpriseLicense"`);
+  }
+}

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

@@ -179,6 +179,7 @@ import { MigrationName1760345757975 } from "./1760345757975-MigrationName";
 import { MigrationName1760357680881 } from "./1760357680881-MigrationName";
 import { MigrationName1761232578396 } from "./1761232578396-MigrationName";
 import { MigrationName1761834523183 } from "./1761834523183-MigrationName";
+import { MigrationName1762181014879 } from "./1762181014879-MigrationName";
 
 export default [
   InitialMigration,
@@ -362,4 +363,5 @@ export default [
   MigrationName1760357680881,
   MigrationName1761232578396,
   MigrationName1761834523183,
+  MigrationName1762181014879,
 ];

package/Server/Services/EnterpriseLicenseService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import EnterpriseLicense from "../../Models/DatabaseModels/EnterpriseLicense";
+
+export class Service extends DatabaseService<EnterpriseLicense> {
+  public constructor() {
+    super(EnterpriseLicense);
+  }
+}
+
+export default new Service();

package/Server/Services/IncidentService.ts

@@ -74,6 +74,17 @@ type UpdateCarryForward = Dictionary<{
   newMonitorChangeStatusIdTo: ObjectID | undefined;
 }>;
 
+type IncidentUpdatePayload = {
+  postmortemNote?: string | null;
+  title?: string | null;
+  rootCause?: string | null;
+  description?: string | null;
+  remediationNotes?: string | null;
+  labels?: unknown;
+  incidentSeverity?: unknown;
+  [key: string]: unknown;
+};
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -1303,8 +1314,8 @@ ${incident.remediationNotes || "No remediation notes provided."}
           incidentId,
         );
 
-        const updatedIncidentData: Partial<Model> =
-          onUpdate.updateBy.data || {};
+        const updatedIncidentData: IncidentUpdatePayload = (onUpdate.updateBy
+          .data ?? {}) as IncidentUpdatePayload;
 
         const createdByUserId: ObjectID | undefined | null =
           onUpdate.updateBy.props.userId;

package/Server/Services/Index.ts

@@ -71,6 +71,7 @@ import ProjectService from "./ProjectService";
 import ProjectSmtpConfigService from "./ProjectSmtpConfigService";
 import ProjectSsoService from "./ProjectSsoService";
 import PromoCodeService from "./PromoCodeService";
+import EnterpriseLicenseService from "./EnterpriseLicenseService";
 import ResellerPlanService from "./ResellerPlanService";
 import ResellerService from "./ResellerService";
 import ScheduledMaintenanceCustomFieldService from "./ScheduledMaintenanceCustomFieldService";
@@ -173,6 +174,7 @@ const services: Array<BaseService> = [
   OnCallDutyPolicyTimeLogService,
   AcmeCertificateService,
   PromoCodeService,
+  EnterpriseLicenseService,
 
   ResellerService,
   ResellerPlanService,