@oneuptime/common 12.0.17 → 12.0.19

package/Tests/UI/Utils/PermissionGate.test.ts

@@ -464,4 +464,109 @@ describe("PermissionGate", () => {
       ).toBeNull();
     });
   });
+  /*
+   * Column-level gating, added for https://github.com/OneUptime/oneuptime/issues/3360.
+   *
+   * Record-level gating decides whether to render a button. Column-level
+   * gating decides whether a field may go into a SELECT, and the consequence
+   * of getting it wrong is much worse: ColumnPermission on the server throws
+   * `User is not allowed to read on <column> column of <model>` and fails the
+   * ENTIRE request, so one over-eager field blanks the whole page rather than
+   * one value. Monitor's secret keys are the first columns on Monitor a
+   * legitimate dashboard user can be refused, which is what made this helper
+   * necessary.
+   */
+  describe("canReadColumn", () => {
+    test("refuses a secret key column to a Viewer", () => {
+      permissionsForTest = [Permission.Viewer];
+
+      expect(
+        PermissionGate.canReadColumn(new Monitor(), "serverMonitorSecretKey"),
+      ).toBe(false);
+    });
+
+    test("allows a secret key column to a role that can rotate it", () => {
+      permissionsForTest = [Permission.ProjectAdmin];
+
+      expect(
+        PermissionGate.canReadColumn(new Monitor(), "serverMonitorSecretKey"),
+      ).toBe(true);
+    });
+
+    test("still allows the columns a Viewer is meant to see", () => {
+      /*
+       * The regression that would break the monitor page for read-only users:
+       * if this ever returns false, Pages/Monitor/View/Index.tsx stops asking
+       * for monitorType and the page cannot decide what kind of monitor it is
+       * looking at.
+       */
+      permissionsForTest = [Permission.Viewer];
+
+      expect(PermissionGate.canReadColumn(new Monitor(), "monitorType")).toBe(
+        true,
+      );
+    });
+
+    test("allows a master admin everything", () => {
+      isMasterAdminForTest = true;
+      permissionsForTest = [];
+
+      expect(
+        PermissionGate.canReadColumn(new Monitor(), "serverMonitorSecretKey"),
+      ).toBe(true);
+    });
+
+    test("fails closed while the permission snapshot has not loaded", () => {
+      /*
+       * The opposite call from PermissionGate.check, and deliberately so.
+       * check() hides a button rather than accuse someone of lacking a
+       * permission they hold. Here the recoverable outcome is omitting the
+       * field - the page renders without one value. Failing open would send
+       * the column and hard-fail the request.
+       */
+      permissionsForTest = [];
+
+      expect(
+        PermissionGate.canReadColumn(new Monitor(), "serverMonitorSecretKey"),
+      ).toBe(false);
+    });
+
+    test("allows a column that declares no read access control", () => {
+      /*
+       * Nothing to enforce, and ColumnPermission agrees - it only refuses
+       * columns that name permissions the user does not hold.
+       */
+      permissionsForTest = [Permission.Viewer];
+
+      expect(
+        PermissionGate.canReadColumn(
+          {
+            getColumnAccessControlForAllColumns: () => {
+              return { someColumn: { create: [], read: [], update: [] } };
+            },
+          },
+          "someColumn",
+        ),
+      ).toBe(true);
+    });
+
+    test("allows a column name the model does not know about", () => {
+      permissionsForTest = [Permission.Viewer];
+
+      expect(PermissionGate.canReadColumn(new Monitor(), "noSuchColumn")).toBe(
+        true,
+      );
+    });
+
+    test("honours an explicitly supplied permission snapshot", () => {
+      // Storage says Viewer; the caller passes something else and wins.
+      permissionsForTest = [Permission.Viewer];
+
+      expect(
+        PermissionGate.canReadColumn(new Monitor(), "serverMonitorSecretKey", {
+          permissions: [Permission.ProjectOwner],
+        }),
+      ).toBe(true);
+    });
+  });
 });

package/Tests/Utils/Dashboard/Components/DashboardComponentDefaults.test.ts

