refactor: remove four uncalled billing and large-value helpers

Each was checked by hand across every file type, including barrel re-exports
and string references, rather than taken from a static analyzer.

`isUserMemberOfOrganization` has no reference anywhere.

`reapplyPaidOrgJoinBillingForExistingMember` only ever ran from two
lock-ordering tests. The transaction-enlisted form it delegated to is what the
subscription webhooks call and what those tests actually assert on, so they now
drive it directly. The assertions are unchanged: the wrapper contributed a
transaction, an organization lock and a membership existence check, none of
which appear in the recorded operations.

`replaceLargeValueReferences` and `replaceLargeValueReferencesWithClient` are
both thin wrappers over `replaceLargeValueReferenceKeysWithClient`, which
execution logging, human-in-the-loop resume and the trace backfill all still
call. The single test covering a wrapper now composes the key collection itself
and targets that live helper.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: icecrasher321

apps/sim/lib/billing/organizations/lock-order.test.ts

@@ -34,7 +34,7 @@ vi.mock('@/lib/billing/storage/payer-transfer', () => ({
 }))
 
 import {
-  reapplyPaidOrgJoinBillingForExistingMember,
+  reapplyPaidOrgJoinBillingForExistingMemberTx,
   restoreUserProSubscription,
   transferOrganizationOwnership,
   withInvitationSafeOrganizationAccessMutation,
@@ -113,9 +113,8 @@ describe('paid-org join billing lock ordering', () => {
 
   it('locks the personal subscription before mutating userStats', async () => {
     const { tx, ops } = createRecordingTx()
-    dbChainMockFns.transaction.mockImplementation(async (cb: (t: unknown) => unknown) => cb(tx))
 
-    await reapplyPaidOrgJoinBillingForExistingMember('user-1', 'org-1')
+    await reapplyPaidOrgJoinBillingForExistingMemberTx(tx as DbOrTx, 'user-1', 'org-1')
 
     const firstUserStatsUpdate = ops.findIndex((o) => o.op === 'update' && o.table === userStats)
     const subscriptionLock = ops.findIndex((o) => o.op === 'lock' && o.table === subscriptionTable)
@@ -127,9 +126,8 @@ describe('paid-org join billing lock ordering', () => {
 
   it('still locks an already-paused personal Pro so a concurrent restore cannot pass it', async () => {
     const { tx, ops } = createRecordingTx({ ...GENERIC_ROW, cancelAtPeriodEnd: true })
-    dbChainMockFns.transaction.mockImplementation(async (cb: (t: unknown) => unknown) => cb(tx))
 
-    await reapplyPaidOrgJoinBillingForExistingMember('user-1', 'org-1')
+    await reapplyPaidOrgJoinBillingForExistingMemberTx(tx as DbOrTx, 'user-1', 'org-1')
 
     expect(ops.some((op) => op.op === 'lock' && op.table === subscriptionTable)).toBe(true)
   })

apps/sim/lib/billing/organizations/membership.ts

@@ -882,34 +882,6 @@ async function applyPaidOrgJoinBillingTx(
   return actions
 }
 
-/**
- * Re-applies paid-org join billing for a user who is already a member of
- * the organization. Used on re-upgrade after a dormant transition: members
- * kept their org membership but had their personal Pro subscriptions
- * restored (`cancelAtPeriodEnd=false`) during the cancel/downgrade. When
- * the org becomes paid again, those Pros must be re-paused so the user
- * isn't double-billed.
- *
- * No-op when the org has no active Team/Enterprise subscription.
- */
-export async function reapplyPaidOrgJoinBillingForExistingMember(
-  userId: string,
-  organizationId: string
-): Promise<PaidOrgJoinBillingActions> {
-  return db.transaction(async (tx) => {
-    await acquireOrganizationMutationLock(tx, organizationId)
-    const [existingMembership] = await tx
-      .select({ id: member.id })
-      .from(member)
-      .where(and(eq(member.userId, userId), eq(member.organizationId, organizationId)))
-      .limit(1)
-    if (!existingMembership) {
-      return { proUsageSnapshotted: false, proCancelledAtPeriodEnd: false }
-    }
-    return reapplyPaidOrgJoinBillingForExistingMemberTx(tx, userId, organizationId)
-  })
-}
-
 /**
  * Transaction-enlisted variant used by subscription webhooks. Keeping the
  * subscription upsert, effective-limit update, provisioning completion, and
@@ -2077,23 +2049,6 @@ export async function isSoleOwnerOfPaidOrganization(userId: string): Promise<{
   }
 }
 
-export async function isUserMemberOfOrganization(
-  userId: string,
-  organizationId: string
-): Promise<{ isMember: boolean; role?: string; memberId?: string }> {
-  const [memberRecord] = await db
-    .select({ id: member.id, role: member.role })
-    .from(member)
-    .where(and(eq(member.userId, userId), eq(member.organizationId, organizationId)))
-    .limit(1)
-
-  if (memberRecord) {
-    return { isMember: true, role: memberRecord.role, memberId: memberRecord.id }
-  }
-
-  return { isMember: false }
-}
-
 /**
  * Get user's current organization membership (if any).
  */

apps/sim/lib/execution/payloads/large-value-metadata.test.ts

@@ -2,16 +2,18 @@
  * @vitest-environment node
  */
 
+import { db } from '@sim/db'
 import { executionLargeValueDependencies, executionLargeValueReferences } from '@sim/db/schema'
 import { dbChainMockFns, resetDbChainMock } from '@sim/testing'
 import { eq, notInArray } from 'drizzle-orm'
 import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   addLargeValueReference,
+  collectLargeValueReferenceKeys,
   MAX_LARGE_VALUE_REFERENCES_PER_SCOPE,
   pruneLargeValueMetadata,
   registerLargeValueOwner,
-  replaceLargeValueReferences,
+  replaceLargeValueReferenceKeysWithClient,
 } from '@/lib/execution/payloads/large-value-metadata'
 
 function largeValueKey(id: string, executionId = 'source-execution'): string {
@@ -205,42 +207,44 @@ describe('large value metadata', () => {
     const otherWorkspaceKey =
       'execution/workspace-2/workflow-1/source-execution/large-value-lv_abcdefghijkl.json'
 
-    await replaceLargeValueReferences(
+    const value = {
+      a: {
+        __simLargeValueRef: true,
+        version: 1,
+        id: 'lv_abcdefghijkl',
+        kind: 'json',
+        size: 123,
+        key: matchingKey,
+      },
+      duplicate: {
+        __simLargeValueRef: true,
+        version: 1,
+        id: 'lv_abcdefghijkl',
+        kind: 'json',
+        size: 123,
+        key: matchingKey,
+      },
+      ignored: {
+        __simLargeValueRef: true,
+        version: 1,
+        id: 'lv_abcdefghijkl',
+        kind: 'json',
+        size: 123,
+        key: otherWorkspaceKey,
+      },
+    }
+
+    await replaceLargeValueReferenceKeysWithClient(
+      db,
       {
         workspaceId: 'workspace-1',
         workflowId: 'workflow-1',
         executionId: 'execution-2',
         source: 'execution_log',
       },
-      {
-        a: {
-          __simLargeValueRef: true,
-          version: 1,
-          id: 'lv_abcdefghijkl',
-          kind: 'json',
-          size: 123,
-          key: matchingKey,
-        },
-        duplicate: {
-          __simLargeValueRef: true,
-          version: 1,
-          id: 'lv_abcdefghijkl',
-          kind: 'json',
-          size: 123,
-          key: matchingKey,
-        },
-        ignored: {
-          __simLargeValueRef: true,
-          version: 1,
-          id: 'lv_abcdefghijkl',
-          kind: 'json',
-          size: 123,
-          key: otherWorkspaceKey,
-        },
-      }
+      collectLargeValueReferenceKeys(value, 'workspace-1')
     )
 
-    expect(dbChainMockFns.transaction).toHaveBeenCalledOnce()
     expect(dbChainMockFns.delete).toHaveBeenCalledOnce()
     expect(eq).toHaveBeenCalledWith(executionLargeValueReferences.source, 'execution_log')
     expect(dbChainMockFns.values).toHaveBeenCalledWith([

apps/sim/lib/execution/payloads/large-value-metadata.ts

@@ -227,22 +227,6 @@ export async function registerLargeValueOwner(
   return true
 }
 
-export async function replaceLargeValueReferencesWithClient(
-  client: LargeValueMetadataClient,
-  scope: LargeValueReferenceScope,
-  value: unknown
-): Promise<void> {
-  if (!scope.workspaceId || !scope.executionId) {
-    return
-  }
-
-  await replaceLargeValueReferenceKeysWithClient(
-    client,
-    scope,
-    collectLargeValueReferenceKeys(value, scope.workspaceId)
-  )
-}
-
 export async function replaceLargeValueReferenceKeysWithClient(
   client: LargeValueMetadataClient,
   scope: LargeValueReferenceScope,
@@ -359,18 +343,6 @@ export async function addLargeValueReference(
     .onConflictDoNothing()
 }
 
-export async function replaceLargeValueReferences(
-  scope: LargeValueReferenceScope,
-  value: unknown
-): Promise<void> {
-  const referenceKeys = scope.workspaceId
-    ? collectLargeValueReferenceKeys(value, scope.workspaceId)
-    : []
-  await dbFor('exec').transaction(async (tx) => {
-    await replaceLargeValueReferenceKeysWithClient(tx, scope, referenceKeys)
-  })
-}
-
 export async function markLargeValuesDeleted(
   keys: string[],
   dbClient: LargeValueMetadataClient = db