fix(e2e): preserve replacement org coverage

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: 2 people

apps/sim/e2e/fixtures/factories/billing.ts

@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { member, organization, subscription, user, userStats } from '@sim/db/schema'
 import { generateId } from '@sim/utils/id'
 import { and, eq, inArray } from 'drizzle-orm'
+import { hasOtherEntitledOrganizationSubscription } from '@/lib/billing/subscriptions/organization-coverage'
 import { detachOrganizationWorkspaces } from '@/lib/workspaces/organization-workspaces'
 
 const CREDITS_PER_DOLLAR = 200
@@ -67,6 +68,8 @@ export async function arrangeSubscription(input: SubscriptionArrangement): Promi
       metadata,
     })
 
+    if (status === 'canceled') return
+
     if (input.plan.startsWith('pro_')) {
       await tx
         .update(userStats)
@@ -142,6 +145,13 @@ export async function lapseOrganizationSubscription(input: {
         periodEnd: now,
       })
       .where(eq(subscription.id, input.subscriptionId))
+  })
+
+  if (await hasOtherEntitledOrganizationSubscription(input.organizationId, input.subscriptionId)) {
+    return
+  }
+
+  await db.transaction(async (tx) => {
     await tx
       .update(organization)
       .set({ orgUsageLimit: null, updatedAt: now })

apps/sim/e2e/foundation/scenario-validation.spec.ts

@@ -226,6 +226,37 @@ test.describe('pure scenario validation', () => {
     expectInvalid(scenario, /current entitled subscription "replacement-team-subscription"/)
   })
 
+  test('allows a lapsed history while a replacement subscription retains organization coverage', () => {
+    const scenario = validScenario()
+    const lapsed = scenario.subscriptions.find(({ key }) => key === 'lapsed-team-subscription')!
+    scenario.subscriptions = [
+      ...scenario.subscriptions,
+      { ...lapsed, key: 'replacement-team-subscription', status: 'active' },
+    ]
+    scenario.workspaces = scenario.workspaces.map((workspace) =>
+      workspace.key === 'lapsed-organization-workspace'
+        ? { ...workspace, subscriptionKey: 'replacement-team-subscription' }
+        : workspace
+    )
+    scenario.personas = scenario.personas.map((persona) =>
+      persona.key === 'freeOrganizationOwner'
+        ? {
+            ...persona,
+            workspaces: persona.workspaces.map((expectation) => ({
+              ...expectation,
+              hostContext: {
+                ...expectation.hostContext,
+                payerScope: 'organization',
+                plan: 'team_6000',
+              },
+            })),
+          }
+        : persona
+    )
+
+    expect(() => validateScenario(scenario)).not.toThrow()
+  })
+
   test('rejects permission groups without active Enterprise organization/workspace scope', () => {
     const scenario = validScenario()
     scenario.permissionGroups = scenario.permissionGroups.map((group) => ({

apps/sim/e2e/scripts/seed-world.ts

@@ -176,7 +176,7 @@ async function createOrganizationsAndSubscriptions(
     const created = await arrangeSubscription({
       referenceId,
       plan: subscription.plan,
-      status: subscription.status === 'lapsed' ? 'active' : subscription.status,
+      status: initialSubscriptionStatus(world.scenario, subscription),
       seats: subscription.seats,
       memberUserIds,
       enterprise: subscription.enterprise
@@ -729,6 +729,28 @@ function resolveBillingReference(world: E2EWorld, subscription: ScenarioSubscrip
       ).id
 }
 
+function initialSubscriptionStatus(
+  scenario: ResolvedScenario,
+  definition: ScenarioSubscription
+): 'active' | 'past_due' | 'canceled' {
+  if (definition.status !== 'lapsed') return definition.status
+  const hasEntitledReplacement = scenario.definition.subscriptions.some(
+    (candidate) =>
+      candidate.key !== definition.key &&
+      (candidate.status === 'active' || candidate.status === 'past_due') &&
+      sameBillingReference(candidate, definition)
+  )
+  return hasEntitledReplacement ? 'canceled' : 'active'
+}
+
+function sameBillingReference(left: ScenarioSubscription, right: ScenarioSubscription): boolean {
+  const identity = (subscription: ScenarioSubscription): string =>
+    subscription.billingReference.kind === 'user'
+      ? `user/${subscription.billingReference.userKey}`
+      : `organization/${subscription.billingReference.organizationKey}`
+  return identity(left) === identity(right)
+}
+
 function expectedUsageLimit(scenario: ResolvedScenario, userKey: string): string | null {
   const membership = scenario.definition.organizationMemberships.find(
     (candidate) => candidate.userKey === userKey

apps/sim/lib/billing/subscriptions/organization-coverage.ts

@@ -0,0 +1,29 @@
+import { db } from '@sim/db'
+import { subscription } from '@sim/db/schema'
+import { and, eq, inArray, ne } from 'drizzle-orm'
+import { isEnterprise, isTeam } from '@/lib/billing/plan-helpers'
+import { ENTITLED_SUBSCRIPTION_STATUSES } from '@/lib/billing/subscriptions/utils'
+
+/**
+ * Returns whether another entitled Team or Enterprise subscription still covers
+ * the organization after a specific subscription ends.
+ */
+export async function hasOtherEntitledOrganizationSubscription(
+  organizationId: string,
+  excludeSubscriptionId: string | null
+): Promise<boolean> {
+  const filters = [
+    eq(subscription.referenceId, organizationId),
+    inArray(subscription.status, ENTITLED_SUBSCRIPTION_STATUSES),
+  ]
+  if (excludeSubscriptionId) {
+    filters.push(ne(subscription.id, excludeSubscriptionId))
+  }
+
+  const rows = await db
+    .select({ plan: subscription.plan })
+    .from(subscription)
+    .where(and(...filters))
+
+  return rows.some(({ plan }) => isTeam(plan) || isEnterprise(plan))
+}

apps/sim/lib/billing/webhooks/subscription.ts

@@ -6,8 +6,9 @@ import { and, eq, inArray, ne } from 'drizzle-orm'
 import { calculateSubscriptionOverage, isSubscriptionOrgScoped } from '@/lib/billing/core/billing'
 import { syncUsageLimitsFromSubscription } from '@/lib/billing/core/usage'
 import { restoreUserProSubscription } from '@/lib/billing/organizations/membership'
-import { isEnterprise, isPaid, isPro, isTeam } from '@/lib/billing/plan-helpers'
+import { isEnterprise, isPaid, isPro } from '@/lib/billing/plan-helpers'
 import { requireStripeClient } from '@/lib/billing/stripe-client'
+import { hasOtherEntitledOrganizationSubscription } from '@/lib/billing/subscriptions/organization-coverage'
 import { ENTITLED_SUBSCRIPTION_STATUSES } from '@/lib/billing/subscriptions/utils'
 import { stripeWebhookIdempotency } from '@/lib/billing/webhooks/idempotency'
 import {
@@ -82,32 +83,6 @@ export interface OrganizationDormantTransitionResult {
   organizationRetainsTeamOrEnterprise: boolean
 }
 
-/**
- * Returns true when the organization is still covered by an **active
- * Team or Enterprise** subscription other than `excludeSubscriptionId`.
- * The org keeps its team-owned workspaces only while such a sub exists;
- * a Pro sub on the org does not count.
- */
-async function hasOtherActiveTeamOrEnterpriseSubscription(
-  organizationId: string,
-  excludeSubscriptionId: string | null
-): Promise<boolean> {
-  const filters = [
-    eq(subscription.referenceId, organizationId),
-    inArray(subscription.status, ENTITLED_SUBSCRIPTION_STATUSES),
-  ]
-  if (excludeSubscriptionId) {
-    filters.push(ne(subscription.id, excludeSubscriptionId))
-  }
-
-  const rows = await db
-    .select({ plan: subscription.plan })
-    .from(subscription)
-    .where(and(...filters))
-
-  return rows.some((row) => isTeam(row.plan) || isEnterprise(row.plan))
-}
-
 async function transitionOrganizationToDormantState(
   organizationId: string,
   triggeringSubscriptionId: string | null
@@ -117,7 +92,7 @@ async function transitionOrganizationToDormantState(
     .from(member)
     .where(eq(member.organizationId, organizationId))
 
-  if (await hasOtherActiveTeamOrEnterpriseSubscription(organizationId, triggeringSubscriptionId)) {
+  if (await hasOtherEntitledOrganizationSubscription(organizationId, triggeringSubscriptionId)) {
     logger.info(
       'Skipping dormant transition - another Team/Enterprise subscription still covers this organization',
       { organizationId, triggeringSubscriptionId }