@oneuptime/common 12.0.18 → 12.0.20

package/Server/Infrastructure/Postgres/SchemaMigrations/1789000000000-AddUserSlackAndMicrosoftTeams.ts

@@ -0,0 +1,197 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Slack and Microsoft Teams as user notification methods.
+ *
+ * Two new per-user method tables (UserSlack / UserMicrosoftTeams — pointers at
+ * the user's OAuth workspace link, created verified), the notification-rule
+ * and on-call timeline foreign keys that let rules route pages to them, and
+ * the two per-event toggles on UserNotificationSetting.
+ */
+export class AddUserSlackAndMicrosoftTeams1789000000000
+  implements MigrationInterface
+{
+  public name = "AddUserSlackAndMicrosoftTeams1789000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "UserSlack" ("_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, "projectId" uuid NOT NULL, "slackUserId" character varying(100), "slackUserName" character varying(100), "userId" uuid, "createdByUserId" uuid, "deletedByUserId" uuid, "isVerified" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_86de4cd76b41a08811fc403e23a" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d5dd2503bf422c6a19946216e1" ON "UserSlack" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_abe4265455b18cd43a94bb84ed" ON "UserSlack" ("slackUserId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9c8fa391e949f53f670dabe222" ON "UserSlack" ("userId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "UserMicrosoftTeams" ("_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, "projectId" uuid NOT NULL, "microsoftTeamsUserId" character varying(100), "microsoftTeamsUserName" character varying(100), "userId" uuid, "createdByUserId" uuid, "deletedByUserId" uuid, "isVerified" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_9e2c27aadbc24a991c68e55c130" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_cebf1edfa5f30a7e597633bddf" ON "UserMicrosoftTeams" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_a746ef4fd29b03ac5abe8f4e4c" ON "UserMicrosoftTeams" ("microsoftTeamsUserId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e4405f9dacd3d1e3c363e8dbd3" ON "UserMicrosoftTeams" ("userId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD "userSlackId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD "userMicrosoftTeamsId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD "userSlackId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD "userMicrosoftTeamsId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" ADD "alertBySlack" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" ADD "alertByMicrosoftTeams" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0c24badba9b152d08700f7d8aa" ON "UserNotificationRule" ("userSlackId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3dc4e1c367eab9fd36b7983e44" ON "UserNotificationRule" ("userMicrosoftTeamsId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d51ef7b2a8b813d37e94890ff7" ON "UserOnCallLogTimeline" ("userSlackId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_a7206c19df5cdfe02cf3215a64" ON "UserOnCallLogTimeline" ("userMicrosoftTeamsId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_d5dd2503bf422c6a19946216e19" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_9c8fa391e949f53f670dabe2220" FOREIGN KEY ("userId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_fd38a9ee050702437ed323f21fb" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" ADD CONSTRAINT "FK_2f058862227400121f90925d65e" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_cebf1edfa5f30a7e597633bddf9" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_e4405f9dacd3d1e3c363e8dbd30" FOREIGN KEY ("userId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_81443b1ab79d63b7700f3d16c84" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" ADD CONSTRAINT "FK_1d7cfdf5a4e314cf4b4cc7873e0" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD CONSTRAINT "FK_0c24badba9b152d08700f7d8aa8" FOREIGN KEY ("userSlackId") REFERENCES "UserSlack"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" ADD CONSTRAINT "FK_3dc4e1c367eab9fd36b7983e444" FOREIGN KEY ("userMicrosoftTeamsId") REFERENCES "UserMicrosoftTeams"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD CONSTRAINT "FK_d51ef7b2a8b813d37e94890ff77" FOREIGN KEY ("userSlackId") REFERENCES "UserSlack"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" ADD CONSTRAINT "FK_a7206c19df5cdfe02cf3215a64c" FOREIGN KEY ("userMicrosoftTeamsId") REFERENCES "UserMicrosoftTeams"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP CONSTRAINT "FK_a7206c19df5cdfe02cf3215a64c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP CONSTRAINT "FK_d51ef7b2a8b813d37e94890ff77"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP CONSTRAINT "FK_3dc4e1c367eab9fd36b7983e444"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP CONSTRAINT "FK_0c24badba9b152d08700f7d8aa8"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_1d7cfdf5a4e314cf4b4cc7873e0"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_81443b1ab79d63b7700f3d16c84"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_e4405f9dacd3d1e3c363e8dbd30"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserMicrosoftTeams" DROP CONSTRAINT "FK_cebf1edfa5f30a7e597633bddf9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_2f058862227400121f90925d65e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_fd38a9ee050702437ed323f21fb"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_9c8fa391e949f53f670dabe2220"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserSlack" DROP CONSTRAINT "FK_d5dd2503bf422c6a19946216e19"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_a7206c19df5cdfe02cf3215a64"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d51ef7b2a8b813d37e94890ff7"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_3dc4e1c367eab9fd36b7983e44"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0c24badba9b152d08700f7d8aa"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" DROP COLUMN "alertByMicrosoftTeams"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationSetting" DROP COLUMN "alertBySlack"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP COLUMN "userMicrosoftTeamsId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserOnCallLogTimeline" DROP COLUMN "userSlackId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP COLUMN "userMicrosoftTeamsId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserNotificationRule" DROP COLUMN "userSlackId"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_e4405f9dacd3d1e3c363e8dbd3"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_a746ef4fd29b03ac5abe8f4e4c"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_cebf1edfa5f30a7e597633bddf"`,
+    );
+    await queryRunner.query(`DROP TABLE "UserMicrosoftTeams"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_9c8fa391e949f53f670dabe222"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_abe4265455b18cd43a94bb84ed"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d5dd2503bf422c6a19946216e1"`,
+    );
+    await queryRunner.query(`DROP TABLE "UserSlack"`);
+  }
+}

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

@@ -540,6 +540,10 @@ import { AddLlmModelPrice1788300000000 } from "./1788300000000-AddLlmModelPrice"
 import { AddMarketingConversionAttribution1788400000000 } from "./1788400000000-AddMarketingConversionAttribution";
 import { RemoveLlmCostBudgetAlertColumns1788500000000 } from "./1788500000000-RemoveLlmCostBudgetAlertColumns";
 import { AddDetectionRuleIncidentColumns1788600000000 } from "./1788600000000-AddDetectionRuleIncidentColumns";
+import { RemoveMarketingConversionUploadState1788700000000 } from "./1788700000000-RemoveMarketingConversionUploadState";
+import { DropMarketingConversionAddEnterpriseLicenseEmail1788800000000 } from "./1788800000000-DropMarketingConversionAddEnterpriseLicenseEmail";
+import { RedactStoredMonitorIngestSecrets1788900000000 } from "./1788900000000-RedactStoredMonitorIngestSecrets";
+import { AddUserSlackAndMicrosoftTeams1789000000000 } from "./1789000000000-AddUserSlackAndMicrosoftTeams";
 import { MigrationName1787142779538 } from "./1787142779538-MigrationName";
 import { MigrationName1787156982416 } from "./1787156982416-MigrationName";
 
@@ -1088,4 +1092,8 @@ export default [
   AddMarketingConversionAttribution1788400000000,
   RemoveLlmCostBudgetAlertColumns1788500000000,
   AddDetectionRuleIncidentColumns1788600000000,
+  RemoveMarketingConversionUploadState1788700000000,
+  DropMarketingConversionAddEnterpriseLicenseEmail1788800000000,
+  RedactStoredMonitorIngestSecrets1788900000000,
+  AddUserSlackAndMicrosoftTeams1789000000000,
 ];

package/Server/Infrastructure/Queue.ts

@@ -17,6 +17,13 @@ export enum QueueName {
   Worker = "Worker",
   Telemetry = "Telemetry",
   Runbook = "Runbook",
+  /*
+   * Outbound marketing conversion webhooks. Data-carrying (the job holds the
+   * whole event), unlike Worker, which looks its function up by name. Nothing
+   * stores these events, so this queue is the only thing that survives a
+   * receiver being briefly unreachable.
+   */
+  MarketingEvent = "MarketingEvent",
 }
 
 export type QueueJob = Job;

package/Server/Services/EnterpriseLicenseService.ts

@@ -1,10 +1,70 @@
 import DatabaseService from "./DatabaseService";
 import EnterpriseLicense from "../../Models/DatabaseModels/EnterpriseLicense";
+import MarketingEventUtil from "../Utils/Marketing/MarketingEventUtil";
+import { MarketingEventType } from "../../Types/Marketing/MarketingEvent";
+import { OnCreate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<EnterpriseLicense> {
   public constructor() {
     super(EnterpriseLicense);
   }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<EnterpriseLicense>,
+    createdItem: EnterpriseLicense,
+  ): Promise<EnterpriseLicense> {
+    /*
+     * The outbound enterprise_license_issued conversion.
+     *
+     * This is where sales-led revenue enters the funnel. Everything else
+     * OneUptime emits is self-serve and knows its own value from the plan
+     * table; an enterprise contract is negotiated, so annualContractValue is
+     * the only place the number exists at all.
+     *
+     * Emitted even with no email and no ACV. A licence issued without either
+     * is still a licence issued, and a receiver that sees the event can chase
+     * the missing detail — one that never sees it cannot. The two nulls are
+     * reported honestly rather than defaulted to zero, which would quietly
+     * drag reported contract value down.
+     */
+    MarketingEventUtil.emitInBackground(
+      MarketingEventUtil.buildEvent({
+        eventType: MarketingEventType.EnterpriseLicenseIssued,
+        eventId: `${MarketingEventType.EnterpriseLicenseIssued}:${createdItem.id?.toString()}`,
+        occurredAt: createdItem.createdAt || new Date(),
+        email: createdItem.email?.toString(),
+        /*
+         * No attribution source. A licence row is typed in by a human and
+         * carries no session, so its campaign is whatever the meeting_booked
+         * sharing its email carried — the join the receiver makes on
+         * emailHash, not something OneUptime can restate here.
+         */
+        data: {
+          enterpriseLicenseId: createdItem.id?.toString() || "",
+          companyName: createdItem.companyName || "",
+          annualContractValueInUSD:
+            createdItem.annualContractValue === undefined ||
+            createdItem.annualContractValue === null
+              ? null
+              : createdItem.annualContractValue,
+          currency: "USD",
+          isEvaluationLicense: Boolean(createdItem.isEvaluationLicense),
+          userLimit:
+            createdItem.userLimit === undefined ||
+            createdItem.userLimit === null
+              ? null
+              : createdItem.userLimit,
+          expiresAt: createdItem.expiresAt
+            ? createdItem.expiresAt.toISOString()
+            : null,
+        },
+      }),
+    );
+
+    return createdItem;
+  }
 }
 
 export default new Service();

package/Server/Services/Index.ts

@@ -145,7 +145,6 @@ import GlobalOidcProjectService from "./GlobalOidcProjectService";
 import PromoCodeService from "./PromoCodeService";
 import EnterpriseLicenseService from "./EnterpriseLicenseService";
 import EnterpriseLicenseInstanceService from "./EnterpriseLicenseInstanceService";
-import MarketingConversionService from "./MarketingConversionService";
 import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
 import RecommendationDismissalService from "./RecommendationDismissalService";
 import ResellerPlanService from "./ResellerPlanService";
@@ -213,6 +212,8 @@ import UserSmsService from "./UserSmsService";
 import UserIncomingCallNumberService from "./UserIncomingCallNumberService";
 import UserWhatsAppService from "./UserWhatsAppService";
 import UserTelegramService from "./UserTelegramService";
+import UserSlackService from "./UserSlackService";
+import UserMicrosoftTeamsService from "./UserMicrosoftTeamsService";
 import WorkflowLogService from "./WorkflowLogService";
 // Workflows.
 import WorkflowService from "./WorkflowService";
@@ -292,6 +293,7 @@ import WorkspaceSettingService from "./WorkspaceSettingService";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 import WorkspaceNotificationLogService from "./WorkspaceNotificationLogService";
 import WorkspaceNotificationSummaryService from "./WorkspaceNotificationSummaryService";
+import WorkspaceUserNotificationService from "./WorkspaceUserNotificationService";
 import OnCallDutyPolicyUserOverrideService from "./OnCallDutyPolicyUserOverrideService";
 
 import MonitorLogService from "./MonitorLogService";
@@ -309,7 +311,6 @@ const services: Array<BaseService> = [
   PromoCodeService,
   EnterpriseLicenseService,
   EnterpriseLicenseInstanceService,
-  MarketingConversionService,
   OpenSourceDeploymentService,
 
   ResellerService,
@@ -490,6 +491,8 @@ const services: Array<BaseService> = [
   UserIncomingCallNumberService,
   UserWhatsAppService,
   UserTelegramService,
+  UserSlackService,
+  UserMicrosoftTeamsService,
   UserTotpAuthService,
   UserWebAuthnService,
 
@@ -587,6 +590,7 @@ const services: Array<BaseService> = [
   WorkspaceNotificationRuleService,
   WorkspaceNotificationLogService,
   WorkspaceNotificationSummaryService,
+  WorkspaceUserNotificationService,
 
   ProjectSCIMLogService,
   StatusPageSCIMLogService,

package/Server/Services/LlmLogService.ts

@@ -57,24 +57,40 @@ export class Service extends DatabaseService<Model> {
     const incidentRunMembership: string = `EXISTS (SELECT 1 FROM "AIRun" AS "run" WHERE "run"."_id" = "log"."aiRunId" AND "run"."triggeredByIncidentId" IS NOT NULL AND "run"."triggeredByAlertId" IS NULL)`;
     const alertRunMembership: string = `EXISTS (SELECT 1 FROM "AIRun" AS "run" WHERE "run"."_id" = "log"."aiRunId" AND "run"."triggeredByIncidentId" IS NULL AND "run"."triggeredByAlertId" IS NOT NULL)`;
 
-    let subjectClause: string = `AND "log"."incidentId" IS NULL AND "log"."alertId" IS NULL AND NOT ("log"."feature" = ANY($4)) AND NOT ("log"."feature" = ANY($5)) AND NOT (${incidentRunMembership}) AND NOT (${alertRunMembership})`;
+    /*
+     * Placeholders and bindings are built together, per branch, because
+     * PostgreSQL derives a prepared statement's parameter count from the
+     * HIGHEST $n present in the text — not from what the driver sends. A
+     * branch that binds an argument it never references is rejected outright
+     * at Bind (bind message supplies 5 parameters, but prepared statement
+     * requires 4), and a branch that skips a placeholder is rejected at Parse
+     * (could not determine data type of parameter $4). Both are runtime-only
+     * failures no compiler catches, so the parameter array is grown next to
+     * the clause that reads it and never assembled apart from it.
+     */
+    const params: Array<unknown> = [
+      data.projectId.toString(), // $1
+      data.since, // $2
+      data.features, // $3
+    ];
+
+    let subjectClause: string;
 
     if (data.incidentId) {
+      params.push(legacyIncidentFeatures); // $4
       subjectClause = `AND (("log"."incidentId" IS NOT NULL AND "log"."alertId" IS NULL) OR ("log"."incidentId" IS NULL AND "log"."alertId" IS NULL AND (("log"."feature" = ANY($4)) OR ${incidentRunMembership})))`;
     } else if (data.alertId) {
-      subjectClause = `AND (("log"."incidentId" IS NULL AND "log"."alertId" IS NOT NULL) OR ("log"."incidentId" IS NULL AND "log"."alertId" IS NULL AND (("log"."feature" = ANY($5)) OR ${alertRunMembership})))`;
+      params.push(legacyAlertFeatures); // $4
+      subjectClause = `AND (("log"."incidentId" IS NULL AND "log"."alertId" IS NOT NULL) OR ("log"."incidentId" IS NULL AND "log"."alertId" IS NULL AND (("log"."feature" = ANY($4)) OR ${alertRunMembership})))`;
+    } else {
+      params.push(legacyIncidentFeatures, legacyAlertFeatures); // $4, $5
+      subjectClause = `AND "log"."incidentId" IS NULL AND "log"."alertId" IS NULL AND NOT ("log"."feature" = ANY($4)) AND NOT ("log"."feature" = ANY($5)) AND NOT (${incidentRunMembership}) AND NOT (${alertRunMembership})`;
     }
 
     const rows: Array<{ total: string | number | null }> =
       await this.getRepository().manager.query(
         `SELECT COALESCE(SUM("log"."totalTokens"), 0) AS "total" FROM "LlmLog" AS "log" WHERE "log"."projectId" = $1 AND "log"."createdAt" >= $2 AND "log"."feature" = ANY($3) ${subjectClause} AND "log"."deletedAt" IS NULL`,
-        [
-          data.projectId.toString(),
-          data.since,
-          data.features,
-          legacyIncidentFeatures,
-          legacyAlertFeatures,
-        ],
+        params,
       );
 
     return Number(rows[0]?.total || 0);

package/Server/Services/OnCallReadinessService.ts

@@ -16,6 +16,8 @@ import UserPushService from "./UserPushService";
 import UserService from "./UserService";
 import UserSmsService from "./UserSmsService";
 import UserTelegramService from "./UserTelegramService";
+import UserSlackService from "./UserSlackService";
+import UserMicrosoftTeamsService from "./UserMicrosoftTeamsService";
 import UserWebhookService from "./UserWebhookService";
 import UserWhatsAppService from "./UserWhatsAppService";
 import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
@@ -51,6 +53,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";
 
@@ -116,7 +120,7 @@ export enum ResponderSource {
 }
 
 /**
- * The seven channels a page can be delivered on. These strings are the same literals the
+ * The nine channels a page can be delivered on. These strings are the same literals the
  * fallback uses for `channelsUsed` (UserNotificationRuleService.chooseFallbackChannels),
  * deliberately: an operator reading "notified via fallback (Push, Email)" in an execution
  * log and "Push, Email" in the readiness table must not have to translate between two
@@ -129,6 +133,8 @@ export enum ReadinessMethodType {
   Call = "Call",
   WhatsApp = "WhatsApp",
   Telegram = "Telegram",
+  Slack = "Slack",
+  MicrosoftTeams = "Microsoft Teams",
   Webhook = "Webhook",
 }
 
@@ -436,6 +442,8 @@ const RULE_TYPE_SCOPES: Array<RuleTypeScope> = [
 const METHOD_DISPLAY_ORDER: Array<ReadinessMethodType> = [
   ReadinessMethodType.Push,
   ReadinessMethodType.Email,
+  ReadinessMethodType.Slack,
+  ReadinessMethodType.MicrosoftTeams,
   ReadinessMethodType.SMS,
   ReadinessMethodType.Call,
   ReadinessMethodType.WhatsApp,
@@ -2194,6 +2202,74 @@ export default class OnCallReadinessService {
       },
     });
 
+    await this.readEveryPage<UserSlack>({
+      description: "Slack notification methods",
+      projectId: projectId,
+      completeness: completeness,
+      service: UserSlackService,
+      query: {
+        projectId: projectId,
+        userId: new Includes(userIds),
+      },
+      /*
+       * The username only — never slackUserId. The member id is the
+       * addressable target the bot sends to; the username is the human-facing
+       * label, and it is the one a user can recognise as theirs.
+       */
+      select: {
+        _id: true,
+        userId: true,
+        slackUserName: true,
+        isVerified: true,
+      },
+      consumePage: (rows: Array<UserSlack>): void => {
+        for (const row of rows) {
+          addMethod(row, {
+            methodType: ReadinessMethodType.Slack,
+            maskedIdentifier: maskIdentifier(
+              row.slackUserName,
+              MaskedIdentifierKind.Handle,
+            ),
+            isVerified: Boolean(row.isVerified),
+          });
+        }
+      },
+    });
+
+    await this.readEveryPage<UserMicrosoftTeams>({
+      description: "Microsoft Teams notification methods",
+      projectId: projectId,
+      completeness: completeness,
+      service: UserMicrosoftTeamsService,
+      query: {
+        projectId: projectId,
+        userId: new Includes(userIds),
+      },
+      /*
+       * The display name only — never microsoftTeamsUserId. The Entra id is
+       * the addressable target the bot sends to; the display name is the
+       * human-facing label, and it is the one a user can recognise as theirs.
+       */
+      select: {
+        _id: true,
+        userId: true,
+        microsoftTeamsUserName: true,
+        isVerified: true,
+      },
+      consumePage: (rows: Array<UserMicrosoftTeams>): void => {
+        for (const row of rows) {
+          addMethod(row, {
+            methodType: ReadinessMethodType.MicrosoftTeams,
+            maskedIdentifier: maskIdentifier(
+              row.microsoftTeamsUserName,
+              MaskedIdentifierKind.Handle,
+            ),
+            isVerified: Boolean(row.isVerified),
+          });
+        }
+      },
+    });
+
     await this.readEveryPage<UserWebhook>({
       description: "webhook notification methods",
       projectId: projectId,
@@ -2677,7 +2753,7 @@ export default class OnCallReadinessService {
    * the real thing rather than a hopeful "some verified method".
    *
    * This mirrors UserNotificationRuleService.chooseFallbackChannels exactly, including
-   * the project switches: zero-cost channels first and BOTH of them if present, then one
+   * the project switches: zero-cost channels first and ALL of them if present, then one
    * paid channel in escalating-intrusiveness order, then webhook. If that function's
    * order ever changes, this one has to change with it — a readiness surface promising
    * "falls back to SMS" for a project that has SMS switched off is worse than saying
@@ -2709,6 +2785,14 @@ export default class OnCallReadinessService {
       zeroCost.push(ReadinessMethodType.Email);
     }
 
+    if (has(ReadinessMethodType.Slack)) {
+      zeroCost.push(ReadinessMethodType.Slack);
+    }
+
+    if (has(ReadinessMethodType.MicrosoftTeams)) {
+      zeroCost.push(ReadinessMethodType.MicrosoftTeams);
+    }
+
     if (zeroCost.length > 0) {
       return zeroCost;
     }