@oneuptime/common 11.3.19 → 11.3.21

package/Models/DatabaseModels/EnterpriseLicenseInstance.ts

@@ -0,0 +1,173 @@
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import EnterpriseLicense from "./EnterpriseLicense";
+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 ObjectID from "../../Types/ObjectID";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+
+@TableAccessControl({
+  create: [],
+  read: [],
+  update: [],
+  delete: [],
+})
+@CrudApiEndpoint(new Route("/enterprise-license-instance"))
+@TableMetadata({
+  tableName: "EnterpriseLicenseInstance",
+  singularName: "Enterprise License Instance",
+  pluralName: "Enterprise License Instances",
+  icon: IconProp.Lock,
+  tableDescription:
+    "Self-hosted OneUptime instances that report usage against an enterprise license. One license can be used across multiple instances (staging, production, etc.) and users are counted uniquely across all of them.",
+})
+@Entity({
+  name: "EnterpriseLicenseInstance",
+})
+// One row per instance per license — upserts rely on this being unique.
+@Index(["enterpriseLicenseId", "instanceId"], { unique: true })
+export default class EnterpriseLicenseInstance extends BaseModel {
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "enterpriseLicenseId",
+    type: TableColumnType.Entity,
+    modelType: EnterpriseLicense,
+    title: "Enterprise License",
+    description: "Enterprise license this instance reports usage against.",
+  })
+  @ManyToOne(
+    () => {
+      return EnterpriseLicense;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "enterpriseLicenseId" })
+  public enterpriseLicense?: EnterpriseLicense = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Enterprise License ID",
+    description: "ID of the enterprise license this instance belongs to.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public enterpriseLicenseId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "Instance ID",
+    description:
+      "Unique identifier of the self-hosted OneUptime instance (auto-generated on the instance when it is installed).",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public instanceId?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Host",
+    description:
+      "Host of the self-hosted instance (for example oneuptime.acme.com). Shown to the customer so they can tell instances apart.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public host?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "User Count",
+    description: "Most recent user count reported by this instance.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Number,
+  })
+  public userCount?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.JSON,
+    title: "User Email Hashes",
+    description:
+      "SHA-256 hashes of the emails of users on this instance. Used to count unique users across all instances of a license without storing raw emails.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public userEmailHashes?: Array<string> = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "Last Reported At",
+    description: "Timestamp of the most recent report from this instance.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Date,
+  })
+  public lastReportedAt?: Date = undefined;
+}

package/Models/DatabaseModels/GlobalConfig.ts

@@ -13,6 +13,7 @@ import Email from "../../Types/Email";
 import MailTransportType from "../../Types/Email/MailTransportType";
 import OAuthProviderType from "../../Types/Email/OAuthProviderType";
 import SMTPAuthenticationType from "../../Types/Email/SMTPAuthenticationType";
+import EnterpriseLicenseInstanceSummary from "../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
 import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Phone from "../../Types/Phone";
@@ -42,6 +43,26 @@ export enum EmailServerType {
   update: [],
 })
 export default class GlobalConfig extends GlobalConfigModel {
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    computed: true,
+    title: "Instance ID",
+    description:
+      "Unique identifier for this OneUptime instance. Auto-generated when the instance is installed.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    unique: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public instanceId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],
@@ -854,6 +875,24 @@ export default class GlobalConfig extends GlobalConfigModel {
   })
   public enterpriseLicenseUserCountUpdatedAt?: Date = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    title: "Enterprise License Instances",
+    description:
+      "Instances (staging, production, etc.) that share the validated enterprise license, as last reported by OneUptime. Users are counted uniquely across all of them.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public enterpriseLicenseInstances?: Array<EnterpriseLicenseInstanceSummary> =
+    undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Models/DatabaseModels/Index.ts

@@ -182,6 +182,7 @@ import GlobalSSOProject from "./GlobalSsoProject";
 import GlobalOIDCProject from "./GlobalOidcProject";
 import PromoCode from "./PromoCode";
 import EnterpriseLicense from "./EnterpriseLicense";