@@ -0,0 +1,257 @@
+import { describe, expect, test } from "@jest/globals";
+import DashboardComponentType from "../../../../Types/Dashboard/DashboardComponentType";
+import DashboardBaseComponent from "../../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import ObjectID from "../../../../Types/ObjectID";
+import { ObjectType } from "../../../../Types/JSON";
+import DashboardAlertListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardAlertListComponent";
+import DashboardCephOsdListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardCephOsdListComponent";
+import DashboardCephPoolListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardCephPoolListComponent";
+import DashboardChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardChartComponent";
+import DashboardClockComponentUtil from "../../../../Utils/Dashboard/Components/DashboardClockComponent";
+import DashboardDataSourceChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceChartComponent";
+import DashboardDataSourceGaugeComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceGaugeComponent";
+import DashboardDataSourceTableComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceTableComponent";
+import DashboardDataSourceValueComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDataSourceValueComponent";
+import DashboardDockerContainerListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerContainerListComponent";
+import DashboardDockerHostListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerHostListComponent";
+import DashboardDockerImageListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerImageListComponent";
+import DashboardDockerNetworkListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerNetworkListComponent";
+import DashboardDockerSwarmNodeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerSwarmNodeListComponent";
+import DashboardDockerSwarmServiceListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerSwarmServiceListComponent";
+import DashboardDockerVolumeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardDockerVolumeListComponent";
+import DashboardGaugeComponentUtil from "../../../../Utils/Dashboard/Components/DashboardGaugeComponent";
+import DashboardHostListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardHostListComponent";
+import DashboardHtmlComponentUtil from "../../../../Utils/Dashboard/Components/DashboardHtmlComponent";
+import DashboardIncidentListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardIncidentListComponent";
+import DashboardKubernetesCronJobListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesCronJobListComponent";
+import DashboardKubernetesDaemonSetListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesDaemonSetListComponent";
+import DashboardKubernetesDeploymentListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesDeploymentListComponent";
+import DashboardKubernetesJobListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesJobListComponent";
+import DashboardKubernetesNamespaceListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesNamespaceListComponent";
+import DashboardKubernetesNodeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesNodeListComponent";
+import DashboardKubernetesPodListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesPodListComponent";
+import DashboardKubernetesStatefulSetListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardKubernetesStatefulSetListComponent";
+import DashboardLogChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardLogChartComponent";
+import DashboardLogStreamComponentUtil from "../../../../Utils/Dashboard/Components/DashboardLogStreamComponent";
+import DashboardMonitorListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardMonitorListComponent";
+import DashboardNetworkMapComponentUtil from "../../../../Utils/Dashboard/Components/DashboardNetworkMapComponent";
+import DashboardPodmanContainerListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanContainerListComponent";
+import DashboardPodmanHostListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanHostListComponent";
+import DashboardPodmanImageListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanImageListComponent";
+import DashboardPodmanNetworkListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanNetworkListComponent";
+import DashboardPodmanVolumeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardPodmanVolumeListComponent";
+import DashboardProxmoxGuestListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardProxmoxGuestListComponent";
+import DashboardProxmoxNodeListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardProxmoxNodeListComponent";
+import DashboardSecurityEventsFlowComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSecurityEventsFlowComponent";
+import DashboardSecurityEventsListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSecurityEventsListComponent";
+import DashboardSloComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSloComponent";
+import DashboardTableComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTableComponent";
+import DashboardTextComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTextComponent";
+import DashboardTraceChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTraceChartComponent";
+import DashboardTraceListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTraceListComponent";
+import DashboardTraceTableComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTraceTableComponent";
+import DashboardValueComponentUtil from "../../../../Utils/Dashboard/Components/DashboardValueComponent";
+import DashboardBaseComponentUtil from "../../../../Utils/Dashboard/Components/DashboardBaseComponent";
+
+/*
+ * Every dashboard widget type ships a getDefaultComponent() that returns the
+ * seed component the editor drops onto the canvas when a user first adds that
+ * widget. Unlike getComponentSettingsArguments (dispatched through Index.ts and
+ * already covered by DashboardComponentsUtil.test.ts), these defaults have no
+ * central dispatcher — each util overrides the method independently. That makes
+ * them easy to get subtly wrong in ways the compiler cannot catch:
+ *
+ *   - copy-pasting a util and forgetting to change the componentType field, so
+ *     two widget types seed the same type and the editor renders the wrong one;
+ *   - a min dimension larger than the default dimension, so the widget is born
+ *     smaller than its own minimum and the resize logic clamps it on drop;
+ *   - a zero/negative width or height, so the widget is invisible on the grid;
+ *   - a shared componentId constant instead of a freshly generated ObjectID, so
+ *     two widgets on the same dashboard collide on id.
+ *
+ * This suite pins those invariants for all widget types at once. The TYPE_TO_UTIL
+ * map below must stay in lockstep with the enum; the exhaustiveness test fails
+ * loudly if a new widget type is added without a default to guard here.
+ */
+
+type ComponentUtil = {
+  getDefaultComponent: () => DashboardBaseComponent;
+};
+
+const TYPE_TO_UTIL: Record<DashboardComponentType, ComponentUtil> = {
+  [DashboardComponentType.Chart]: DashboardChartComponentUtil,
+  [DashboardComponentType.Text]: DashboardTextComponentUtil,
+  [DashboardComponentType.Clock]: DashboardClockComponentUtil,
+  [DashboardComponentType.Value]: DashboardValueComponentUtil,
+  [DashboardComponentType.Table]: DashboardTableComponentUtil,
+  [DashboardComponentType.Gauge]: DashboardGaugeComponentUtil,
+  [DashboardComponentType.DataSourceChart]:
+    DashboardDataSourceChartComponentUtil,
+  [DashboardComponentType.DataSourceValue]:
+    DashboardDataSourceValueComponentUtil,
+  [DashboardComponentType.DataSourceGauge]:
+    DashboardDataSourceGaugeComponentUtil,
+  [DashboardComponentType.DataSourceTable]:
+    DashboardDataSourceTableComponentUtil,
+  [DashboardComponentType.LogStream]: DashboardLogStreamComponentUtil,
+  [DashboardComponentType.LogChart]: DashboardLogChartComponentUtil,
+  [DashboardComponentType.SecurityEventsList]:
+    DashboardSecurityEventsListComponentUtil,
+  [DashboardComponentType.SecurityEventsFlow]:
+    DashboardSecurityEventsFlowComponentUtil,
+  [DashboardComponentType.TraceList]: DashboardTraceListComponentUtil,
+  [DashboardComponentType.TraceChart]: DashboardTraceChartComponentUtil,
+  [DashboardComponentType.TraceTable]: DashboardTraceTableComponentUtil,
+  [DashboardComponentType.IncidentList]: DashboardIncidentListComponentUtil,
+  [DashboardComponentType.AlertList]: DashboardAlertListComponentUtil,
+  [DashboardComponentType.MonitorList]: DashboardMonitorListComponentUtil,
+  [DashboardComponentType.Slo]: DashboardSloComponentUtil,
+  [DashboardComponentType.KubernetesPodList]:
+    DashboardKubernetesPodListComponentUtil,
+  [DashboardComponentType.KubernetesNodeList]:
+    DashboardKubernetesNodeListComponentUtil,
+  [DashboardComponentType.KubernetesNamespaceList]:
+    DashboardKubernetesNamespaceListComponentUtil,
+  [DashboardComponentType.KubernetesDeploymentList]:
+    DashboardKubernetesDeploymentListComponentUtil,
+  [DashboardComponentType.KubernetesStatefulSetList]:
+    DashboardKubernetesStatefulSetListComponentUtil,
+  [DashboardComponentType.KubernetesDaemonSetList]:
+    DashboardKubernetesDaemonSetListComponentUtil,
+  [DashboardComponentType.KubernetesJobList]:
+    DashboardKubernetesJobListComponentUtil,
+  [DashboardComponentType.KubernetesCronJobList]:
+    DashboardKubernetesCronJobListComponentUtil,
+  [DashboardComponentType.DockerHostList]: DashboardDockerHostListComponentUtil,
+  [DashboardComponentType.DockerContainerList]:
+    DashboardDockerContainerListComponentUtil,
+  [DashboardComponentType.DockerImageList]:
+    DashboardDockerImageListComponentUtil,
+  [DashboardComponentType.DockerNetworkList]:
+    DashboardDockerNetworkListComponentUtil,
+  [DashboardComponentType.DockerVolumeList]:
+    DashboardDockerVolumeListComponentUtil,
+  [DashboardComponentType.PodmanHostList]: DashboardPodmanHostListComponentUtil,
+  [DashboardComponentType.PodmanContainerList]:
+    DashboardPodmanContainerListComponentUtil,
+  [DashboardComponentType.PodmanImageList]:
+    DashboardPodmanImageListComponentUtil,
+  [DashboardComponentType.PodmanNetworkList]:
+    DashboardPodmanNetworkListComponentUtil,
+  [DashboardComponentType.PodmanVolumeList]:
+    DashboardPodmanVolumeListComponentUtil,
+  [DashboardComponentType.HostList]: DashboardHostListComponentUtil,
+  [DashboardComponentType.ProxmoxNodeList]:
+    DashboardProxmoxNodeListComponentUtil,
+  [DashboardComponentType.ProxmoxGuestList]:
+    DashboardProxmoxGuestListComponentUtil,
+  [DashboardComponentType.DockerSwarmNodeList]:
+    DashboardDockerSwarmNodeListComponentUtil,
+  [DashboardComponentType.DockerSwarmServiceList]:
+    DashboardDockerSwarmServiceListComponentUtil,
+  [DashboardComponentType.CephOsdList]: DashboardCephOsdListComponentUtil,
+  [DashboardComponentType.CephPoolList]: DashboardCephPoolListComponentUtil,
+  [DashboardComponentType.NetworkMap]: DashboardNetworkMapComponentUtil,
+  [DashboardComponentType.Html]: DashboardHtmlComponentUtil,
+};
+
+const ALL_TYPES: Array<DashboardComponentType> = Object.values(
+  DashboardComponentType,
+);
+
+describe("Dashboard component getDefaultComponent()", () => {
+  test("every DashboardComponentType has a default component guarded here", () => {
+    // If a new widget type is added to the enum, this fails until it is mapped.
+    for (const type of ALL_TYPES) {
+      expect(TYPE_TO_UTIL[type]).toBeDefined();
+    }
+    // And nothing stale: the map must not carry keys the enum dropped.
+    expect(Object.keys(TYPE_TO_UTIL).sort()).toEqual([...ALL_TYPES].sort());
+  });
+
+  test.each(ALL_TYPES)(
+    "%s default is a well-formed dashboard component",
+    (type: DashboardComponentType) => {
+      const component: DashboardBaseComponent =
+        TYPE_TO_UTIL[type].getDefaultComponent();
+
+      // It must be tagged as a dashboard component so serialization routes it right.
+      expect(component._type).toBe(ObjectType.DashboardComponent);
+
+      /*
+       * The seeded componentType must match the type the editor asked for; a
+       * copy-paste that leaves the wrong type here makes the widget render as a
+       * different kind than the one the user picked.
+       */
+      expect(component.componentType).toBe(type);
+
+      // A zero/negative footprint means the widget is invisible on the grid.
+      expect(component.widthInDashboardUnits).toBeGreaterThan(0);
+      expect(component.heightInDashboardUnits).toBeGreaterThan(0);
+      expect(component.minWidthInDashboardUnits).toBeGreaterThan(0);
+      expect(component.minHeightInDashboardUnits).toBeGreaterThan(0);
+
+      /*
+       * The default size must not start below its own minimum, or the resize
+       * clamp shrinks the widget the instant it is dropped.
+       */
+      expect(component.widthInDashboardUnits).toBeGreaterThanOrEqual(
+        component.minWidthInDashboardUnits,
+      );
+      expect(component.heightInDashboardUnits).toBeGreaterThanOrEqual(
+        component.minHeightInDashboardUnits,
+      );
+
+      // A widget is dropped at the origin; negative offsets place it off-grid.
+      expect(component.topInDashboardUnits).toBeGreaterThanOrEqual(0);
+      expect(component.leftInDashboardUnits).toBeGreaterThanOrEqual(0);
+
+      // The id must be a real, generated ObjectID (UUID), not a placeholder.
+      expect(component.componentId).toBeInstanceOf(ObjectID);
+      expect(ObjectID.isValidUUID(component.componentId.toString())).toBe(true);
+    },
+  );
+
+  test("no two widget types seed the same componentType", () => {
+    /*
+     * Guards the classic copy-paste bug: duplicating a util and forgetting to
+     * change componentType. Every default must report a distinct type.
+     */
+    const seededTypes: Array<DashboardComponentType> = ALL_TYPES.map(
+      (type: DashboardComponentType) => {
+        return TYPE_TO_UTIL[type].getDefaultComponent().componentType;
+      },
+    );
+    expect(new Set<DashboardComponentType>(seededTypes).size).toBe(
+      seededTypes.length,
+    );
+  });
+
+  test("each call generates a fresh componentId so widgets never collide", () => {
+    /*
+     * Two of the same widget added to one dashboard must not share an id, or
+     * selection/deletion in the editor would act on both at once. This only
+     * holds if getDefaultComponent() calls ObjectID.generate() per call rather
+     * than reusing a module-level constant.
+     */
+    for (const type of ALL_TYPES) {
+      const first: DashboardBaseComponent =
+        TYPE_TO_UTIL[type].getDefaultComponent();
+      const second: DashboardBaseComponent =
+        TYPE_TO_UTIL[type].getDefaultComponent();
+      expect(first.componentId.toString()).not.toBe(
+        second.componentId.toString(),
+      );
+    }
+  });
+
+  test("the base component util refuses to seed a component", () => {
+    /*
+     * The base class intentionally throws so a util that forgets to override
+     * getDefaultComponent() fails fast instead of returning a typeless stub.
+     */
+    expect(() => {
+      return DashboardBaseComponentUtil.getDefaultComponent();
+    }).toThrow();
+  });
+});

