fix(webapp): cancel the billing subscription when deleting an organization

Deleting an organization now cancels its billing subscription
immediately (one final invoice for consumed usage) before the
organization is removed, warns about this in the delete dialog, and
refuses deletion when the billing state cannot be verified.

Mono-RevId: 828f4b59737e6c36cd0b58387aa33f92600cca4e

Author: kathiekiwi

.server-changes/org-delete-cancels-subscription.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Deleting an organization now cancels its billing subscription.

apps/webapp/app/routes/_app.orgs.$organizationSlug.settings._index/route.tsx

@@ -44,6 +44,7 @@ import { Popover, PopoverContent, PopoverTrigger } from "~/components/primitives
 import { SpinnerWhite } from "~/components/primitives/Spinner";
 import { prisma } from "~/db.server";
 import { useFaviconUrl } from "~/hooks/useFaviconUrl";
+import { useFeatures } from "~/hooks/useFeatures";
 import { redirectWithErrorMessage, redirectWithSuccessMessage } from "~/models/message.server";
 import { resolveOrgIdFromSlug } from "~/models/organization.server";
 import { clearCurrentProject } from "~/services/dashboardPreferences.server";
@@ -336,6 +337,7 @@ export const action = dashboardAction(
 
 export default function Page() {
   const { organization, canManageOrganization } = useTypedLoaderData<typeof loader>();
+  const { isManagedCloud } = useFeatures();
   const lastSubmission = useActionData();
   const navigation = useNavigation();
 
@@ -453,6 +455,8 @@ export default function Page() {
                       This change is irreversible, so please be certain. Type in the Organization
                       slug <InlineCode variant="extra-small">{organization.slug}</InlineCode> and
                       then press Delete.
+                      {isManagedCloud &&
+                        " Your subscription will be cancelled immediately and any outstanding usage will be billed."}
                     </Hint>
                   </InputGroup>
                   <FormButtons

apps/webapp/app/services/deleteOrganization.server.ts

@@ -1,9 +1,8 @@
-import { DateFormatter } from "@internationalized/date";
+import { tryCatch } from "@trigger.dev/core/v3";
 import type { PrismaClient } from "@trigger.dev/database";
 import { prisma } from "~/db.server";
-import { featuresForRequest } from "~/features.server";
 import { DeleteProjectService } from "./deleteProject.server";
-import { getCurrentPlan } from "./platform.v3.server";
+import { cancelSubscription, getCurrentPlanOrThrow } from "./platform.v3.server";
 import { controlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
 import { commonWorker } from "~/v3/commonWorker.server";
 import { logger } from "./logger.server";
@@ -18,7 +17,6 @@ export class DeleteOrganizationService {
   public async call({
     organizationSlug,
     userId,
-    request,
   }: {
     organizationSlug: string;
     userId: string;
@@ -43,31 +41,7 @@ export class DeleteOrganizationService {
       throw new Error("Organization already deleted");
     }
 
-    //Check if they have an active subscription
-    const { isManagedCloud } = featuresForRequest(request);
-    const currentPlan = isManagedCloud ? await getCurrentPlan(organization.id) : undefined;
-
-    if (currentPlan && currentPlan.v3Subscription && currentPlan.v3Subscription.isPaying) {
-      //they've cancelled and that date hasn't passed yet
-      if (
-        currentPlan.v3Subscription.canceledAt &&
-        new Date(currentPlan.v3Subscription.canceledAt) > new Date()
-      ) {
-        //a dateformatter that produces results like "Jan 1 2024"
-        const dateFormatter = new DateFormatter("en-us", {
-          year: "numeric",
-          month: "short",
-          day: "numeric",
-        });
-        throw new Error(
-          `This Organization has a canceled subscription. You can delete it when the cancelation date (${dateFormatter.format(
-            new Date(currentPlan.v3Subscription.canceledAt)
-          )}) is in the past.`
-        );
-      }
-
-      throw new Error("You can't delete an Organization that has an active subscription");
-    }
+    await this.#cancelSubscription(organization.id);
 
     // loop through the projects and delete them
     const projectDeleteService = new DeleteProjectService();
@@ -105,4 +79,26 @@ export class DeleteOrganizationService {
       });
     }
   }
+
+  async #cancelSubscription(organizationId: string) {
+    let plan: Awaited<ReturnType<typeof getCurrentPlanOrThrow>>;
+    try {
+      plan = await getCurrentPlanOrThrow(organizationId);
+    } catch (error) {
+      logger.error("Failed to load plan before deleting organization", { organizationId, error });
+      throw new Error("Couldn't verify billing state, try again");
+    }
+
+    if (!plan) return;
+
+    const [error, result] = await tryCatch(cancelSubscription(organizationId));
+    if (error || !result?.success) {
+      logger.error("Failed to cancel subscription before deleting organization", {
+        organizationId,
+        error,
+        result,
+      });
+      throw new Error("Couldn't cancel the subscription, try again");
+    }
+  }
 }

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

@@ -395,6 +395,18 @@ export async function getCurrentPlan(orgId: string) {
   }
 }
 
+export async function getCurrentPlanOrThrow(orgId: string) {
+  if (!client) return undefined;
+
+  const result = await client.currentPlan(orgId);
+  if (!result.success) {
+    recordPlatformFailure("getCurrentPlanOrThrow", "no_success");
+    throw new Error(result.error);
+  }
+
+  return result;
+}
+
 export type SelfServePurchaseBlockReason = "plan_unavailable" | "managed_billing";
 
 /**
@@ -620,6 +632,24 @@ export async function activateFreePlan(
   return { success: true };
 }
 
+export async function cancelSubscription(orgId: string) {
+  if (!client) return undefined;
+
+  const [error, result] = await tryCatch(client.cancelSubscription(orgId));
+  if (error) {
+    recordPlatformFailure("cancelSubscription", "caught");
+    throw error;
+  }
+
+  if (result.success) {
+    invalidatePlanDerivedCaches(orgId);
+  } else {
+    recordPlatformFailure("cancelSubscription", "no_success");
+  }
+
+  return result;
+}
+
 export async function setPlan(
   organization: { id: string; slug: string },
   request: Request,

apps/webapp/package.json

@@ -130,7 +130,7 @@
     "@trigger.dev/core": "workspace:*",
     "@trigger.dev/database": "workspace:*",
     "@trigger.dev/otlp-importer": "workspace:*",
-    "@trigger.dev/platform": "1.3.1",
+    "@trigger.dev/platform": "1.4.0",
     "@trigger.dev/plugins": "workspace:*",
     "@trigger.dev/rbac": "workspace:*",
     "@trigger.dev/redis-worker": "workspace:*",

apps/webapp/test/deleteOrganization.test.ts

@@ -0,0 +1,145 @@
+import { postgresTest } from "@internal/testcontainers";
+import type { PrismaClient } from "@trigger.dev/database";
+import { beforeEach, describe, expect, vi } from "vitest";
+import { DeleteOrganizationService } from "~/services/deleteOrganization.server";
+import { createTestUser, uniqueId } from "./fixtures/environmentVariablesFixtures";
+
+const { getCurrentPlanOrThrowMock, cancelSubscriptionMock } = vi.hoisted(() => ({
+  getCurrentPlanOrThrowMock: vi.fn(async (_orgId: string): Promise<unknown> => undefined),
+  cancelSubscriptionMock: vi.fn(async (_orgId: string): Promise<unknown> => undefined),
+}));
+
+vi.mock("~/services/platform.v3.server", async (importOriginal) => {
+  const mod = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...mod,
+    getCurrentPlanOrThrow: getCurrentPlanOrThrowMock,
+    cancelSubscription: cancelSubscriptionMock,
+  };
+});
+
+vi.mock("~/v3/commonWorker.server", () => ({
+  commonWorker: { enqueue: async () => undefined },
+}));
+
+vi.setConfig({ testTimeout: 60_000 });
+
+async function createOrg(prisma: PrismaClient) {
+  const user = await createTestUser(prisma);
+  const organization = await prisma.organization.create({
+    data: {
+      title: "Test Org",
+      slug: uniqueId("org"),
+      members: { create: { userId: user.id, role: "ADMIN" } },
+    },
+  });
+  return { user, organization };
+}
+
+async function deleteOrg(prisma: PrismaClient, slug: string, userId: string) {
+  return new DeleteOrganizationService(prisma).call({
+    organizationSlug: slug,
+    userId,
+    request: new Request("https://cloud.trigger.dev/"),
+  });
+}
+
+function plan(v3Subscription: Record<string, unknown>) {
+  return { success: true, v3Subscription: { freeTierStatus: "approved", ...v3Subscription } };
+}
+
+describe("DeleteOrganizationService billing", () => {
+  beforeEach(() => {
+    getCurrentPlanOrThrowMock.mockReset();
+    cancelSubscriptionMock.mockReset();
+  });
+
+  postgresTest("aborts when the plan lookup fails", async ({ prisma }) => {
+    const { user, organization } = await createOrg(prisma);
+    getCurrentPlanOrThrowMock.mockRejectedValue(new Error("billing down"));
+
+    await expect(deleteOrg(prisma, organization.slug, user.id)).rejects.toThrow(
+      "Couldn't verify billing state, try again"
+    );
+
+    expect(cancelSubscriptionMock).not.toHaveBeenCalled();
+    const org = await prisma.organization.findUniqueOrThrow({ where: { id: organization.id } });
+    expect(org.deletedAt).toBeNull();
+  });
+
+  postgresTest("cancels a paid subscription then deletes", async ({ prisma }) => {
+    const { user, organization } = await createOrg(prisma);
+    getCurrentPlanOrThrowMock.mockResolvedValue(plan({ isPaying: true }));
+    cancelSubscriptionMock.mockResolvedValue({
+      success: true,
+      outcome: "canceled",
+      cancelAt: null,
+    });
+
+    await deleteOrg(prisma, organization.slug, user.id);
+
+    expect(cancelSubscriptionMock).toHaveBeenCalledTimes(1);
+    expect(cancelSubscriptionMock).toHaveBeenCalledWith(organization.id);
+    const org = await prisma.organization.findUniqueOrThrow({ where: { id: organization.id } });
+    expect(org.deletedAt).toBeInstanceOf(Date);
+  });
+
+  postgresTest("aborts when the cancel call returns an error", async ({ prisma }) => {
+    const { user, organization } = await createOrg(prisma);
+    getCurrentPlanOrThrowMock.mockResolvedValue(plan({ isPaying: true }));
+    cancelSubscriptionMock.mockResolvedValue({ success: false, error: "stripe_error" });
+
+    await expect(deleteOrg(prisma, organization.slug, user.id)).rejects.toThrow(
+      "Couldn't cancel the subscription, try again"
+    );
+
+    const org = await prisma.organization.findUniqueOrThrow({ where: { id: organization.id } });
+    expect(org.deletedAt).toBeNull();
+  });
+
+  postgresTest("aborts when the cancel call throws", async ({ prisma }) => {
+    const { user, organization } = await createOrg(prisma);
+    getCurrentPlanOrThrowMock.mockResolvedValue(plan({ isPaying: true }));
+    cancelSubscriptionMock.mockRejectedValue(new Error("network down"));
+
+    await expect(deleteOrg(prisma, organization.slug, user.id)).rejects.toThrow(
+      "Couldn't cancel the subscription, try again"
+    );
+
+    const org = await prisma.organization.findUniqueOrThrow({ where: { id: organization.id } });
+    expect(org.deletedAt).toBeNull();
+  });
+
+  postgresTest("deletes when the subscription is already canceled", async ({ prisma }) => {
+    const { user, organization } = await createOrg(prisma);
+    getCurrentPlanOrThrowMock.mockResolvedValue(plan({ isPaying: true }));
+    cancelSubscriptionMock.mockResolvedValue({
+      success: true,
+      outcome: "already_canceled",
+      cancelAt: null,
+    });
+
+    await deleteOrg(prisma, organization.slug, user.id);
+
+    expect(cancelSubscriptionMock).toHaveBeenCalledTimes(1);
+    const org = await prisma.organization.findUniqueOrThrow({ where: { id: organization.id } });
+    expect(org.deletedAt).toBeInstanceOf(Date);
+  });
+
+  postgresTest("asks billing to cancel even when not paying", async ({ prisma }) => {
+    const { user, organization } = await createOrg(prisma);
+    getCurrentPlanOrThrowMock.mockResolvedValue(plan({ isPaying: false }));
+    cancelSubscriptionMock.mockResolvedValue({
+      success: true,
+      outcome: "no_subscription",
+      cancelAt: null,
+    });
+
+    await deleteOrg(prisma, organization.slug, user.id);
+
+    expect(cancelSubscriptionMock).toHaveBeenCalledTimes(1);
+    expect(cancelSubscriptionMock).toHaveBeenCalledWith(organization.id);
+    const org = await prisma.organization.findUniqueOrThrow({ where: { id: organization.id } });
+    expect(org.deletedAt).toBeInstanceOf(Date);
+  });
+});