+import EnterpriseLicenseInstance from "./EnterpriseLicenseInstance";
 import OpenSourceDeployment from "./OpenSourceDeployment";
 import Reseller from "./Reseller";
 import ResellerPlan from "./ResellerPlan";
@@ -651,6 +652,7 @@ const AllModelTypes: Array<{
 
   PromoCode,
   EnterpriseLicense,
+  EnterpriseLicenseInstance,
   OpenSourceDeployment,
 
   GlobalConfig,

package/Server/API/DashboardAPI.ts

@@ -375,6 +375,58 @@ const PUBLIC_DASHBOARD_RESOURCES: Record<
   },
 };
 
+type ResolveDashboardIdOrThrowFunction = (
+  dashboardIdOrDomain: string,
+) => Promise<ObjectID>;
+
+/*
+ * Resolve the :dashboardIdOrDomain route param to a dashboard ID. Accepts
+ * either a dashboard ID (UUID) or a verified custom dashboard domain —
+ * same contract as the status page overview endpoint.
+ */
+const resolveDashboardIdOrThrow: ResolveDashboardIdOrThrowFunction = async (
+  dashboardIdOrDomain: string,
+): Promise<ObjectID> => {
+  if (!dashboardIdOrDomain) {
+    throw new NotFoundException("Dashboard not found");
+  }
+
+  if (dashboardIdOrDomain.includes(".")) {
+    const dashboardDomain: DashboardDomain | null =
+      await DashboardDomainService.findOneBy({
+        query: {
+          fullDomain: dashboardIdOrDomain,
+          domain: {
+            isVerified: true,
+          } as any,
+        },
+        select: {
+          dashboardId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!dashboardDomain || !dashboardDomain.dashboardId) {
+      throw new NotFoundException("Dashboard not found");
+    }
+
+    return dashboardDomain.dashboardId;
+  }
+
+  try {
+    ObjectID.validateUUID(dashboardIdOrDomain);
+    return new ObjectID(dashboardIdOrDomain);
+  } catch (err) {
+    logger.error(
+      `Error converting dashboardIdOrDomain to ObjectID: ${dashboardIdOrDomain}`,
+    );
+    logger.error(err);
+    throw new NotFoundException("Dashboard not found");
+  }
+};
+
 export default class DashboardAPI extends BaseAPI<
   Dashboard,
   DashboardServiceType
@@ -476,6 +528,111 @@ export default class DashboardAPI extends BaseAPI<
       },
     );
 