package/Types/Billing/PayAsYouGoPricing.ts

@@ -10,7 +10,7 @@
  * worse than quoting no price at all, so there is exactly one copy.
  */
 
-// Telemetry ingest - logs, traces, metrics and profiles.
+// Telemetry ingest - logs, traces, metrics, profiles and security events.
 export const TELEMETRY_PRICE_IN_USD_PER_GB: number = 0.1;
 
 /*

package/Types/Marketing/MarketingEvent.ts

@@ -0,0 +1,97 @@
+import { JSONObject } from "../JSON";
+
+/*
+ * The outbound marketing event contract.
+ *
+ * OneUptime does not keep a conversion ledger. The four moments worth
+ * measuring are emitted as signed webhooks at the instant they happen and are
+ * not stored here afterwards, so this interface — not a database table — is
+ * the whole record of what a conversion looks like.
+ *
+ * Two consequences follow from having no store, and both are the receiver's
+ * job rather than ours:
+ *
+ *   - DEDUPLICATION. `eventId` is stable for a given real-world occurrence, so
+ *     a redelivery carries the id the first attempt did. Retries are expected
+ *     (the queue retries, and Cal retries into us), so a receiver that keys on
+ *     anything else will double-count.
+ *   - ORDERING. Events are delivered per-occurrence with no sequence number.
+ *     A signup and a plan change seconds apart may arrive either way round;
+ *     order by `occurredAt`, never by arrival.
+ *
+ * Names are the same snake_case the browser funnel uses
+ * (Common/Types/Analytics/RevenueEvent.ts) so one event means one thing on
+ * both sides. Adding a property is safe; changing what an existing one means
+ * requires a new schema version.
+ */
+export enum MarketingEventType {
+  SignUp = "sign_up",
+  MeetingBooked = "meeting_booked",
+  SubscriptionUpgraded = "subscription_upgraded",
+  SubscriptionDowngraded = "subscription_downgraded",
+  /*
+   * A sales-led licence was issued, carrying its annual contract value.
+   *
+   * This is the only event that reports enterprise revenue, and the only one
+   * whose email is typed in by a human rather than captured from a session —
+   * which is exactly what makes it joinable: set EnterpriseLicense.email to
+   * the address the customer booked with and this event shares an identity
+   * with the meeting_booked that preceded it, months earlier.
+   */
+  EnterpriseLicenseIssued = "enterprise_license_issued",
+}
+
+export const MARKETING_EVENT_SCHEMA_VERSION: number = 1;
+
+/*
+ * The campaign the converting visitor carried.
+ *
+ * Copied from the User or Project row for a signup or a plan change, and read
+ * out of Cal booking metadata for a booked meeting. Every field is optional:
+ * a conversion with no attribution at all is still a conversion, and is still
+ * emitted.
+ */
+export interface MarketingEventAttribution extends JSONObject {
+  utmSource?: string | undefined;
+  utmMedium?: string | undefined;
+  utmCampaign?: string | undefined;
+  utmTerm?: string | undefined;
+  utmContent?: string | undefined;
+  utmUrl?: string | undefined;
+  clickIds: JSONObject;
+  firstTouch: JSONObject;
+}
+
+export interface MarketingEvent extends JSONObject {
+  schemaVersion: number;
+  /*
+   * Stable per real-world occurrence, and the receiver's deduplication key:
+   *
+   *   sign_up:{userId}
+   *   meeting_booked:{calBookingUid}
+   *   subscription_upgraded:{projectId}:{occurredAt}
+   *   subscription_downgraded:{projectId}:{occurredAt}
+   *   enterprise_license_issued:{enterpriseLicenseId}
+   *
+   * Three of these are naturally unique — a user signs up once, a booking has
+   * one uid, a licence row is issued once — so Cal retrying a delivery or the
+   * queue retrying a job cannot produce a second conversion. A plan change can
+   * legitimately recur for one project, so its id carries the instant it
+   * happened.
+   */
+  eventId: string;
+  eventType: MarketingEventType;
+  // ISO 8601, UTC. The moment the conversion happened, not the moment it was sent.
+  occurredAt: string;
+  /*
+   * Identity. Both forms are sent: the address for a direct CRM join, and its
+   * SHA-256 (trimmed and lowercased before hashing, per the usual ad-platform
+   * normalisation) for anywhere a digest is wanted instead. Absent only when
+   * OneUptime genuinely has no address for the conversion.
+   */
+  email?: string | undefined;
+  emailHash?: string | undefined;
+  attribution: MarketingEventAttribution;
+  // Event-specific detail. See the per-event builders in MarketingEventUtil.
+  data: JSONObject;
+}

