@oneuptime/common 12.0.17 → 12.0.19

package/Models/DatabaseModels/EnterpriseLicense.ts

@@ -8,6 +8,7 @@ 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 Email from "../../Types/Email";
 import IconProp from "../../Types/Icon/IconProp";
 import { Column, Entity, Index } from "typeorm";
 
@@ -47,6 +48,28 @@ export default class EnterpriseLicense extends BaseModel {
   })
   public companyName?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Email,
+    title: "Email",
+    description:
+      "Contact email for this license. Set it to the address the customer booked their meeting with, so the licence can be joined to the conversion that produced it.",
+  })
+  @Index("idx_enterprise_license_email")
+  @Column({
+    nullable: true,
+    type: ColumnType.Email,
+    length: ColumnLength.Email,
+    unique: false,
+    transformer: Email.getDatabaseTransformer(),
+  })
+  public email?: Email = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Models/DatabaseModels/Index.ts

@@ -278,6 +278,8 @@ import UserEmail from "./UserEmail";
 import UserPush from "./UserPush";
 import UserWhatsApp from "./UserWhatsApp";
 import UserTelegram from "./UserTelegram";
+import UserSlack from "./UserSlack";
+import UserMicrosoftTeams from "./UserMicrosoftTeams";
 import UserWebhook from "./UserWebhook";
 // User Notification Rules
 import UserNotificationRule from "./UserNotificationRule";
@@ -437,7 +439,6 @@ import MetricType from "./MetricType";
 import ProjectSCIM from "./ProjectSCIM";
 import ProjectSCIMLog from "./ProjectSCIMLog";
 import StatusPageSCIMLog from "./StatusPageSCIMLog";
