Function reconcileOrganizationSeats

apps/sim/lib/billing/organizations/seats.ts:41–151

({
  organizationId,
  reason,
}: ReconcileOrganizationSeatsParams)

 * always correct regardless of interleaving.
 */
export async function reconcileOrganizationSeats({
  organizationId,
  reason,
}: ReconcileOrganizationSeatsParams): Promise<ReconcileOrganizationSeatsResult> {
  if (!isBillingEnabled) {
    return { changed: false, reason: 'Billing is not enabled' }
  }

  type ReconcileOutcome =
    | { kind: 'skip'; reason: string }
    | { kind: 'noop'; seats: number }
    | {
        kind: 'changed'
        previousSeats: number
        seats: number
        outboxEventId: string
        sync: { id: string; plan: string; status: string | null }
      }

  const outcome = await db.transaction<ReconcileOutcome>(async (tx) => {
    const [orgSubscription] = await tx
      .select()
      .from(subscription)
      .where(
        and(
          eq(subscription.referenceId, organizationId),
          inArray(subscription.status, USABLE_SUBSCRIPTION_STATUSES)
        )
      )
      .for('update')
      .limit(1)

    if (!orgSubscription) {
      return { kind: 'skip', reason: 'No active subscription found' }
    }
    if (!isTeam(orgSubscription.plan)) {
      return { kind: 'skip', reason: 'Seat changes are only available for Team plans' }
    }
    if (!orgSubscription.stripeSubscriptionId) {
      return { kind: 'skip', reason: 'No Stripe subscription found for this organization' }
    }

    const [memberCountRow] = await tx
      .select({ value: count() })
      .from(member)
      .where(eq(member.organizationId, organizationId))

    const targetSeats = Math.max(1, memberCountRow?.value ?? 1)
    const currentSeats = orgSubscription.seats ?? 1

    if (targetSeats === currentSeats) {
      return { kind: 'noop', seats: currentSeats }
    }

    await tx
      .update(subscription)
      .set({ seats: targetSeats })
      .where(eq(subscription.id, orgSubscription.id))