fix(webapp): preserve hosted webhook endpoint status across deploys

ericallam · ericallam · commit 681f5664ea29 · 2026-08-08T13:04:54.000+01:00
A redeploy no longer re-activates a hosted webhook endpoint that was disabled via the API: the declarative sync only marks an endpoint active when it first creates it, so an operator disable survives future deploys. A deploy that omits the webhook list entirely (an older client) also no longer deactivates existing endpoints, which is now distinguished from an explicit empty list.
diff --git a/apps/webapp/app/v3/services/changeCurrentDeployment.server.ts b/apps/webapp/app/v3/services/changeCurrentDeployment.server.ts
@@ -219,7 +219,7 @@ export class ChangeCurrentDeploymentService extends BaseService {
 
     await syncDeclarativeSchedules(parsed.data.tasks, worker, environment, this._prisma);
     await syncDeclarativeWebhooks(
-      parsed.data.webhooks ?? [],
+      parsed.data.webhooks,
       worker,
       environment,
       this._prisma,
diff --git a/apps/webapp/app/v3/services/createBackgroundWorker.server.ts b/apps/webapp/app/v3/services/createBackgroundWorker.server.ts
@@ -209,7 +209,7 @@ export class CreateBackgroundWorkerService extends BaseService {
 
       const [webhooksError] = await tryCatch(
         syncDeclarativeWebhooks(
-          body.metadata.webhooks ?? [],
+          body.metadata.webhooks,
           backgroundWorker,
           environment,
           this._prisma,
@@ -673,13 +673,15 @@ function generateOpaqueId(): string {
 }
 
 export async function syncDeclarativeWebhooks(
-  webhooks: WebhookResource[],
+  webhooks: WebhookResource[] | undefined,
   worker: BackgroundWorker,
   environment: AuthenticatedEnvironment,
   prisma: PrismaClientOrTransaction,
   // Endpoint rows live on the webhook DB; the task-existence check below stays on the main client.
   webhookPrisma: WebhookDatabase
 ) {
+  if (webhooks === undefined) return;
+
   const existing = await webhookPrisma.webhookEndpoint.findMany({
     where: {
       runtimeEnvironmentId: environment.id,
@@ -751,7 +753,6 @@ export async function syncDeclarativeWebhooks(
           verifierArtifact: wh.verifierArtifact as unknown as Prisma.InputJsonValue,
           secretProvisioning: wh.secretProvisioning ?? "either",
           metadata: (wh.metadata ?? {}) as unknown as Prisma.InputJsonValue,
-          status: "ACTIVE",
           ...filterData,
         },
       });
diff --git a/apps/webapp/app/v3/services/createDeploymentBackgroundWorkerV4.server.ts b/apps/webapp/app/v3/services/createDeploymentBackgroundWorkerV4.server.ts
@@ -232,7 +232,7 @@ export class CreateDeploymentBackgroundWorkerServiceV4 extends BaseService {
 
       const [webhooksError] = await tryCatch(
         syncDeclarativeWebhooks(
-          body.metadata.webhooks ?? [],
+          body.metadata.webhooks,
           backgroundWorker,
           environment,
           this._prisma,
diff --git a/apps/webapp/test/syncDeclarativeWebhooks.test.ts b/apps/webapp/test/syncDeclarativeWebhooks.test.ts
@@ -0,0 +1,190 @@
+import { containerTest } from "@internal/testcontainers";
+import type { WebhookResource } from "@trigger.dev/core/v3";
+import type { BackgroundWorker, PrismaClient } from "@trigger.dev/database";
+import { describe, expect, vi } from "vitest";
+import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { syncDeclarativeWebhooks } from "~/v3/services/createBackgroundWorker.server";
+
+vi.setConfig({ testTimeout: 60_000 });
+
+type WorkerArg = Parameters<typeof syncDeclarativeWebhooks>[1];
+const noWorker = {} as unknown as WorkerArg;
+
+async function seedProjectWithEnv(prisma: PrismaClient) {
+  const slug = `sdw_${Math.random().toString(36).slice(2, 10)}`;
+  const organization = await prisma.organization.create({ data: { title: slug, slug } });
+  const project = await prisma.project.create({
+    data: { name: slug, slug, organizationId: organization.id, externalRef: slug },
+  });
+  const environment = await prisma.runtimeEnvironment.create({
+    data: {
+      slug: "prod",
+      type: "PRODUCTION",
+      projectId: project.id,
+      organizationId: organization.id,
+      apiKey: `tr_prod_${slug}`,
+      pkApiKey: `pk_prod_${slug}`,
+      shortcode: `p${slug.slice(0, 5)}`,
+    },
+  });
+  return { organization, project, environment };
+}
+
+async function seedWorkerWithTask(
+  prisma: PrismaClient,
+  project: { id: string },
+  environment: { id: string },
+  taskSlug: string
+): Promise<BackgroundWorker> {
+  const suffix = Math.random().toString(36).slice(2, 10);
+  const worker = await prisma.backgroundWorker.create({
+    data: {
+      friendlyId: `worker_${suffix}`,
+      contentHash: `hash_${suffix}`,
+      version: "20260101.1",
+      metadata: {},
+      projectId: project.id,
+      runtimeEnvironmentId: environment.id,
+    },
+  });
+  await prisma.backgroundWorkerTask.create({
+    data: {
+      friendlyId: `task_${suffix}`,
+      slug: taskSlug,
+      filePath: `src/trigger/${taskSlug}.ts`,
+      workerId: worker.id,
+      projectId: project.id,
+      runtimeEnvironmentId: environment.id,
+    },
+  });
+  return worker;
+}
+
+async function seedEndpoint(
+  prisma: PrismaClient,
+  base: { organizationId: string; projectId: string; runtimeEnvironmentId: string },
+  handlerWebhookId: string,
+  status: "ACTIVE" | "INACTIVE"
+) {
+  const suffix = Math.random().toString(36).slice(2, 10);
+  return prisma.webhookEndpoint.create({
+    data: {
+      friendlyId: `wh_${suffix}`,
+      opaqueId: `op_${suffix}${Math.random().toString(36).slice(2, 10)}`,
+      organizationId: base.organizationId,
+      projectId: base.projectId,
+      runtimeEnvironmentId: base.runtimeEnvironmentId,
+      environmentType: "PRODUCTION",
+      source: "stripe",
+      handlerWebhookId,
+      routingTarget: { type: "task", taskId: "handle-stripe" },
+      verifierArtifact: { kind: "bundle", bundleUrl: "https://example.test/v.js", hash: "h" },
+      status,
+    },
+  });
+}
+
+function makeWebhookResource(id: string, taskId: string): WebhookResource {
+  return {
+    id,
+    filePath: `src/trigger/${id}.ts`,
+    source: "stripe",
+    verifierArtifact: { kind: "bundle", bundleUrl: "https://example.test/v.js", hash: "h" },
+    routingTarget: { type: "task", taskId },
+  };
+}
+
+const asEnv = (env: unknown) => env as AuthenticatedEnvironment;
+
+describe("syncDeclarativeWebhooks status reconciliation", () => {
+  containerTest(
+    "an absent webhooks list (older client) does not deactivate existing endpoints",
+    async ({ prisma }) => {
+      const { organization, project, environment } = await seedProjectWithEnv(prisma);
+      const endpoint = await seedEndpoint(
+        prisma,
+        {
+          organizationId: organization.id,
+          projectId: project.id,
+          runtimeEnvironmentId: environment.id,
+        },
+        "declared-webhook",
+        "ACTIVE"
+      );
+
+      await syncDeclarativeWebhooks(undefined, noWorker, asEnv(environment), prisma, prisma);
+
+      const after = await prisma.webhookEndpoint.findUniqueOrThrow({ where: { id: endpoint.id } });
+      expect(after.status).toBe("ACTIVE");
+    }
+  );
+
+  containerTest(
+    "an explicit empty list deactivates endpoints that are no longer declared",
+    async ({ prisma }) => {
+      const { organization, project, environment } = await seedProjectWithEnv(prisma);
+      const endpoint = await seedEndpoint(
+        prisma,
+        {
+          organizationId: organization.id,
+          projectId: project.id,
+          runtimeEnvironmentId: environment.id,
+        },
+        "declared-webhook",
+        "ACTIVE"
+      );
+
+      await syncDeclarativeWebhooks([], noWorker, asEnv(environment), prisma, prisma);
+
+      const after = await prisma.webhookEndpoint.findUniqueOrThrow({ where: { id: endpoint.id } });
+      expect(after.status).toBe("INACTIVE");
+    }
+  );
+
+  containerTest(
+    "a redeploy does not re-activate an endpoint disabled via the API",
+    async ({ prisma }) => {
+      const { organization, project, environment } = await seedProjectWithEnv(prisma);
+      const worker = await seedWorkerWithTask(prisma, project, environment, "handle-stripe");
+      const endpoint = await seedEndpoint(
+        prisma,
+        {
+          organizationId: organization.id,
+          projectId: project.id,
+          runtimeEnvironmentId: environment.id,
+        },
+        "declared-webhook",
+        "INACTIVE"
+      );
+
+      await syncDeclarativeWebhooks(
+        [makeWebhookResource("declared-webhook", "handle-stripe")],
+        worker,
+        asEnv(environment),
+        prisma,
+        prisma
+      );
+
+      const after = await prisma.webhookEndpoint.findUniqueOrThrow({ where: { id: endpoint.id } });
+      expect(after.status).toBe("INACTIVE");
+    }
+  );
+
+  containerTest("a newly declared webhook creates an active endpoint", async ({ prisma }) => {
+    const { project, environment } = await seedProjectWithEnv(prisma);
+    const worker = await seedWorkerWithTask(prisma, project, environment, "handle-stripe");
+
+    await syncDeclarativeWebhooks(
+      [makeWebhookResource("brand-new-webhook", "handle-stripe")],
+      worker,
+      asEnv(environment),
+      prisma,
+      prisma
+    );
+
+    const created = await prisma.webhookEndpoint.findFirst({
+      where: { runtimeEnvironmentId: environment.id, handlerWebhookId: "brand-new-webhook" },
+    });
+    expect(created?.status).toBe("ACTIVE");
+  });
+});
