fix(webapp): re-sync webhook endpoints on promote and rollback

Promoting or rolling back a deployment now updates webhook endpoints to match the deployment that becomes current.

Mono-RevId: dff3d7c34e49b2a8f7e4e5a4b4cc79b145e98888

Author: ericallam

.server-changes/webhook-endpoints-sync-on-promote.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Promoting or rolling back a deployment now updates your webhook endpoints to match the deployment that's now current.

apps/webapp/app/v3/services/changeCurrentDeployment.server.ts

@@ -171,16 +171,16 @@ export class ChangeCurrentDeploymentService extends BaseService {
       );
     }
 
-    const [scheduleSyncError] = await tryCatch(this.#syncSchedulesForDeployment(deployment));
+    const [declarativeSyncError] = await tryCatch(this.#syncDeclarativeResources(deployment));
 
-    if (scheduleSyncError) {
-      logger.error("Error syncing declarative schedules on deployment change", {
-        error: scheduleSyncError,
+    if (declarativeSyncError) {
+      logger.error("Error syncing declarative resources on deployment change", {
+        error: declarativeSyncError,
       });
     }
   }
 
-  async #syncSchedulesForDeployment(deployment: WorkerDeployment) {
+  async #syncDeclarativeResources(deployment: WorkerDeployment) {
     const worker = await this._prisma.backgroundWorker.findFirst({
       where: { id: deployment.workerId! },
     });
@@ -221,16 +221,35 @@ export class ChangeCurrentDeploymentService extends BaseService {
       return;
     }
 
-    await syncDeclarativeSchedules(parsed.data.tasks, worker, environment, this._prisma);
-    await syncDeclarativeWebhooks(
-      {
-        endpoints: parsed.data.webhookEndpoints,
-        subscribers: parsed.data.webhookSubscribers,
-      },
-      worker,
-      environment,
-      this._prisma,
-      webhookPrisma
+    const [schedulesError] = await tryCatch(
+      syncDeclarativeSchedules(parsed.data.tasks, worker, environment, this._prisma)
+    );
+
+    if (schedulesError) {
+      logger.error("Error syncing declarative schedules on deployment change", {
+        deploymentId: deployment.id,
+        error: schedulesError,
+      });
+    }
+
+    const [webhooksError] = await tryCatch(
+      syncDeclarativeWebhooks(
+        {
+          endpoints: parsed.data.webhookEndpoints,
+          subscribers: parsed.data.webhookSubscribers,
+        },
+        worker,
+        environment,
+        this._prisma,
+        webhookPrisma
+      )
     );
+
+    if (webhooksError) {
+      logger.error("Error syncing declarative webhooks on deployment change", {
+        deploymentId: deployment.id,
+        error: webhooksError,
+      });
+    }
   }
 }

apps/webapp/app/v3/services/stripBackgroundWorkerMetadataForStorage.server.ts

@@ -7,7 +7,8 @@ import type { Prisma } from "@trigger.dev/database";
  * (BackgroundWorker.{contentHash,cliVersion,sdkVersion,runtime,runtimeVersion},
  * BackgroundWorkerTask, BackgroundWorkerFile, TaskQueue, Prompt). Today the
  * only post-write reader is changeCurrentDeployment.server.ts, which feeds
- * tasks[].schedule into syncDeclarativeSchedules. packageVersion, contentHash,
+ * tasks[].schedule into syncDeclarativeSchedules and webhookEndpoints +
+ * webhookSubscribers into syncDeclarativeWebhooks. packageVersion, contentHash,
  * and tasks[].filePath are kept solely to satisfy BackgroundWorkerMetadata's
  * required fields when the column is parsed back.
  */
@@ -24,5 +25,9 @@ export function stripBackgroundWorkerMetadataForStorage(
         filePath: t.filePath,
         schedule: t.schedule,
       })),
+    webhookEndpoints: metadata.webhookEndpoints as unknown as Prisma.InputJsonValue[] | undefined,
+    webhookSubscribers: metadata.webhookSubscribers as unknown as
+      | Prisma.InputJsonValue[]
+      | undefined,
   };
 }

apps/webapp/test/stripBackgroundWorkerMetadataForStorage.test.ts

@@ -0,0 +1,67 @@
+import { BackgroundWorkerMetadata } from "@trigger.dev/core/v3";
+import { describe, expect, it } from "vitest";
+import { stripBackgroundWorkerMetadataForStorage } from "~/v3/services/stripBackgroundWorkerMetadataForStorage.server";
+
+const baseMetadata: BackgroundWorkerMetadata = {
+  packageVersion: "4.8.1",
+  contentHash: "hash",
+  tasks: [
+    { id: "plain", filePath: "src/trigger/plain.ts", exportName: "plain" },
+    {
+      id: "nightly",
+      filePath: "src/trigger/nightly.ts",
+      exportName: "nightly",
+      schedule: { cron: "0 0 * * *", timezone: "UTC" },
+    },
+  ],
+};
+
+function roundTrip(metadata: BackgroundWorkerMetadata) {
+  const stored = JSON.parse(JSON.stringify(stripBackgroundWorkerMetadataForStorage(metadata)));
+  return BackgroundWorkerMetadata.parse(stored);
+}
+
+describe("stripBackgroundWorkerMetadataForStorage", () => {
+  it("keeps only scheduled tasks", () => {
+    const parsed = roundTrip(baseMetadata);
+
+    expect(parsed.tasks.map((t) => t.id)).toEqual(["nightly"]);
+    expect(parsed.tasks[0].schedule).toEqual({ cron: "0 0 * * *", timezone: "UTC" });
+  });
+
+  it("keeps webhook endpoints and subscribers so promotion can re-sync them", () => {
+    const webhookEndpoints: BackgroundWorkerMetadata["webhookEndpoints"] = [
+      {
+        id: "stripe-events",
+        filePath: "src/trigger/stripe.ts",
+        source: "stripe",
+        verifierArtifact: { kind: "bundle", bundleUrl: "https://example.test/v.js", hash: "h" },
+      },
+    ];
+    const webhookSubscribers: BackgroundWorkerMetadata["webhookSubscribers"] = [
+      {
+        endpointId: "stripe-events",
+        target: { type: "task", id: "plain", taskId: "plain" },
+      },
+    ];
+
+    const parsed = roundTrip({ ...baseMetadata, webhookEndpoints, webhookSubscribers });
+
+    expect(parsed.webhookEndpoints).toEqual(webhookEndpoints);
+    expect(parsed.webhookSubscribers).toEqual(webhookSubscribers);
+  });
+
+  it("keeps an empty endpoint list so promotion removes endpoints the worker no longer declares", () => {
+    const parsed = roundTrip({ ...baseMetadata, webhookEndpoints: [], webhookSubscribers: [] });
+
+    expect(parsed.webhookEndpoints).toEqual([]);
+    expect(parsed.webhookSubscribers).toEqual([]);
+  });
+
+  it("leaves webhook fields absent when the worker didn't declare them", () => {
+    const parsed = roundTrip(baseMetadata);
+
+    expect(parsed.webhookEndpoints).toBeUndefined();
+    expect(parsed.webhookSubscribers).toBeUndefined();
+  });
+});