package/UI/Utils/NotificationMethodUtil.ts

@@ -7,6 +7,8 @@ import UserNotificationRule from "../../Models/DatabaseModels/UserNotificationRu
 import UserPush from "../../Models/DatabaseModels/UserPush";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
 import UserTelegram from "../../Models/DatabaseModels/UserTelegram";
+import UserSlack from "../../Models/DatabaseModels/UserSlack";
+import UserMicrosoftTeams from "../../Models/DatabaseModels/UserMicrosoftTeams";
 import UserWebhook from "../../Models/DatabaseModels/UserWebhook";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
 import ObjectID from "../../Types/ObjectID";
@@ -37,6 +39,8 @@ export interface NotificationMethodModels {
   userPush: Array<UserPush>;
   userWhatsApps: Array<UserWhatsApp>;
   userTelegrams: Array<UserTelegram>;
+  userSlacks: Array<UserSlack>;
+  userMicrosoftTeamsAccounts: Array<UserMicrosoftTeams>;
   userWebhooks: Array<UserWebhook>;
 }
 
@@ -74,6 +78,16 @@ const NOTIFICATION_METHOD_RELATIONS: Array<NotificationMethodRelation> = [
     title: "Telegram",
     columns: ["telegramUserHandle", "telegramChatId"],
   },