-import MarketingConversion from "./MarketingConversion";
 import DeletedProject from "./DeletedProject";
 
 const AllModelTypes: Array<{
@@ -703,6 +704,8 @@ const AllModelTypes: Array<{
   UserPush,
   UserWhatsApp,
   UserTelegram,
+  UserSlack,
+  UserMicrosoftTeams,
   UserWebhook,
   UserIncomingCallNumber,
 
@@ -897,7 +900,6 @@ const AllModelTypes: Array<{
   RumSessionReplayView,
   RumSessionErasureRequest,
   RumSessionPin,
-  MarketingConversion,
   DeletedProject,
 ];
 

package/Models/DatabaseModels/Monitor.ts

@@ -1220,15 +1220,25 @@ export default class Monitor extends BaseModel {
 
   @ColumnAccessControl({
     create: [],
+    /*
+     * Gated on the ability to ROTATE the secret, not on the ability to view
+     * the monitor: this read list is deliberately identical to the update list
+     * below. A holder of this key can authenticate as any host
+     * agent reporting to the monitor -- forging or suppressing heartbeats.
+     *
+     * Viewer, MonitorViewer and ReadProjectMonitor used to be here. Viewer is
+     * the least privilege OneUptime grants and is what gets handed to
+     * dashboards, auditors, contractors and automations, so "read-only" also
+     * meant "can read a live bearer credential".
+     * https://github.com/OneUptime/oneuptime/issues/3360
+     */
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
       Permission.ProjectMember,
-      Permission.Viewer,
       Permission.MonitorAdmin,
       Permission.MonitorMember,
-      Permission.MonitorViewer,
-      Permission.ReadProjectMonitor,
+      Permission.EditProjectMonitor,
     ],
     update: [
       Permission.ProjectOwner,
@@ -1258,15 +1268,25 @@ export default class Monitor extends BaseModel {
 
   @ColumnAccessControl({
     create: [],
+    /*
+     * Gated on the ability to ROTATE the secret, not on the ability to view
+     * the monitor: this read list is deliberately identical to the update list
+     * below. This key IS the heartbeat URL: a holder can beat the
+     * monitor and keep a dead service looking alive.
+     *
+     * Viewer, MonitorViewer and ReadProjectMonitor used to be here. Viewer is
+     * the least privilege OneUptime grants and is what gets handed to
+     * dashboards, auditors, contractors and automations, so "read-only" also
+     * meant "can read a live bearer credential".
+     * https://github.com/OneUptime/oneuptime/issues/3360
+     */
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
       Permission.ProjectMember,
-      Permission.Viewer,
       Permission.MonitorAdmin,
       Permission.MonitorMember,
-      Permission.MonitorViewer,
-      Permission.ReadProjectMonitor,
+      Permission.EditProjectMonitor,
     ],
     update: [
       Permission.ProjectOwner,
@@ -1333,15 +1353,25 @@ export default class Monitor extends BaseModel {
 
   @ColumnAccessControl({
     create: [],
+    /*
+     * Gated on the ability to ROTATE the secret, not on the ability to view
+     * the monitor: this read list is deliberately identical to the update list
+     * below. This key IS the monitor's inbound address: a holder can
+     * send mail that the monitor counts as a heartbeat.
+     *
+     * Viewer, MonitorViewer and ReadProjectMonitor used to be here. Viewer is
+     * the least privilege OneUptime grants and is what gets handed to
+     * dashboards, auditors, contractors and automations, so "read-only" also
+     * meant "can read a live bearer credential".
+     * https://github.com/OneUptime/oneuptime/issues/3360
+     */
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,
       Permission.ProjectMember,
-      Permission.Viewer,
       Permission.MonitorAdmin,
       Permission.MonitorMember,
-      Permission.MonitorViewer,
-      Permission.ReadProjectMonitor,
+      Permission.EditProjectMonitor,
     ],
     update: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/UserMicrosoftTeams.ts

@@ -0,0 +1,344 @@
+import Project from "./Project";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import AllowAccessIfSubscriptionIsUnpaid from "../../Types/Database/AccessControl/AllowAccessIfSubscriptionIsUnpaid";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import OwnerOnlyColumn from "../../Types/Database/AccessControl/OwnerOnlyColumn";
+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 CurrentUserCanAccessRecordBy from "../../Types/Database/CurrentUserCanAccessRecordBy";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+
+/*
+ * `read` names Permission.CurrentUser and nothing else, exactly like the other
+ * notification-method models (UserTelegram has the full essay). That single
+ * entry is what keeps every row owner-only: row scoping comes from the TABLE
+ * list alone, and widening it would expose the Microsoft Entra user id every
+ * project member's pages are delivered to. Do not add administrator
+ * permissions here - OnCallReadinessService returns the masked,
+ * admin-sanctioned view instead.
+ *
+ * Unlike Telegram/SMS/WhatsApp there is no verification code: a row is only
+ * ever created from an existing, OAuth-established workspace link
+ * (WorkspaceUserAuthToken), so creation IS verification.
+ * UserMicrosoftTeamsService enforces that and stamps the Microsoft Teams
+ * identifiers server-side.
+ */
+@TenantColumn("projectId")
+@AllowAccessIfSubscriptionIsUnpaid()
+@TableAccessControl({
+  create: [Permission.CurrentUser],
+  read: [Permission.CurrentUser],
+  delete: [Permission.CurrentUser],
+  update: [Permission.CurrentUser],
+})
+@CrudApiEndpoint(new Route("/user-microsoft-teams"))
+@Entity({
+  name: "UserMicrosoftTeams",
+})
+@TableMetadata({
+  tableName: "UserMicrosoftTeams",
+  singularName: "Microsoft Teams Account",
+  pluralName: "Microsoft Teams Accounts",
+  icon: IconProp.MicrosoftTeams,
+  tableDescription:
+    "Microsoft Teams accounts used for Microsoft Teams notifications.",
+})
+@CurrentUserCanAccessRecordBy("userId")
+class UserMicrosoftTeams extends BaseModel {
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * CurrentUser here does NOT mean the client may choose the value: the
+     * service hook refuses any non-root payload that carries these columns
+     * and then stamps them itself, and hooks run BEFORE the column
+     * permission check (DatabaseService.create). The entry exists because
+     * that same check runs on the STAMPED data - with an empty list the
+     * server's own write is refused and no user can add this method at all.
+     * Same shape as UserWebAuthn's server-stamped isVerified.
+     */
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  /*
+   * The Microsoft Entra (Azure AD) object id the project's bot delivers
+   * direct messages to. Holding it is enough to address bot messages at that
+   * person, so it is a delivery target and not a label. Captured server-side
+   * from the user's own WorkspaceUserAuthToken - never writable by the client.
+   */
+  @OwnerOnlyColumn()
+  @TableColumn({
+    title: "Microsoft Teams User ID",
+    required: false,
+    unique: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    description:
+      "Microsoft Entra user ID captured from your connected Microsoft Teams account. Populated automatically.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    unique: false,
+    nullable: true,
+  })
+  public microsoftTeamsUserId?: string = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * CurrentUser here does NOT mean the client may choose the value: the
+     * service hook refuses any non-root payload that carries these columns
+     * and then stamps them itself, and hooks run BEFORE the column
+     * permission check (DatabaseService.create). The entry exists because
+     * that same check runs on the STAMPED data - with an empty list the
+     * server's own write is refused and no user can add this method at all.
+     * Same shape as UserWebAuthn's server-stamped isVerified.
+     */
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  /*
+   * The person's Microsoft Teams display name at the time the method was
+   * added. Only a label for the row, but it is still their identity in an
+   * outside workspace, so it stays owner-only like the Telegram handle.
+   */
+  @OwnerOnlyColumn()
+  @TableColumn({
+    title: "Microsoft Teams Username",
+    required: false,
+    unique: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    description:
+      "Display name captured from your connected Microsoft Teams account. Populated automatically.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    unique: false,
+    nullable: true,
+  })
+  public microsoftTeamsUserName?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "user",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "User",
+    description: "Relation to User who this Microsoft Teams account belongs to",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userId" })
+  public user?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "User ID",
+    description: "User ID who this Microsoft Teams account belongs to",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  @Index()
+  public userId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    modelType: User,
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * CurrentUser here does NOT mean the client may choose the value: the
+     * service hook refuses any non-root payload that carries these columns
+     * and then stamps them itself, and hooks run BEFORE the column
+     * permission check (DatabaseService.create). The entry exists because
+     * that same check runs on the STAMPED data - with an empty list the
+     * server's own write is refused and no user can add this method at all.
+     * Same shape as UserWebAuthn's server-stamped isVerified.
+     */
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    title: "Is Verified",
+    description: "Is this Microsoft Teams account verified?",
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    default: false,
+  })
+  public isVerified?: boolean = undefined;
+}
+
+export default UserMicrosoftTeams;

package/Models/DatabaseModels/UserNotificationRule.ts

@@ -7,6 +7,8 @@ import UserEmail from "./UserEmail";
 import UserPush from "./UserPush";
 import UserSMS from "./UserSMS";
 import UserTelegram from "./UserTelegram";
+import UserSlack from "./UserSlack";
+import UserMicrosoftTeams from "./UserMicrosoftTeams";
 import UserWebhook from "./UserWebhook";
 import UserWhatsApp from "./UserWhatsApp";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
@@ -80,9 +82,9 @@ const ADMIN_WRITE_PERMISSIONS: Array<Permission> = [
  * only EditProjectUserNotificationRule would leave the feature dead on arrival
  * for every project that already exists.
  *
- * Note the asymmetry with the seven notification-method models this rule points
+ * Note the asymmetry with the nine notification-method models this rule points
  * at (UserEmail, UserSMS, UserCall, UserPush, UserWhatsApp, UserTelegram,
- * UserWebhook). There, only `read` is widened. An administrator may see which
+ * UserSlack, UserMicrosoftTeams, UserWebhook). There, only `read` is widened. An administrator may see which
  * methods a member has and repair the rules that route to them, but may never
  * create or edit a method on somebody else's behalf. Letting them would hand
  * any administrator a paging-hijack primitive - add a phone number or webhook
@@ -382,11 +384,11 @@ class UserNotificationRule extends BaseModel {
   public deletedByUserId?: ObjectID = undefined;
 
   /*
-   * THE SEVEN METHOD RELATIONS BELOW ARE THE MOST DANGEROUS COLUMNS ON THIS
+   * THE NINE METHOD RELATIONS BELOW ARE THE MOST DANGEROUS COLUMNS ON THIS
    * MODEL. What follows applies to every one of them - userCall, userPush,
-   * userSms, userWhatsApp, userTelegram, userWebhook and userEmail, in both
-   * their relation and their `*Id` spelling - and is written out once here
-   * rather than fourteen times.
+   * userSms, userWhatsApp, userTelegram, userSlack, userMicrosoftTeams,
+   * userWebhook and userEmail, in both their relation and their `*Id`
+   * spelling - and is written out once here rather than eighteen times.
    *
    * A rule is a pair: the ownership column decides WHOSE pages select the row,
    * and the method relation decides WHERE those pages are delivered. The two
@@ -751,6 +753,139 @@ class UserNotificationRule extends BaseModel {
   })
   public userTelegramId?: ObjectID = undefined;
 
+  /*
+   * READ IS OWNER-ONLY ON THE RELATION, EVEN THOUGH THIS TABLE IS ADMIN-READABLE.
+   *
+   * Widening the relation would re-open the exposure that reverting the
+   * method models was meant to close, by a different route. A read of this
+   * table is NOT pinned to the caller's own rows for an administrator - that is
+   * the whole point of the phase - and QueryPermission.checkRelationQueryPermission
+   * authorises each nested field with relatedModel.hasReadPermissions, a
+   * name-intersection in which Permission.CurrentUser is auto-granted to every
+   * authenticated caller. So `select: { userSlack: { slackUserId: true } }` on somebody
+   * else's rule would hand back their raw Slack member id with no row scope
+   * anywhere in the path.
+   *
+   * The FK below stays admin-readable: an id is not sensitive, and it is what
+   * correlates a rule with the masked entry in OnCallReadinessService's
+   * ReadinessMethod { methodId, methodType, maskedIdentifier, isVerified }.
+   * That masked payload is the administrator's sanctioned view of a method.
+   */
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser, ...ADMIN_WRITE_PERMISSIONS],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "userSlackId",
+    type: TableColumnType.Entity,
+    modelType: UserSlack,
+    title: "User Slack",
+    description: "Relation to User Slack Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return UserSlack;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userSlackId" })
+  public userSlack?: UserSlack = undefined;
+
+  // Re-pointable by an administrator. Read the essay above `userCall` first.
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser, ...ADMIN_WRITE_PERMISSIONS],
+    read: [Permission.CurrentUser, ...ADMIN_READ_PERMISSIONS],
+    update: [...ADMIN_WRITE_PERMISSIONS],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "User Slack ID",
+    description: "ID of User Slack in which this object belongs",
+    example: "4d5e6f7a-8b9c-0d1e-2f3a-4b5c6d7e8f9a",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public userSlackId?: ObjectID = undefined;
+
+  /*
+   * READ IS OWNER-ONLY ON THE RELATION, EVEN THOUGH THIS TABLE IS ADMIN-READABLE.
+   *
+   * Widening the relation would re-open the exposure that reverting the
+   * method models was meant to close, by a different route. A read of this
+   * table is NOT pinned to the caller's own rows for an administrator - that is
+   * the whole point of the phase - and QueryPermission.checkRelationQueryPermission
+   * authorises each nested field with relatedModel.hasReadPermissions, a
+   * name-intersection in which Permission.CurrentUser is auto-granted to every
+   * authenticated caller. So `select: { userMicrosoftTeams: { microsoftTeamsUserId: true } }`
+   * on somebody else's rule would hand back their raw Microsoft Entra user id
+   * with no row scope anywhere in the path.
+   *
+   * The FK below stays admin-readable: an id is not sensitive, and it is what
+   * correlates a rule with the masked entry in OnCallReadinessService's
+   * ReadinessMethod { methodId, methodType, maskedIdentifier, isVerified }.
+   * That masked payload is the administrator's sanctioned view of a method.
+   */
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser, ...ADMIN_WRITE_PERMISSIONS],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "userMicrosoftTeamsId",
+    type: TableColumnType.Entity,
+    modelType: UserMicrosoftTeams,
+    title: "User Microsoft Teams",
+    description:
+      "Relation to User Microsoft Teams Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return UserMicrosoftTeams;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userMicrosoftTeamsId" })
+  public userMicrosoftTeams?: UserMicrosoftTeams = undefined;
+
+  // Re-pointable by an administrator. Read the essay above `userCall` first.
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser, ...ADMIN_WRITE_PERMISSIONS],
+    read: [Permission.CurrentUser, ...ADMIN_READ_PERMISSIONS],
+    update: [...ADMIN_WRITE_PERMISSIONS],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "User Microsoft Teams ID",
+    description: "ID of User Microsoft Teams in which this object belongs",
+    example: "5e6f7a8b-9c0d-1e2f-3a4b-5c6d7e8f9a0b",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public userMicrosoftTeamsId?: ObjectID = undefined;
+
   /*
    * READ IS OWNER-ONLY ON THE RELATION, EVEN THOUGH THIS TABLE IS ADMIN-READABLE.
    *
@@ -1020,8 +1155,9 @@ class UserNotificationRule extends BaseModel {
    * An opt-out row is a rule that exists in order to send nothing. It carries a
    * `ruleType` and a severity exactly like a normal rule, sets `isOptOut` to true, and
    * holds NO notification-method relation at all — there is no userEmail, userSms,
-   * userCall, userPush, userWhatsApp, userTelegram or userWebhook on it, and that
-   * absence is the point rather than a misconfiguration.
+   * userCall, userPush, userWhatsApp, userTelegram, userSlack, userMicrosoftTeams
+   * or userWebhook on it, and that absence is the point rather than a
+   * misconfiguration.
    *
    * It exists because "this user has zero rules matching this ruleType and severity" is
    * otherwise two completely different situations wearing the same clothes. Almost