Function getUserUsageLimit

apps/sim/lib/billing/core/usage.ts:508–589

(
  userId: string,
  preloadedSubscription?: HighestPrioritySubscription
)

 * write still resolves to the fallback instead of blocking execution.
 */
export async function getUserUsageLimit(
  userId: string,
  preloadedSubscription?: HighestPrioritySubscription
): Promise<number> {
  const subscription =
    preloadedSubscription !== undefined
      ? preloadedSubscription
      : await getHighestPrioritySubscription(userId)

  if (isOrgScopedSubscription(subscription, userId) && subscription) {
    const orgExists = await db
      .select({ id: organization.id })
      .from(organization)
      .where(eq(organization.id, subscription.referenceId))
      .limit(1)

    if (orgExists.length === 0) {
      throw new Error(`Organization not found: ${subscription.referenceId} for user: ${userId}`)
    }

    const orgLimit = await getOrgUsageLimit(
      subscription.referenceId,
      subscription.plan,
      subscription.seats
    )
    return orgLimit.limit
  }

  const userStatsQuery = await db
    .select({ currentUsageLimit: userStats.currentUsageLimit })
    .from(userStats)
    .where(eq(userStats.userId, userId))
    .limit(1)

  if (userStatsQuery.length === 0) {
    throw new Error(
      `No user stats record found for userId: ${userId}. User must be properly initialized before execution.`
    )
  }

  if (!userStatsQuery[0].currentUsageLimit) {
    const fallbackLimit =
      subscription && hasPaidSubscriptionStatus(subscription.status)
        ? getPerUserMinimumLimit(subscription)
        : getFreeTierLimit()

    try {
      const healed = await db
        .update(userStats)
        .set({
          currentUsageLimit: fallbackLimit.toString(),
          usageLimitUpdatedAt: new Date(),
        })
        .where(and(eq(userStats.userId, userId), isNull(userStats.currentUsageLimit)))
        .returning({ currentUsageLimit: userStats.currentUsageLimit })

      if (healed.length === 0) {
        const concurrent = await db