+  {
+    relationName: "userSlack",
+    title: "Slack",
+    columns: ["slackUserName", "slackUserId"],
+  },
+  {
+    relationName: "userMicrosoftTeams",
+    title: "Microsoft Teams",
+    columns: ["microsoftTeamsUserName", "microsoftTeamsUserId"],
+  },
   /*
    * Only `name` is read here. A webhook URL is a bearer credential for
    * Slack/Discord/Teams style hooks, so it is deliberately never selected into
@@ -185,6 +199,24 @@ export default class NotificationMethodUtil {
       );
     }
 
+    if (model instanceof UserSlack) {
+      return (
+        "Slack: " +
+        (NotificationMethodUtil.readColumn(model, "slackUserName") ||
+          NotificationMethodUtil.readColumn(model, "slackUserId") ||
+          "Unknown Account")
+      );
+    }
+
+    if (model instanceof UserMicrosoftTeams) {
+      return (
+        "Microsoft Teams: " +
+        (NotificationMethodUtil.readColumn(model, "microsoftTeamsUserName") ||
+          NotificationMethodUtil.readColumn(model, "microsoftTeamsUserId") ||
+          "Unknown Account")
+      );
+    }
+
     const identifier: string =
       NotificationMethodUtil.readColumn(model, "phone") ||
       NotificationMethodUtil.readColumn(model, "email") ||
@@ -207,7 +239,7 @@ export default class NotificationMethodUtil {
 
   /*
    * Maps the id chosen in the dropdown back onto the rule being created. The
-   * dropdown is single-select, so at most one of the seven foreign keys is set.
+   * dropdown is single-select, so at most one of the nine foreign keys is set.
    * An id that matches nothing leaves the rule untouched, and the server then
    * rejects the create as having no notification method.
    */