+    /*
+     * Shared handler for the public overview endpoint. Registered for both
+     * POST and GET (machine-readable access for crawlers / AI agents that
+     * only issue plain GET requests — discovered via llms.txt on public
+     * dashboard URLs) so the authentication and authorization path can
+     * never drift between the two methods. It does not read req.body.
+     */
+    const overviewHandler: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      try {
+        const dashboardId: ObjectID = await resolveDashboardIdOrThrow(
+          req.params["dashboardIdOrDomain"] as string,
+        );
+
+        // Check read access (handles public check, IP whitelist, master password)
+        const accessResult: {
+          hasReadAccess: boolean;
+          error?: NotAuthenticatedException | ForbiddenException;
+        } = await DashboardService.hasReadAccess({
+          dashboardId,
+          req,
+        });
+
+        if (!accessResult.hasReadAccess) {
+          throw (
+            accessResult.error ||
+            new BadDataException("Access denied to this dashboard.")
+          );
+        }
+
+        const dashboard: Dashboard | null = await DashboardService.findOneById({
+          id: dashboardId,
+          select: {
+            _id: true,
+            name: true,
+            description: true,
+            pageTitle: true,
+            pageDescription: true,
+            dashboardViewConfig: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (!dashboard) {
+          throw new NotFoundException("Dashboard not found");
+        }
+
+        /*
+         * Everything below is derived from columns the public /metadata and
+         * /view-config endpoints already serve to anonymous viewers — the
+         * overview only reshapes them into a single GET-able document.
+         */
+        return Response.sendJsonObjectResponse(req, res, {
+          _id: dashboard._id?.toString() || "",
+          name: dashboard.name || "Dashboard",
+          description: dashboard.description || "",
+          pageTitle: dashboard.pageTitle || "",
+          pageDescription: dashboard.pageDescription || "",
+          components: DashboardAPI.buildPublicComponentSummaries(
+            dashboard.dashboardViewConfig,
+          ),
+          metricsUsed: Array.from(
+            DashboardAPI.collectDashboardMetricNames(
+              dashboard.dashboardViewConfig,
+            ),
+          ).sort(),
+          dashboardViewConfig: dashboard.dashboardViewConfig
+            ? JSONFunctions.serialize(dashboard.dashboardViewConfig as any)
+            : null,
+        });
+      } catch (err) {
+        next(err);
+      }
+    };
+
+    const overviewApiPath: string = `${new this.entityType()
+      .getCrudApiPath()
+      ?.toString()}/overview/:dashboardIdOrDomain`;
+
+    this.router.post(
+      overviewApiPath,
+      UserMiddleware.getUserMiddleware,
+      overviewHandler,
+    );
+
+    /*
+     * GET variant of the overview endpoint. Same middleware and same handler
+     * as the POST route above — non-public dashboards are rejected for
+     * unauthenticated callers exactly as they are on POST.
+     */
+    this.router.get(
+      overviewApiPath,
+      UserMiddleware.getUserMiddleware,
+      overviewHandler,
+    );
+
     // Domain resolution endpoint
     this.router.post(
       `${new this.entityType().getCrudApiPath()?.toString()}/domain`,
@@ -1079,6 +1236,70 @@ export default class DashboardAPI extends BaseAPI<
     );
   }
 
+  /*
+   * Build a compact machine-readable summary of the widgets on a dashboard
+   * for the public overview endpoint. Derived entirely from the stored
+   * dashboardViewConfig (already served to public viewers by /view-config) —
+   * this only lifts out the human-meaningful fields (widget type, title,
+   * text, metric names). The config comes straight from a JSON column, so
+   * every field is read defensively.
+   */
+  private static buildPublicComponentSummaries(
+    dashboardViewConfig: unknown,
+  ): Array<JSONObject> {
+    const summaries: Array<JSONObject> = [];
+
+    const components: unknown =
+      dashboardViewConfig && typeof dashboardViewConfig === "object"
+        ? (dashboardViewConfig as Record<string, unknown>)["components"]
+        : undefined;
+
+    if (!Array.isArray(components)) {
+      return summaries;
+    }
+
+    for (const component of components) {
+      if (!component || typeof component !== "object") {
+        continue;
+      }
+
+      const componentObject: Record<string, unknown> = component as Record<
+        string,
+        unknown
+      >;
+
+      const argumentsObject: Record<string, unknown> =
+        componentObject["arguments"] &&
+        typeof componentObject["arguments"] === "object"
+          ? (componentObject["arguments"] as Record<string, unknown>)
+          : {};
+
+      const getStringArgument: (key: string) => string | null = (
+        key: string,
+      ): string | null => {
+        const value: unknown = argumentsObject[key];
+        return typeof value === "string" && value.trim().length > 0
+          ? value
+          : null;
+      };
+
+      summaries.push({
+        componentType:
+          typeof componentObject["componentType"] === "string"
+            ? componentObject["componentType"]
+            : "",
+        title: getStringArgument("chartTitle") || getStringArgument("title"),
+        description: getStringArgument("chartDescription"),
+        text: getStringArgument("text"),
+        metricNames: Array.from(
+          DashboardAPI.collectDashboardMetricNames(component),
+        ).sort(),
+      });
+    }
+
+    return summaries;
+  }
+
   /*
    * Walk a stored dashboard view config and collect every metric name it
    * references (chart/value/gauge/table widgets all carry their metric in a