fix(alerts): deliver legacy Slack alerts through a removed integration again

fix(webapp): restore Slack alert delivery for channels linked to removed
integrations

Mono-RevId: 941ebb4266026f8b64e9ea3f047a5605f34bc60e

Author: kathiekiwi

.server-changes/legacy-slack-deleted-integration.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Alerts sent to Slack channels connected through a removed Slack installation deliver again.

apps/webapp/app/v3/services/alerts/alertTransport.server.ts

@@ -24,23 +24,28 @@ const PERMANENT_WEBHOOK_STATUSES = [401, 403, 404, 410];
 
 export async function findSlackIntegration(
   prisma: { organizationIntegration: { findFirst: Function } },
-  params: { integrationId?: string | null; organizationId: string }
+  params: { integrationId?: string | null; organizationId: string },
+  options: { includeDeleted?: boolean } = {}
 ): Promise<OrganizationIntegrationForService<"SLACK"> | null> {
+  const findLatest = (where: { deletedAt?: null }) =>
+    prisma.organizationIntegration.findFirst({
+      where: { service: "SLACK", organizationId: params.organizationId, ...where },
+      orderBy: { createdAt: "desc" },
+      include: { tokenReference: true },
+    });
+
   const integration = params.integrationId
     ? await prisma.organizationIntegration.findFirst({
         where: {
           id: params.integrationId,
           service: "SLACK",
           organizationId: params.organizationId,
-          deletedAt: null,
+          ...(options.includeDeleted ? {} : { deletedAt: null }),
         },
         include: { tokenReference: true },
       })
-    : await prisma.organizationIntegration.findFirst({
-        where: { service: "SLACK", organizationId: params.organizationId, deletedAt: null },
-        orderBy: { createdAt: "desc" },
-        include: { tokenReference: true },
-      });
+    : ((await findLatest({ deletedAt: null })) ??
+      (options.includeDeleted ? await findLatest({}) : null));
 
   if (!integration || !isIntegrationForService(integration, "SLACK")) {
     return null;

apps/webapp/app/v3/services/alerts/deliverAlert.server.ts

@@ -761,10 +761,14 @@ export class DeliverAlertService extends BaseService {
       return;
     }
 
-    const integration = await findSlackIntegration(this._prisma, {
-      integrationId: slackProperties.data.integrationId,
-      organizationId: alert.project.organizationId,
-    });
+    const integration = await findSlackIntegration(
+      this._prisma,
+      {
+        integrationId: slackProperties.data.integrationId,
+        organizationId: alert.project.organizationId,
+      },
+      { includeDeleted: true }
+    );
 
     if (!integration) {
       logger.error("[DeliverAlert] Slack integration not found", {

apps/webapp/app/v3/services/alerts/deliverDashboardAgentWatchAlert.server.ts

@@ -277,10 +277,14 @@ export class DeliverDashboardAgentWatchChannelAlertService {
       return;
     }
 
-    const integration = await findSlackIntegration(prisma, {
-      integrationId: slackProperties.data.integrationId,
-      organizationId: payload.organizationId,
-    });
+    const integration = await findSlackIntegration(
+      prisma,
+      {
+        integrationId: slackProperties.data.integrationId,
+        organizationId: payload.organizationId,
+      },
+      { includeDeleted: true }
+    );
 
     if (!integration) {
       logger.error("[DeliverDashboardAgentWatchAlert] Slack integration not found");

apps/webapp/app/v3/services/alerts/deliverErrorGroupAlert.server.ts

@@ -28,6 +28,7 @@ import {
   buildErrorGroupSlackMessage,
   type ErrorAlertPayload,
 } from "./errorGroupSlackMessage.server";
+import { findSlackIntegration } from "./alertTransport.server";
 import { safeWebhookFetch } from "./safeWebhookFetch.server";
 
 class SkipRetryError extends Error {}
@@ -143,24 +144,14 @@ export class DeliverErrorGroupAlertService {
       return;
     }
 
-    const integration = slackProperties.data.integrationId
-      ? await prisma.organizationIntegration.findFirst({
-          where: {
-            id: slackProperties.data.integrationId,
-            organizationId: channel.project.organizationId,
-            deletedAt: null,
-          },
-          include: { tokenReference: true },
-        })
-      : await prisma.organizationIntegration.findFirst({
-          where: {
-            service: "SLACK",
-            organizationId: channel.project.organizationId,
-            deletedAt: null,
-          },
-          orderBy: { createdAt: "desc" },
-          include: { tokenReference: true },
-        });
+    const integration = await findSlackIntegration(
+      prisma,
+      {
+        integrationId: slackProperties.data.integrationId,
+        organizationId: channel.project.organizationId,
+      },
+      { includeDeleted: true }
+    );
 
     if (!integration || !isIntegrationForService(integration, "SLACK")) {
       logger.error("[DeliverErrorGroupAlert] Slack integration not found");

apps/webapp/app/v3/services/alerts/findSlackIntegration.server.test.ts

@@ -47,3 +47,60 @@ postgresTest("ignores a soft-deleted Slack integration", async ({ prisma }) => {
   ).toBeNull();
   expect(await findSlackIntegration(prisma, { organizationId: organization.id })).toBeNull();
 });
+
+postgresTest(
+  "resolves a soft-deleted integration by id when includeDeleted is set",
+  async ({ prisma }) => {
+    const { organization, integration } = await seed(prisma, true);
+
+    const byId = await findSlackIntegration(
+      prisma,
+      { integrationId: integration.id, organizationId: organization.id },
+      { includeDeleted: true }
+    );
+
+    expect(byId?.id).toBe(integration.id);
+  }
+);
+
+postgresTest(
+  "resolves a soft-deleted integration by organization when includeDeleted is set",
+  async ({ prisma }) => {
+    const { organization, integration } = await seed(prisma, true);
+
+    const byOrg = await findSlackIntegration(
+      prisma,
+      { organizationId: organization.id },
+      { includeDeleted: true }
+    );
+
+    expect(byOrg?.id).toBe(integration.id);
+  }
+);
+
+postgresTest(
+  "prefers an older live integration over a newer soft-deleted one when includeDeleted is set",
+  async ({ prisma }) => {
+    const { organization, integration: live } = await seed(prisma, false);
+    const secret = await prisma.secretReference.create({ data: { key: "slack-lookup-token-2" } });
+    await prisma.organizationIntegration.create({
+      data: {
+        friendlyId: generateFriendlyId("org_integration"),
+        service: "SLACK",
+        integrationData: {},
+        tokenReferenceId: secret.id,
+        organizationId: organization.id,
+        createdAt: new Date(Date.now() + 60_000),
+        deletedAt: new Date(),
+      },
+    });
+
+    const byOrg = await findSlackIntegration(
+      prisma,
+      { organizationId: organization.id },
+      { includeDeleted: true }
+    );
+
+    expect(byOrg?.id).toBe(live.id);
+  }
+);