@@ -258,6 +290,12 @@ export default class NotificationMethodUtil {
     assignById(models.userTelegrams, (id: ObjectID) => {
       rule.userTelegramId = id;
     });
+    assignById(models.userSlacks, (id: ObjectID) => {
+      rule.userSlackId = id;
+    });
+    assignById(models.userMicrosoftTeamsAccounts, (id: ObjectID) => {
+      rule.userMicrosoftTeamsId = id;
+    });
     assignById(models.userWebhooks, (id: ObjectID) => {
       rule.userWebhookId = id;
     });
@@ -279,6 +317,8 @@ export default class NotificationMethodUtil {
       ...models.userPush,
       ...models.userWhatsApps,
       ...models.userTelegrams,
+      ...models.userSlacks,
+      ...models.userMicrosoftTeamsAccounts,
       ...models.userWebhooks,
     ];
   }

package/UI/Utils/PermissionGate.ts

@@ -4,6 +4,7 @@ import Permission, {
   PermissionHelper,
   PermissionProps,
 } from "../../Types/Permission";
+import { ColumnAccessControl } from "../../Types/BaseDatabase/AccessControl";
 import PermissionUtil from "./Permission";
 import User from "./User";
 
@@ -52,6 +53,15 @@ export interface PermissionCheckableModel {
   getDeletePermissions: () => Array<Permission>;
 }
 
