A desktop coding agent with free access to frontier models.
TypeScript
import Stripe from "stripe"
import { and, eq, isNotNull, isNull, sql } from "@omnirush-ee/den-db/drizzle"
import {
MemberTable,
OrgSubscriptionStatus,
OrgSubscriptionType,
OrgSubscriptionTable,
OrganizationTable,
} from "@omnirush-ee/den-db/schema"
import { createDenTypeId } from "@omnirush-ee/utils/typeid"
import { ManagedModelsPolicyError } from "@omnirush/types/den/managed-models-policy"
import { db } from "./db.js"
import { env } from "./env.js"
import type { DenOrgMode } from "./env.js"
import { setInferenceEnabled } from "./inference.js"
import { assertOrganizationManagedModelsAllowed } from "./organization-metadata.js"
import { appLogger } from "./observability/logger.js"
import { isOmniRushWebAvailable } from "./omnirush-web-availability.js"
import { hasOmniRushWebComplimentaryAccess, resolveOmniRushWebAccess } from "./omnirush-web-access.js"
type OrgId = typeof OrganizationTable.$inferSelect.id
type MemberId = typeof MemberTable.$inferSelect.id
type OrgSubscriptionStatusValue = (typeof OrgSubscriptionStatus)[number]
type OrgSubscriptionTypeValue = (typeof OrgSubscriptionType)[number]
const STRIPE_API_VERSION = "2026-04-22.dahlia"
const INFERENCE_SUBSCRIPTION_TYPE = "inference" as const
const SEAT_SUBSCRIPTION_TYPE = "seat" as const
const WEB_SUBSCRIPTION_TYPE = "web" as const
export const FREE_ORG_SEAT_COUNT = 5
export const OMNIRUSH_WEB_UNIT_AMOUNT = 5000
export const OMNIRUSH_WEB_CURRENCY = "usd" as const
export const OMNIRUSH_WEB_INTERVAL = "month" as const
export const OMNIRUSH_WEB_QUANTITY_DEFINITION = "joined_non_removed_members" as const
const ACTIVE_STATUSES = new Set<OrgSubscriptionStatusValue>(["active", "trialing"])
const ONGOING_STATUSES = new Set<OrgSubscriptionStatusValue>(["active", "trialing", "incomplete", "past_due", "unpaid", "paused"])
const EXPIRED_STATUSES = new Set<OrgSubscriptionStatusValue>(["past_due", "canceled", "unpaid", "incomplete_expired", "expired"])
const logger = appLogger.child({ component: "stripe_billing" })
export type StripeCheckoutSubscriptionType = typeof INFERENCE_SUBSCRIPTION_TYPE | typeof SEAT_SUBSCRIPTION_TYPE | typeof WEB_SUBSCRIPTION_TYPE
let stripeClient: Stripe | null = null
function stripe() {
if (!env.stripe.secretKey) {
throw new Error("stripe_secret_key_missing")
}
if (!stripeClient) {
stripeClient = new Stripe(env.stripe.secretKey, {
apiVersion: STRIPE_API_VERSION as any,
})
}
return stripeClient
}
function requireInferencePriceId() {
if (!env.stripe.inferencePriceId) {
throw new Error("stripe_inference_price_id_missing")
}
return env.stripe.inferencePriceId
}
function requireSeatPriceId() {
if (!env.stripe.seatPriceId) {
throw new Error("stripe_seat_price_id_missing")
}
return env.stripe.seatPriceId
}
function requireOmniRushWebPriceId() {
const priceId = env.stripe.omnirushWebPriceId
if (!isOmniRushWebAvailable() || !priceId) {
throw new Error("stripe_omnirush_web_not_available")
}
return priceId
}
function requirePriceIdForSubscriptionType(subscriptionType: StripeCheckoutSubscriptionType) {
switch (subscriptionType) {
case INFERENCE_SUBSCRIPTION_TYPE:
return requireInferencePriceId()
case SEAT_SUBSCRIPTION_TYPE:
return requireSeatPriceId()
case WEB_SUBSCRIPTION_TYPE:
return requireOmniRushWebPriceId()
}
}
function fromUnixSeconds(value: number | null | undefined) {
return typeof value === "number" ? new Date(value * 1000) : null
}
function subscriptionStatus(value: string | null | undefined): OrgSubscriptionStatusValue {
switch (value) {
case "incomplete":
case "incomplete_expired":
case "trialing":
case "active":
case "past_due":
case "canceled":
case "unpaid":
case "paused":
return value
default:
return "expired"
}
}
function customerIdFromSubscription(subscription: Stripe.Subscription) {
return typeof subscription.customer === "string" ? subscription.customer : subscription.customer.id
}
function firstSubscriptionItem(subscription: Stripe.Subscription) {
return subscription.items.data[0] ?? null
}
function parseSubscriptionType(value: string | null | undefined): OrgSubscriptionTypeValue | null {
switch (value) {
case INFERENCE_SUBSCRIPTION_TYPE:
return INFERENCE_SUBSCRIPTION_TYPE
case SEAT_SUBSCRIPTION_TYPE:
case "seats":
return SEAT_SUBSCRIPTION_TYPE
case WEB_SUBSCRIPTION_TYPE:
case "omnirush_web":
return WEB_SUBSCRIPTION_TYPE
default:
return null
}
}
function getBillingMetadata(metadata: Stripe.Metadata | null | undefined) {
const orgId = metadata?.org_id?.trim() ?? ""
const orgMemberId = metadata?.created_by_org_member_id?.trim() ?? ""
return {
organizationId: orgId || null,
orgMemberId: orgMemberId || null,
subscriptionType: parseSubscriptionType(metadata?.subscription_type?.trim()),
}
}
function getSubscriptionMetadata(subscription: Stripe.Subscription) {
return getBillingMetadata(subscription.metadata)
}
function subscriptionTypeFromStripeSubscription(subscription: Stripe.Subscription, item: Stripe.SubscriptionItem | null) {
const metadataType = getSubscriptionMetadata(subscription).subscriptionType
if (metadataType) {
return metadataType
}
const priceId = typeof item?.price?.id === "string" ? item.price.id : null
if (env.stripe.seatPriceId && priceId === env.stripe.seatPriceId) {
return SEAT_SUBSCRIPTION_TYPE
}
if (env.stripe.omnirushWebPriceId && priceId === env.stripe.omnirushWebPriceId) {
return WEB_SUBSCRIPTION_TYPE
}
return INFERENCE_SUBSCRIPTION_TYPE
}
async function activeMemberCount(organizationId: OrgId) {
const [row] = await db
.select({ count: sql<number>`count(*)` })
.from(MemberTable)
.where(and(eq(MemberTable.organizationId, organizationId), isNull(MemberTable.removedAt)))
return Math.max(0, Number(row?.count ?? 0))
}
async function joinedMemberCount(organizationId: OrgId) {
const [row] = await db
.select({ count: sql<number>`count(*)` })
.from(MemberTable)
.where(and(
eq(MemberTable.organizationId, organizationId),
isNotNull(MemberTable.joinedAt),
isNull(MemberTable.removedAt),
))
return normalizeSeatCount(Number(row?.count ?? 0))
}
async function organizationOmniRushWebComplimentaryAccess(organizationId: OrgId) {
const rows = await db
.select({ metadata: OrganizationTable.metadata })
.from(OrganizationTable)
.where(eq(OrganizationTable.id, organizationId))
.limit(1)
return hasOmniRushWebComplimentaryAccess(rows[0]?.metadata)
}
export function isOmniRushWebBillableMember(input: { joinedAt: Date | null; removedAt: Date | null }) {
return input.joinedAt !== null && input.removedAt === null
}
export function calculateOmniRushWebBilling(input: { joinedMemberCount: number }) {
const quantity = normalizeSeatCount(input.joinedMemberCount)
return {
quantity,
unitAmount: OMNIRUSH_WEB_UNIT_AMOUNT,
expectedMonthlyTotal: quantity * OMNIRUSH_WEB_UNIT_AMOUNT,
}
}
export function isEligibleOmniRushWebSubscriptionStatus(status: string | null | undefined) {
return status === "active" || status === "trialing"
}
export function isOngoingOmniRushWebSubscriptionStatus(status: string | null | undefined) {
return typeof status === "string" && ONGOING_STATUSES.has(subscriptionStatus(status)) && status !== "expired"
}
export function omniRushWebPaymentStatus(status: string | null | undefined, paymentFailed = false) {
if (paymentFailed) {
return "payment_failed" as const
}
switch (status) {
case "active":
return "paid" as const
case "trialing":
return "trialing" as const
case "past_due":
return "past_due" as const
case "unpaid":
return "unpaid" as const
case "incomplete":
return "incomplete" as const
case "paused":
return "paused" as const
default:
return "inactive" as const
}
}
function normalizeSeatCount(value: number) {
return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0
}
function normalizeAdditionalFreeSeats(value: unknown) {
return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : 0
}
export function additionalFreeSeatCountFromMetadata(metadata: Record<string, unknown> | null | undefined) {
return normalizeAdditionalFreeSeats(metadata?.seatsFreeAdditional)
}
// Seat billing only gates member additions on hosted multi-org deployments
// where Stripe seat billing is configured. Single-org (self-hosted /
// enterprise) deployments never restrict member count, and without Stripe
// configured the 402 would be a dead end the operator cannot resolve.
export function isSeatBillingGateEnabled(input: {
orgMode: DenOrgMode
stripeSecretKey: string | undefined
stripeSeatPriceId: string | undefined
}) {
return input.orgMode === "multi_org" && Boolean(input.stripeSecretKey && input.stripeSeatPriceId)
}
export function calculateOrganizationSeatBillingCounts(input: {
memberCount: number
metadata?: Record<string, unknown> | null
additionalFreeSeats?: number
}) {
const total = normalizeSeatCount(input.memberCount)
const additionalFree = input.additionalFreeSeats === undefined
? additionalFreeSeatCountFromMetadata(input.metadata)
: normalizeAdditionalFreeSeats(input.additionalFreeSeats)
const free = FREE_ORG_SEAT_COUNT + additionalFree
const chargeable = Math.max(0, total - free)
return {
total,
chargeable,
free,
includedFree: FREE_ORG_SEAT_COUNT,
additionalFree,
}
}
export async function getOrganizationSeatBillingCounts(input: { organizationId: OrgId; memberCount?: number }) {
const memberCountPromise = typeof input.memberCount === "number"
? Promise.resolve(input.memberCount)
: activeMemberCount(input.organizationId)
const metadataPromise = db
.select({ metadata: OrganizationTable.metadata })
.from(OrganizationTable)
.where(eq(OrganizationTable.id, input.organizationId))
.limit(1)
const [memberCount, rows] = await Promise.all([memberCountPromise, metadataPromise])
return calculateOrganizationSeatBillingCounts({ memberCount, metadata: rows[0]?.metadata })
}
async function findOrgSubscriptionByType(organizationId: OrgId, subscriptionType: OrgSubscriptionTypeValue) {
return db
.select()
.from(OrgSubscriptionTable)
.where(and(
eq(OrgSubscriptionTable.organization_id, organizationId),
eq(OrgSubscriptionTable.type, subscriptionType),
))
.limit(1)
.then((rows) => rows[0] ?? null)
}
async function findInferenceSubscriptionByOrg(organizationId: OrgId) {
return findOrgSubscriptionByType(organizationId, INFERENCE_SUBSCRIPTION_TYPE)
}
async function findSeatSubscriptionByOrg(organizationId: OrgId) {
return findOrgSubscriptionByType(organizationId, SEAT_SUBSCRIPTION_TYPE)
}
async function findWebSubscriptionByOrg(organizationId: OrgId) {
return findOrgSubscriptionByType(organizationId, WEB_SUBSCRIPTION_TYPE)
}
async function findOrgSubscriptionByStripeId(stripeSubscriptionId: string) {
return db
.select()
.from(OrgSubscriptionTable)
.where(eq(OrgSubscriptionTable.stripe_subscription_id, stripeSubscriptionId))
.limit(1)
.then((rows) => rows[0] ?? null)
}
export async function cancelOrganizationSubscriptions(input: { organizationId: OrgId }) {
if (!env.stripe.secretKey) {
return
}
const rows = await db
.select({
id: OrgSubscriptionTable.id,
stripeSubscriptionId: OrgSubscriptionTable.stripe_subscription_id,
})
.from(OrgSubscriptionTable)
.where(eq(OrgSubscriptionTable.organization_id, input.organizationId))
for (const row of rows) {
if (!row.stripeSubscriptionId) {
continue
}
try {
await stripe().subscriptions.cancel(row.stripeSubscriptionId)
} catch (error) {
logger.warn("failed to cancel Stripe subscription during organization deletion", {
organization_id: input.organizationId,
org_subscription_id: row.id,
stripe_subscription_id: row.stripeSubscriptionId,
error,
})
}
}
}
async function findInferenceSubscriptionByStripeId(stripeSubscriptionId: string) {
const row = await findOrgSubscriptionByStripeId(stripeSubscriptionId)
return row?.type === INFERENCE_SUBSCRIPTION_TYPE ? row : null
}
async function findStripeCustomerIdByOrg(organizationId: string) {
return db
.select({ stripeCustomerId: OrgSubscriptionTable.stripe_customer_id })
.from(OrgSubscriptionTable)
.where(eq(OrgSubscriptionTable.organization_id, organizationId as OrgId))
.limit(1)
.then((rows) => rows[0]?.stripeCustomerId ?? null)
}
function stripeSearchLiteral(value: string) {
return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")
}
async function findStripeCustomerIdByOrgMetadata(organizationId: string) {
try {
const customers = await stripe().customers.search({
query: `metadata['org_id']:'${stripeSearchLiteral(organizationId)}'`,
limit: 1,
})
return customers.data[0]?.id ?? null
} catch (error) {
logger.warn("failed to search Stripe customers by org metadata", { organization_id: organizationId, error })
return null
}
}
async function stripeCustomerBelongsToOrganization(customerId: string, organizationId: string) {
try {
const customer = await stripe().customers.retrieve(customerId)
return !customer.deleted && customer.metadata.org_id?.trim() === organizationId
} catch (error) {
logger.warn("failed to verify Stripe customer organization metadata", {
organization_id: organizationId,
stripe_customer_id: customerId,
error,
})
return false
}
}
export async function organizationHasActiveInferenceSubscription(organizationId: OrgId) {
const row = await findInferenceSubscriptionByOrg(organizationId)
return Boolean(row && ACTIVE_STATUSES.has(row.status))
}
export async function organizationHasActiveSeatSubscription(organizationId: OrgId) {
const row = await findSeatSubscriptionByOrg(organizationId)
return Boolean(row && ACTIVE_STATUSES.has(row.status))
}
function isEligibleOmniRushWebSubscriptionRow(row: Awaited<ReturnType<typeof findWebSubscriptionByOrg>>) {
return Boolean(
row
&& isEligibleOmniRushWebSubscriptionStatus(row.status)
&& env.stripe.omnirushWebPriceId
&& row.stripe_price_id === env.stripe.omnirushWebPriceId
&& row.payment_failed !== true,
)
}
function isOngoingConfiguredOmniRushWebSubscriptionRow(row: Awaited<ReturnType<typeof findWebSubscriptionByOrg>>) {
return Boolean(
row
&& isOngoingOmniRushWebSubscriptionStatus(row.status)
&& env.stripe.omnirushWebPriceId
&& row.stripe_price_id === env.stripe.omnirushWebPriceId,
)
}
export async function organizationHasEligibleOmniRushWebSubscription(organizationId: OrgId) {
return isEligibleOmniRushWebSubscriptionRow(await findWebSubscriptionByOrg(organizationId))
}
export async function organizationHasOngoingOmniRushWebSubscription(organizationId: OrgId) {
let row = await findWebSubscriptionByOrg(organizationId)
if (row?.stripe_subscription_id) {
row = await refreshOrgSubscriptionFromStripe(row.stripe_subscription_id)
}
return Boolean(row && isOngoingOmniRushWebSubscriptionStatus(row.status))
}
export async function getOrganizationSeatAddEligibility(organizationId: OrgId) {
const seatCounts = await getOrganizationSeatBillingCounts({ organizationId })
const gateEnabled = isSeatBillingGateEnabled({
orgMode: env.orgMode,
stripeSecretKey: env.stripe.secretKey,
stripeSeatPriceId: env.stripe.seatPriceId,
})
if (!gateEnabled || seatCounts.total < seatCounts.free) {
return {
allowed: true,
currentCount: seatCounts.total,
freeSeatCount: seatCounts.free,
billableSeatCount: seatCounts.chargeable,
hasActiveSeatSubscription: false,
}
}
const hasActiveSeatSubscription = await organizationHasActiveSeatSubscription(organizationId)
return {
allowed: hasActiveSeatSubscription,
currentCount: seatCounts.total,
freeSeatCount: seatCounts.free,
billableSeatCount: seatCounts.chargeable,
hasActiveSeatSubscription,
}
}
export async function upsertOrgSubscriptionFromStripe(subscription: Stripe.Subscription, eventId?: string | null) {
const item = firstSubscriptionItem(subscription)
const metadata = getSubscriptionMetadata(subscription)
if (!metadata.organizationId) {
return null
}
const status = subscriptionStatus(subscription.status)
const subscriptionType = subscriptionTypeFromStripeSubscription(subscription, item)
const existingWebSubscription = subscriptionType === WEB_SUBSCRIPTION_TYPE
? await findWebSubscriptionByOrg(metadata.organizationId as OrgId)
: null
const sameWebSubscription = existingWebSubscription?.stripe_subscription_id === subscription.id
// An active Stripe subscription is not proof that its latest payment was
// collected (notably for asynchronous payment methods). New or replacement
// active Web subscriptions therefore fail closed until Checkout or an
// invoice event positively confirms payment. Trialing subscriptions remain
// eligible because Stripe does not require an initial payment for a trial.
const paymentFailed = subscriptionType === WEB_SUBSCRIPTION_TYPE
? sameWebSubscription
? existingWebSubscription?.payment_failed ?? status === "active"
: status === "active"
: false
const quantity = item?.quantity ?? 0
const priceId = typeof item?.price?.id === "string" ? item.price.id : null
const now = new Date()
const values = {
id: createDenTypeId("orgSubscription"),
organization_id: metadata.organizationId as OrgId,
created_by_org_membership_id: metadata.orgMemberId as MemberId | null,
type: subscriptionType,
status,
stripe_customer_id: customerIdFromSubscription(subscription),
stripe_subscription_id: subscription.id,
stripe_price_id: priceId,
stripe_subscription_item_id: item?.id ?? null,
quantity,
current_period_start: fromUnixSeconds((subscription as Stripe.Subscription & { current_period_start?: number }).current_period_start),
current_period_end: fromUnixSeconds((subscription as Stripe.Subscription & { current_period_end?: number }).current_period_end),
cancel_at_period_end: subscription.cancel_at_period_end,
payment_failed: paymentFailed,
canceled_at: fromUnixSeconds(subscription.canceled_at),
ended_at: fromUnixSeconds(subscription.ended_at),
last_event_id: eventId ?? null,
created_at: now,
updated_at: now,
}
await db.insert(OrgSubscriptionTable).values(values).onDuplicateKeyUpdate({
set: {
created_by_org_membership_id: values.created_by_org_membership_id,
status: values.status,
stripe_customer_id: values.stripe_customer_id,
stripe_subscription_id: values.stripe_subscription_id,
stripe_price_id: values.stripe_price_id,
stripe_subscription_item_id: values.stripe_subscription_item_id,
quantity: values.quantity,
current_period_start: values.current_period_start,
current_period_end: values.current_period_end,
cancel_at_period_end: values.cancel_at_period_end,
...(subscriptionType !== WEB_SUBSCRIPTION_TYPE || !sameWebSubscription
? { payment_failed: values.payment_failed }
: {}),
canceled_at: values.canceled_at,
ended_at: values.ended_at,
last_event_id: values.last_event_id,
updated_at: now,
},
})
if (subscriptionType === INFERENCE_SUBSCRIPTION_TYPE && EXPIRED_STATUSES.has(status)) {
await setInferenceEnabled({ organizationId: metadata.organizationId as OrgId, enabled: false })
}
return findOrgSubscriptionByStripeId(subscription.id)
}
export async function upsertInferenceSubscriptionFromStripe(subscription: Stripe.Subscription, eventId?: string | null) {
return upsertOrgSubscriptionFromStripe(subscription, eventId)
}
export async function refreshOrgSubscriptionFromStripe(stripeSubscriptionId: string) {
if (!env.stripe.secretKey) {
return findOrgSubscriptionByStripeId(stripeSubscriptionId)
}
const existing = await findOrgSubscriptionByStripeId(stripeSubscriptionId)
const subscription = await stripe().subscriptions.retrieve(stripeSubscriptionId)
const item = firstSubscriptionItem(subscription)
const status = subscriptionStatus(subscription.status)
const quantity = item?.quantity ?? 0
const priceId = typeof item?.price?.id === "string" ? item.price.id : null
const paymentFailed = existing?.type === WEB_SUBSCRIPTION_TYPE
? existing.payment_failed
: false
await db
.update(OrgSubscriptionTable)
.set({
status,
stripe_customer_id: customerIdFromSubscription(subscription),
stripe_price_id: priceId,
stripe_subscription_item_id: item?.id ?? null,
quantity,
current_period_start: fromUnixSeconds((subscription as Stripe.Subscription & { current_period_start?: number }).current_period_start),
current_period_end: fromUnixSeconds((subscription as Stripe.Subscription & { current_period_end?: number }).current_period_end),
cancel_at_period_end: subscription.cancel_at_period_end,
...(existing?.type !== WEB_SUBSCRIPTION_TYPE ? { payment_failed: paymentFailed } : {}),
canceled_at: fromUnixSeconds(subscription.canceled_at),
ended_at: fromUnixSeconds(subscription.ended_at),
updated_at: new Date(),
})
.where(eq(OrgSubscriptionTable.stripe_subscription_id, subscription.id))
return findOrgSubscriptionByStripeId(subscription.id)
}
export async function findOrCreateStripeCustomer(input: {
email: string
name: string
organizationId?: string | null
metadata?: Stripe.MetadataParam
existingCustomerId?: string | null
}) {
const existingCustomerId = input.existingCustomerId?.trim()
if (existingCustomerId) {
const organizationId = input.organizationId?.trim()
if (!organizationId || await stripeCustomerBelongsToOrganization(existingCustomerId, organizationId)) {
return existingCustomerId
}
}
const organizationId = input.organizationId?.trim()
if (organizationId) {
const dbCustomerId = await findStripeCustomerIdByOrg(organizationId)
if (dbCustomerId && await stripeCustomerBelongsToOrganization(dbCustomerId, organizationId)) {
return dbCustomerId
}
const stripeCustomerId = await findStripeCustomerIdByOrgMetadata(organizationId)
if (stripeCustomerId && await stripeCustomerBelongsToOrganization(stripeCustomerId, organizationId)) {
return stripeCustomerId
}
const email = input.email.trim()
if (!email) {
throw new Error("stripe_customer_email_missing")
}
const customer = await stripe().customers.create({
email,
name: input.name,
metadata: {
...input.metadata,
org_id: organizationId,
},
}, {
idempotencyKey: `omnirush-org-customer:${organizationId}`,
})
return customer.id
}
const email = input.email.trim()
if (!email) {
throw new Error("stripe_customer_email_missing")
}
const existing = await stripe().customers.list({ email, limit: 1 })
if (existing.data[0]) {
return existing.data[0].id
}
const customer = await stripe().customers.create({
email,
name: input.name,
metadata: input.metadata,
})
return customer.id
}
export function omniRushWebCheckoutIdempotencyKey(input: {
organizationId: string
quantity: number
previousSessionId?: string | null
}) {
return `omnirush-web-checkout:${input.organizationId}:${input.quantity}:${input.previousSessionId ?? "initial"}`
}
function subscriptionHasConfiguredOmniRushWebPrice(subscription: Stripe.Subscription) {
const item = firstSubscriptionItem(subscription)
return Boolean(
env.stripe.omnirushWebPriceId
&& typeof item?.price?.id === "string"
&& item.price.id === env.stripe.omnirushWebPriceId,
)
}
async function validateOmniRushWebPrice(priceId: string) {
const price = await stripe().prices.retrieve(priceId)
if (
!price.active
|| price.type !== "recurring"
|| price.billing_scheme !== "per_unit"
|| price.transform_quantity !== null
|| price.unit_amount !== OMNIRUSH_WEB_UNIT_AMOUNT
|| price.currency.toLowerCase() !== OMNIRUSH_WEB_CURRENCY
|| price.recurring?.interval !== OMNIRUSH_WEB_INTERVAL
|| price.recurring.interval_count !== 1
|| price.recurring.usage_type !== "licensed"
) {
throw new Error("stripe_omnirush_web_price_contract_invalid")
}
}
function checkoutSessionMatchesOmniRushWeb(input: {
session: Stripe.Checkout.Session
organizationId: string
}) {
const metadata = getBillingMetadata(input.session.metadata)
return input.session.mode === "subscription"
&& input.session.client_reference_id === input.organizationId
&& metadata.organizationId === input.organizationId
&& metadata.subscriptionType === WEB_SUBSCRIPTION_TYPE
}
async function createOmniRushWebCheckoutSession(input: {
organizationId: OrgId
orgMemberId: MemberId
email: string
name: string
priceId: string
metadata: Stripe.MetadataParam
successUrl: string
cancelUrl: string
}) {
await validateOmniRushWebPrice(input.priceId)
const quantity = await joinedMemberCount(input.organizationId)
if (quantity < 1) {
throw new Error("stripe_omnirush_web_quantity_empty")
}
const storedWebSubscription = await findWebSubscriptionByOrg(input.organizationId)
if (storedWebSubscription?.stripe_subscription_id) {
const refreshedWebSubscription = await refreshOrgSubscriptionFromStripe(storedWebSubscription.stripe_subscription_id)
if (isOngoingConfiguredOmniRushWebSubscriptionRow(refreshedWebSubscription)) {
throw new Error("stripe_omnirush_web_subscription_exists")
}
}
const customer = await findOrCreateStripeCustomer({
organizationId: input.organizationId,
email: input.email,
name: input.name,
metadata: {
org_id: input.organizationId,
created_by_org_member_id: input.orgMemberId,
omnirush_product: "omnirush_web",
},
})
const subscriptions = await stripe().subscriptions.list({
customer,
status: "all",
limit: 100,
})
const existingOngoingSubscription = subscriptions.data.find((subscription) => {
const metadata = getSubscriptionMetadata(subscription)
return metadata.organizationId === input.organizationId
&& metadata.subscriptionType === WEB_SUBSCRIPTION_TYPE
&& isOngoingOmniRushWebSubscriptionStatus(subscription.status)
&& subscriptionHasConfiguredOmniRushWebPrice(subscription)
})
if (existingOngoingSubscription) {
await upsertOrgSubscriptionFromStripe(existingOngoingSubscription)
throw new Error("stripe_omnirush_web_subscription_exists")
}
const checkoutSessions = await stripe().checkout.sessions.list({
customer,
limit: 100,
})
const latestMatchingSession = checkoutSessions.data.find((session) => checkoutSessionMatchesOmniRushWeb({
session,
organizationId: input.organizationId,
}))
if (latestMatchingSession?.status === "open" && latestMatchingSession.url) {
const lineItems = await stripe().checkout.sessions.listLineItems(latestMatchingSession.id, { limit: 1 })
const lineItem = lineItems.data[0]
const lineItemPriceId = typeof lineItem?.price?.id === "string" ? lineItem.price.id : null
if (lineItemPriceId === input.priceId && lineItem?.quantity === quantity) {
return latestMatchingSession
}
await stripe().checkout.sessions.expire(latestMatchingSession.id).catch((error) => {
logger.warn("failed to expire stale OmniRush.ai Web Checkout session", {
organization_id: input.organizationId,
stripe_checkout_session_id: latestMatchingSession.id,
error,
})
})
}
return stripe().checkout.sessions.create({
mode: "subscription",
customer,
allow_promotion_codes: true,
line_items: [{ price: input.priceId, quantity }],
success_url: input.successUrl,
cancel_url: input.cancelUrl,
client_reference_id: input.organizationId,
metadata: input.metadata,
subscription_data: {
metadata: input.metadata,
},
}, {
idempotencyKey: omniRushWebCheckoutIdempotencyKey({
organizationId: input.organizationId,
quantity,
previousSessionId: latestMatchingSession?.id,
}),
})
}
export async function createOrgSubscriptionCheckoutSession(input: {
subscriptionType: StripeCheckoutSubscriptionType
organizationId: OrgId
orgMemberId: MemberId
email: string
name: string
successUrl: string
cancelUrl: string
}) {
if (input.subscriptionType === INFERENCE_SUBSCRIPTION_TYPE) {
await assertOrganizationManagedModelsAllowed(input.organizationId)
}
const priceId = requirePriceIdForSubscriptionType(input.subscriptionType)
const omnirushProduct = input.subscriptionType === SEAT_SUBSCRIPTION_TYPE
? "omnirush_seats"
: input.subscriptionType === WEB_SUBSCRIPTION_TYPE
? "omnirush_web"
: "omnirush_models"
const metadata = {
org_id: input.organizationId,
created_by_org_member_id: input.orgMemberId,
omnirush_product: omnirushProduct,
subscription_type: input.subscriptionType,
}
if (input.subscriptionType === WEB_SUBSCRIPTION_TYPE) {
return createOmniRushWebCheckoutSession({
organizationId: input.organizationId,
orgMemberId: input.orgMemberId,
email: input.email,
name: input.name,
priceId,
metadata,
successUrl: input.successUrl,
cancelUrl: input.cancelUrl,
})
}
const customer = await findOrCreateStripeCustomer({
organizationId: input.organizationId,
email: input.email,
name: input.name,
metadata: {
org_id: input.organizationId,
created_by_org_member_id: input.orgMemberId,
omnirush_product: omnirushProduct,
},
})
if (input.subscriptionType === SEAT_SUBSCRIPTION_TYPE) {
return stripe().checkout.sessions.create({
mode: "setup",
customer,
currency: "usd",
success_url: input.successUrl,
cancel_url: input.cancelUrl,
client_reference_id: input.organizationId,
metadata,
setup_intent_data: { metadata },
})
}
const quantity = Math.max(1, await activeMemberCount(input.organizationId))
await assertOrganizationManagedModelsAllowed(input.organizationId)
return stripe().checkout.sessions.create({
mode: "subscription",
customer,
allow_promotion_codes: true,
line_items: [{ price: priceId, quantity }],
success_url: input.successUrl,
cancel_url: input.cancelUrl,
client_reference_id: input.organizationId,
metadata,
subscription_data: {
metadata,
},
})
}
export async function createInferenceCheckoutSession(input: Omit<Parameters<typeof createOrgSubscriptionCheckoutSession>[0], "subscriptionType">) {
return createOrgSubscriptionCheckoutSession({ ...input, subscriptionType: INFERENCE_SUBSCRIPTION_TYPE })
}
export async function createSeatCheckoutSession(input: Omit<Parameters<typeof createOrgSubscriptionCheckoutSession>[0], "subscriptionType">) {
return createOrgSubscriptionCheckoutSession({ ...input, subscriptionType: SEAT_SUBSCRIPTION_TYPE })
}
export async function createOmniRushWebCheckout(input: Omit<Parameters<typeof createOrgSubscriptionCheckoutSession>[0], "subscriptionType">) {
return createOrgSubscriptionCheckoutSession({ ...input, subscriptionType: WEB_SUBSCRIPTION_TYPE })
}
export async function createStripePortalSession(input: { organizationId: OrgId; returnUrl: string }) {
const storedCustomerId = await findStripeCustomerIdByOrg(input.organizationId)
const stripeCustomerId = storedCustomerId && await stripeCustomerBelongsToOrganization(storedCustomerId, input.organizationId)
? storedCustomerId
: await findStripeCustomerIdByOrgMetadata(input.organizationId)
if (!stripeCustomerId) {
throw new Error("stripe_customer_missing")
}
return stripe().billingPortal.sessions.create({
customer: stripeCustomerId,
return_url: input.returnUrl,
})
}
export async function createInferencePortalSession(input: { organizationId: OrgId; returnUrl: string }) {
return createStripePortalSession(input)
}
function serializeSubscription(row: Awaited<ReturnType<typeof findOrgSubscriptionByStripeId>>) {
return row ? {
id: row.id,
status: row.status,
paymentStatus: omniRushWebPaymentStatus(row.status, row.payment_failed),
stripeCustomerId: row.stripe_customer_id,
stripeSubscriptionId: row.stripe_subscription_id,
stripePriceId: row.stripe_price_id,
quantity: row.quantity,
currentPeriodStart: row.current_period_start?.toISOString() ?? null,
currentPeriodEnd: row.current_period_end?.toISOString() ?? null,
cancelAtPeriodEnd: row.cancel_at_period_end,
canceledAt: row.canceled_at?.toISOString() ?? null,
endedAt: row.ended_at?.toISOString() ?? null,
} : null
}
function serializeOmniRushWebSubscription(row: Awaited<ReturnType<typeof findWebSubscriptionByOrg>>) {
return row ? {
status: row.status,
paymentStatus: omniRushWebPaymentStatus(row.status, row.payment_failed),
quantity: row.quantity,
currentPeriodStart: row.current_period_start?.toISOString() ?? null,
currentPeriodEnd: row.current_period_end?.toISOString() ?? null,
cancelAtPeriodEnd: row.cancel_at_period_end,
canceledAt: row.canceled_at?.toISOString() ?? null,
endedAt: row.ended_at?.toISOString() ?? null,
} : null
}
async function loadOmniRushWebBillingSummary(organizationId: OrgId) {
const [row, memberCount, complimentaryAccess] = await Promise.all([
findWebSubscriptionByOrg(organizationId),
joinedMemberCount(organizationId),
organizationOmniRushWebComplimentaryAccess(organizationId),
])
const billing = calculateOmniRushWebBilling({ joinedMemberCount: memberCount })
const hasEligibleSubscription = isEligibleOmniRushWebSubscriptionRow(row)
const access = resolveOmniRushWebAccess({
deploymentAvailable: isOmniRushWebAvailable(),
hasEligibleSubscription,
complimentaryAccess,
})
return {
row,
summary: {
configured: isOmniRushWebAvailable()
&& Boolean(env.stripe.secretKey && env.stripe.omnirushWebPriceId),
unitAmount: OMNIRUSH_WEB_UNIT_AMOUNT,
currency: OMNIRUSH_WEB_CURRENCY,
interval: OMNIRUSH_WEB_INTERVAL,
quantityDefinition: OMNIRUSH_WEB_QUANTITY_DEFINITION,
quantityDescription: "Every joined, non-removed organization member; pending invitations are excluded.",
quantity: billing.quantity,
expectedMonthlyTotal: billing.expectedMonthlyTotal,
hasEligibleSubscription,
...access,
subscription: serializeOmniRushWebSubscription(row),
},
}
}
export async function getOmniRushWebAccess(organizationId: OrgId) {
const [row, complimentaryAccess] = await Promise.all([
findWebSubscriptionByOrg(organizationId),
organizationOmniRushWebComplimentaryAccess(organizationId),
])
return resolveOmniRushWebAccess({
deploymentAvailable: isOmniRushWebAvailable(),
hasEligibleSubscription: isEligibleOmniRushWebSubscriptionRow(row),
complimentaryAccess,
})
}
export async function getOmniRushWebBillingSummary(organizationId: OrgId) {
return (await loadOmniRushWebBillingSummary(organizationId)).summary
}
export async function getOrgBillingSummary(input: { organizationId: OrgId; includePortalUrl?: boolean; returnUrl: string }) {
const row = await findInferenceSubscriptionByOrg(input.organizationId)
const seatRow = await findSeatSubscriptionByOrg(input.organizationId)
const webBillingState = await loadOmniRushWebBillingSummary(input.organizationId)
const webRow = webBillingState.row
const seatCounts = await getOrganizationSeatBillingCounts({ organizationId: input.organizationId })
const hasActiveSubscription = Boolean(row && ACTIVE_STATUSES.has(row.status))
const hasActiveSeatSubscription = Boolean(seatRow && ACTIVE_STATUSES.has(seatRow.status))
const hasEligibleWebSubscription = isEligibleOmniRushWebSubscriptionRow(webRow)
let portalUrl: string | null = null
if (input.includePortalUrl && (row?.stripe_customer_id || seatRow?.stripe_customer_id || webRow?.stripe_customer_id)) {
try {
portalUrl = (await createInferencePortalSession({ organizationId: input.organizationId, returnUrl: input.returnUrl })).url
} catch (error) {
logger.warn("failed to create billing portal session", { organization_id: input.organizationId, error })
}
}
return {
stripe: {
configured: Boolean(env.stripe.secretKey && env.stripe.inferencePriceId),
priceId: env.stripe.inferencePriceId ?? null,
unitAmount: 1000,
currency: "usd",
interval: "month",
memberCount: seatCounts.total,
hasActiveSubscription,
portalUrl,
subscription: serializeSubscription(row),
seats: {
configured: Boolean(env.stripe.secretKey && env.stripe.seatPriceId),
priceId: env.stripe.seatPriceId ?? null,
unitAmount: 1000,
currency: "usd",
interval: "month",
freeSeatCount: seatCounts.free,
seatsFreeAdditional: seatCounts.additionalFree,
billableSeatCount: seatCounts.chargeable,
hasActiveSubscription: hasActiveSeatSubscription,
subscription: serializeSubscription(seatRow),
},
web: {
...webBillingState.summary,
priceId: env.stripe.omnirushWebPriceId ?? null,
hasEligibleSubscription: hasEligibleWebSubscription,
portalUrl,
subscription: serializeSubscription(webRow),
},
},
}
}
export async function syncInferenceSubscriptionQuantityAfterMemberChange(input: { organizationId: OrgId; memberCount: number }) {
if (!env.stripe.secretKey) {
return
}
const row = await findInferenceSubscriptionByOrg(input.organizationId)
if (!row || !ACTIVE_STATUSES.has(row.status) || !row.stripe_subscription_item_id) {
return
}
const quantity = Math.max(1, input.memberCount)
await stripe().subscriptionItems.update(row.stripe_subscription_item_id, {
quantity,
// Accrue prorations onto the next monthly invoice instead of charging
// (and invoicing) every quantity change immediately. Customers get one
// consolidated invoice per cycle; add/remove churn nets out.
proration_behavior: "create_prorations",
})
}
export async function syncSeatSubscriptionQuantityAfterMemberChange(input: { organizationId: OrgId; memberCount: number }) {
if (!env.stripe.secretKey) {
return
}
const row = await findSeatSubscriptionByOrg(input.organizationId)
if (!row || !ACTIVE_STATUSES.has(row.status) || !row.stripe_subscription_item_id) {
return
}
const seatCounts = await getOrganizationSeatBillingCounts(input)
await stripe().subscriptionItems.update(row.stripe_subscription_item_id, {
quantity: seatCounts.chargeable,
// See syncInferenceSubscriptionQuantityAfterMemberChange: one invoice per
// cycle instead of a card charge per seat change.
proration_behavior: "create_prorations",
})
}
export async function syncWebSubscriptionQuantityAfterMemberChange(input: { organizationId: OrgId; memberCount: number }) {
if (!env.stripe.secretKey) {
return
}
const row = await findWebSubscriptionByOrg(input.organizationId)
if (!isEligibleOmniRushWebSubscriptionRow(row) || !row?.stripe_subscription_item_id) {
return
}
const quantity = await joinedMemberCount(input.organizationId)
if (quantity < 1 || row.quantity === quantity) {
return
}
await stripe().subscriptionItems.update(row.stripe_subscription_item_id, {
quantity,
proration_behavior: "create_prorations",
})
}
async function createSeatSubscriptionFromSetupCheckoutSession(session: Stripe.Checkout.Session, eventId: string) {
if (typeof session.setup_intent !== "string" || typeof session.customer !== "string") {
return null
}
const metadata = getBillingMetadata(session.metadata)
if (metadata.subscriptionType !== SEAT_SUBSCRIPTION_TYPE || !metadata.organizationId) {
return null
}
const existingSeatSubscription = await findSeatSubscriptionByOrg(metadata.organizationId as OrgId)
if (existingSeatSubscription && ACTIVE_STATUSES.has(existingSeatSubscription.status)) {
return existingSeatSubscription
}
const setupIntent = await stripe().setupIntents.retrieve(session.setup_intent)
const paymentMethod = typeof setupIntent.payment_method === "string"
? setupIntent.payment_method
: setupIntent.payment_method?.id ?? null
if (!paymentMethod) {
throw new Error("stripe_setup_payment_method_missing")
}
const subscription = await stripe().subscriptions.create(
{
customer: session.customer,
default_payment_method: paymentMethod,
items: [{ price: requireSeatPriceId(), quantity: 0 }],
metadata: {
org_id: metadata.organizationId,
created_by_org_member_id: metadata.orgMemberId ?? "",
omnirush_product: "omnirush_seats",
subscription_type: SEAT_SUBSCRIPTION_TYPE,
},
},
{ idempotencyKey: `omnirush-seat-subscription-${session.id}` },
)
return upsertOrgSubscriptionFromStripe(subscription, eventId)
}
export async function syncSeatCheckoutSession(input: { organizationId: OrgId; sessionId: string }) {
const session = await stripe().checkout.sessions.retrieve(input.sessionId)
const metadata = getBillingMetadata(session.metadata)
if (metadata.subscriptionType !== SEAT_SUBSCRIPTION_TYPE) {
return null
}
if (metadata.organizationId !== input.organizationId) {
throw new Error("stripe_checkout_session_org_mismatch")
}
if (session.status !== "complete") {
return null
}
return createSeatSubscriptionFromSetupCheckoutSession(session, `checkout-session-sync:${session.id}`)
}
export async function syncStripeCheckoutSession(input: { organizationId: OrgId; sessionId: string }) {
const session = await stripe().checkout.sessions.retrieve(input.sessionId)
const metadata = getBillingMetadata(session.metadata)
if (metadata.organizationId !== input.organizationId) {
throw new Error("stripe_checkout_session_org_mismatch")
}
if (session.status !== "complete") {
return null
}
if (session.mode === "setup") {
return createSeatSubscriptionFromSetupCheckoutSession(session, `checkout-session-sync:${session.id}`)
}
if (typeof session.subscription !== "string") {
return null
}
const subscription = await stripe().subscriptions.retrieve(session.subscription)
const subscriptionMetadata = getSubscriptionMetadata(subscription)
if (subscriptionMetadata.organizationId !== input.organizationId) {
throw new Error("stripe_checkout_session_org_mismatch")
}
const eventId = `checkout-session-sync:${session.id}`
let row = await syncCurrentStripeSubscription(subscription.id, eventId)
if (row?.type === WEB_SUBSCRIPTION_TYPE) {
row = await syncOmniRushWebPaymentStateFromCurrentInvoice({
row,
stripeSubscriptionId: subscription.id,
eventId,
})
}
if (row?.type === INFERENCE_SUBSCRIPTION_TYPE && ACTIVE_STATUSES.has(subscriptionStatus(subscription.status))) {
await activatePurchasedInference(row.organization_id)
}
return row
}
async function activatePurchasedInference(organizationId: OrgId) {
try {
await setInferenceEnabled({ organizationId, enabled: true })
} catch (error) {
// Keep the purchase history, but acknowledge a deliberate policy denial.
// Unavailable policy must still fail safely so a later delivery can retry.
if (error instanceof ManagedModelsPolicyError && error.code === "managed_models_disabled_for_dpa") return
throw error
}
}
async function syncCurrentStripeSubscription(stripeSubscriptionId: string, eventId: string) {
const subscription = await stripe().subscriptions.retrieve(stripeSubscriptionId)
const item = firstSubscriptionItem(subscription)
const metadata = getSubscriptionMetadata(subscription)
const subscriptionType = subscriptionTypeFromStripeSubscription(subscription, item)
if (subscriptionType === WEB_SUBSCRIPTION_TYPE && metadata.organizationId) {
const existing = await findWebSubscriptionByOrg(metadata.organizationId as OrgId)
if (existing?.stripe_subscription_id && existing.stripe_subscription_id !== subscription.id) {
const refreshedExisting = await refreshOrgSubscriptionFromStripe(existing.stripe_subscription_id)
if (isOngoingConfiguredOmniRushWebSubscriptionRow(refreshedExisting)) {
return refreshedExisting
}
}
}
return upsertOrgSubscriptionFromStripe(subscription, eventId)
}
async function syncOmniRushWebPaymentStateFromCurrentInvoice(input: {
row: Awaited<ReturnType<typeof findOrgSubscriptionByStripeId>>
stripeSubscriptionId: string
eventId: string
}) {
if (
!input.row
|| input.row.type !== WEB_SUBSCRIPTION_TYPE
|| input.row.stripe_subscription_id !== input.stripeSubscriptionId
) {
return input.row
}
const subscription = await stripe().subscriptions.retrieve(input.stripeSubscriptionId)
if (subscription.id !== input.stripeSubscriptionId) {
return input.row
}
const latestInvoiceId = stripeResourceId(subscription.latest_invoice)
if (!latestInvoiceId) {
return input.row
}
const currentInvoice = await stripe().invoices.retrieve(latestInvoiceId)
if (currentInvoice.id !== latestInvoiceId) {
return input.row
}
const paymentFailed = currentInvoice.status !== "paid"
await db
.update(OrgSubscriptionTable)
.set({ payment_failed: paymentFailed, last_event_id: input.eventId, updated_at: new Date() })
.where(eq(OrgSubscriptionTable.id, input.row.id))
return { ...input.row, payment_failed: paymentFailed }
}
function stripeResourceId(resource: string | { id: string } | null | undefined) {
return typeof resource === "string" ? resource : resource?.id ?? null
}
async function expireNonWebSubscriptionAfterPaymentFailure(
row: NonNullable<Awaited<ReturnType<typeof findOrgSubscriptionByStripeId>>>,
eventId: string,
) {
await db
.update(OrgSubscriptionTable)
.set({ status: "expired", last_event_id: eventId, updated_at: new Date() })
.where(eq(OrgSubscriptionTable.id, row.id))
if (row.type === INFERENCE_SUBSCRIPTION_TYPE) {
await setInferenceEnabled({ organizationId: row.organization_id, enabled: false })
}
}
async function syncPaymentStateFromInvoiceEvent(input: {
invoice: Stripe.Invoice
eventType: "invoice.paid" | "invoice.payment_failed"
eventId: string
}) {
const subscriptionId = stripeResourceId(input.invoice.parent?.subscription_details?.subscription)
if (!subscriptionId) {
return null
}
const existingRow = await findOrgSubscriptionByStripeId(subscriptionId)
if (input.eventType === "invoice.payment_failed" && existingRow && existingRow.type !== WEB_SUBSCRIPTION_TYPE) {
await expireNonWebSubscriptionAfterPaymentFailure(existingRow, input.eventId)
return null
}
const subscription = await stripe().subscriptions.retrieve(subscriptionId)
const subscriptionType = subscriptionTypeFromStripeSubscription(subscription, firstSubscriptionItem(subscription))
if (subscriptionType !== WEB_SUBSCRIPTION_TYPE) {
const row = await syncCurrentStripeSubscription(subscription.id, input.eventId)
if (input.eventType === "invoice.payment_failed" && row) {
await expireNonWebSubscriptionAfterPaymentFailure(row, input.eventId)
return null
}
return row
}
const latestInvoiceId = stripeResourceId(subscription.latest_invoice)
if (!latestInvoiceId || latestInvoiceId !== input.invoice.id) {
return null
}
const currentInvoice = await stripe().invoices.retrieve(latestInvoiceId)
if (currentInvoice.id !== latestInvoiceId) {
return null
}
const paymentFailed = currentInvoice.status === "paid"
? false
: input.eventType === "invoice.payment_failed"
? true
: null
if (paymentFailed === null) {
return null
}
const row = await syncCurrentStripeSubscription(subscription.id, input.eventId)
if (!row || row.type !== WEB_SUBSCRIPTION_TYPE || row.stripe_subscription_id !== subscription.id) {
return null
}
await db
.update(OrgSubscriptionTable)
.set({ payment_failed: paymentFailed, last_event_id: input.eventId, updated_at: new Date() })
.where(eq(OrgSubscriptionTable.id, row.id))
return { ...row, payment_failed: paymentFailed }
}
export async function handleStripeWebhook(input: { payload: string; signature: string | null }) {
if (!env.stripe.webhookSecret) {
throw new Error("stripe_webhook_secret_missing")
}
if (!input.signature) {
throw new Error("stripe_signature_missing")
}
const event = stripe().webhooks.constructEvent(input.payload, input.signature, env.stripe.webhookSecret)
switch (event.type) {
case "checkout.session.async_payment_failed": {
const session = event.data.object as Stripe.Checkout.Session
if (typeof session.subscription === "string") {
const subscription = await stripe().subscriptions.retrieve(session.subscription)
let row = await syncCurrentStripeSubscription(subscription.id, event.id)
if (row?.type === WEB_SUBSCRIPTION_TYPE) {
row = await syncOmniRushWebPaymentStateFromCurrentInvoice({
row,
stripeSubscriptionId: subscription.id,
eventId: event.id,
})
} else if (row) {
await expireNonWebSubscriptionAfterPaymentFailure(row, event.id)
}
}
break
}
case "checkout.session.completed":
case "checkout.session.async_payment_succeeded": {
const session = event.data.object as Stripe.Checkout.Session
if (session.mode === "setup") {
await createSeatSubscriptionFromSetupCheckoutSession(session, event.id)
} else if (typeof session.subscription === "string") {
const subscription = await stripe().subscriptions.retrieve(session.subscription)
let row = await syncCurrentStripeSubscription(subscription.id, event.id)
if (row?.type === WEB_SUBSCRIPTION_TYPE) {
row = await syncOmniRushWebPaymentStateFromCurrentInvoice({
row,
stripeSubscriptionId: subscription.id,
eventId: event.id,
})
}
if (row?.type === INFERENCE_SUBSCRIPTION_TYPE && ACTIVE_STATUSES.has(subscriptionStatus(subscription.status))) {
await activatePurchasedInference(row.organization_id)
}
if (row?.type === WEB_SUBSCRIPTION_TYPE && isEligibleOmniRushWebSubscriptionStatus(subscription.status)) {
await syncWebSubscriptionQuantityAfterMemberChange({
organizationId: row.organization_id,
memberCount: row.quantity,
})
}
}
break
}
case "customer.subscription.created":
case "customer.subscription.updated":
case "customer.subscription.deleted": {
const row = await syncCurrentStripeSubscription((event.data.object as Stripe.Subscription).id, event.id)
if (row?.type === WEB_SUBSCRIPTION_TYPE && isEligibleOmniRushWebSubscriptionStatus(row.status)) {
await syncWebSubscriptionQuantityAfterMemberChange({
organizationId: row.organization_id,
memberCount: row.quantity,
})
}
break
}
case "invoice.paid":
case "invoice.payment_failed": {
const row = await syncPaymentStateFromInvoiceEvent({
invoice: event.data.object as Stripe.Invoice,
eventType: event.type,
eventId: event.id,
})
if (row && isEligibleOmniRushWebSubscriptionRow(row)) {
await syncWebSubscriptionQuantityAfterMemberChange({
organizationId: row.organization_id,
memberCount: row.quantity,
})
}
break
}
}
return { received: true, type: event.type }
}