+/*
+ * A model that declares column-level access control. Separate from
+ * PermissionCheckableModel because column gating answers a different question
+ * ("may this field be SELECTED?") and only the database models carry it.
+ */
+export interface ColumnPermissionCheckableModel {
+  getColumnAccessControlForAllColumns: () => Dictionary<ColumnAccessControl>;
+}
+
 export interface PermissionGateOptions {
   /*
    * Overrides the permissions read from storage. Only used by tests and by
@@ -270,6 +280,52 @@ export default class PermissionGate {
     };
   }
 
+  /*
+   * Whether the signed-in user may SELECT a column.
+   *
+   * Column access control is enforced differently from record access control:
+   * asking for a column you cannot read is not degraded, it is fatal.
+   * ColumnPermission throws `User is not allowed to read on <column> column of
+   * <model>` and the whole request fails, so one unreadable field in a select
+   * takes down the entire page rather than blanking one value. That is why
+   * ModelAction has no column-level members (see the comment on the enum) and
+   * why callers must ask this BEFORE building the select, not after.
+   *
+   * Deliberately fails closed. When the permission snapshot has not landed yet
+   * this returns false and the caller omits the field: the page renders
+   * without that one value, which is recoverable. Failing open would send the
+   * column anyway and hard-fail the request, which is not.
+   *
+   * A column with no declared read ACL is readable - there is nothing to
+   * enforce, and ColumnPermission agrees.
+   */
+  public static canReadColumn(
+    model: ColumnPermissionCheckableModel,
+    columnName: string,
+    options?: PermissionGateOptions | undefined,
+  ): boolean {
+    if (User.isMasterAdmin()) {
+      return true;
+    }
+
+    const accessControl: ColumnAccessControl | undefined =
+      model.getColumnAccessControlForAllColumns()[columnName];
+
+    const columnPermissions: Array<Permission> = accessControl?.read || [];
+
+    if (columnPermissions.length === 0) {
+      return true;
+    }
+
+    const userPermissions: Array<Permission> =
+      options?.permissions ?? PermissionUtil.getAllPermissions();
+
+    return PermissionHelper.doesPermissionsIntersect(
+      userPermissions,
+      columnPermissions,
+    );
+  }
+
   /* Test seam - the props lookup is memoized for the lifetime of the page. */
   public static clearPermissionPropsCache(): void {
     permissionPropsCache = null;