better-supabase 0.5.0 → 0.6.0

package/dist/blocks/billing/index.d.ts

@@ -0,0 +1,265 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-D7y2fT87.js";
+import { t as SqlClient } from "../../executor-DbvExCFC.js";
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { E as BlockEventType, a as EventHub, x as BillingEventData } from "../../events-DWDhx77e.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-CKtbFcRv.js";
+import { n as StripeSource, r as StripeTaxId, t as StripeClient } from "../../stripe-D04h-QBT.js";
+import { r as EventSink } from "../../cloud-event-C1JCc1bH.js";
+import { h as stripeInboxVerify, p as signStripeWebhook, v as verifyStripeWebhook } from "../../verify-DPuWngD4.js";
+//#region src/blocks/billing/billing.d.ts
+interface BillingOptions extends BlockTemporalOptions {
+  readonly stripe: StripeSource;
+  /** A service-role transport: linking customers and reading seats are granted to `service_role` only. */
+  readonly transport: BlockTransport;
+  /** The module schema (`sql.modules.billing.schema`), default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `betterSupabase.events`, for `billing.*` block events. */
+  readonly events?: EventHub;
+  /** The per-seat price `syncSeats` updates; default the subscription's first item. */
+  readonly seatPrice?: string;
+  /** Stripe `proration_behavior` for seat changes, default `create_prorations`. */
+  readonly prorationBehavior?: "create_prorations" | "none" | "always_invoice";
+  /**
+   * Invalidates the cached sessions of a customer's members after a plan
+   * change (`entitlementMembers`), so their next request reads the new
+   * entitlements. Needs the `entitlements` module.
+   */
+  readonly sessions?: {
+    readonly sql: SqlClient;
+    readonly invalidate: (userId: string) => void;
+  };
+}
+interface CustomerDetails {
+  readonly email?: string;
+  readonly name?: string;
+}
+interface CheckoutOptions extends CustomerDetails {
+  /** A Stripe price id. Pass this or `plan`. */
+  readonly price?: string;
+  /**
+   * A plan key from `sql.modules.billing.options.plans`, resolved to its
+   * Stripe price in the app's plan catalog (with `interval` when plans have
+   * monthly and yearly prices).
+   */
+  readonly plan?: string;
+  readonly interval?: string;
+  /** One of the plan's prices, from the catalog's `variant` column. */
+  readonly variant?: string;
+  /**
+   * More line items, such as add-on packages next to the plan: each a
+   * price, or a plan key with `interval` and `variant`. Quantity defaults to 1.
+   */
+  readonly items?: readonly CheckoutItem[];
+  readonly successUrl: string;
+  readonly cancelUrl?: string;
+  /** A number, or `seats` for the tenant's seat count. Default 1. */
+  readonly quantity?: number | "seats";
+  /** Default `subscription`. */
+  readonly mode?: "subscription" | "payment";
+  /**
+   * More Checkout Session parameters, merged deeply over the block's (nested
+   * objects such as `metadata` merge, arrays replace). The customer,
+   * `client_reference_id` and the tenant's `metadata.organization_id` always
+   * stay.
+   */
+  readonly params?: Readonly<Record<string, unknown>>;
+  readonly idempotencyKey?: string;
+}
+/** An extra Checkout line item. */
+interface CheckoutItem {
+  readonly price?: string;
+  readonly plan?: string;
+  readonly interval?: string;
+  readonly variant?: string;
+  readonly quantity?: number;
+}
+interface SubscriptionItem {
+  readonly subscriptionId: string;
+  readonly itemId: string;
+  readonly price: string | undefined;
+  readonly quantity: number;
+  readonly status: string;
+}
+interface BillingStatus {
+  readonly customerId: string | undefined;
+  readonly seats: number;
+  readonly subscription: SubscriptionItem | undefined;
+}
+interface SeatSync {
+  readonly quantity: number;
+  readonly previousQuantity: number | undefined;
+  /** False when there is no subscription item or the quantity already matches. */
+  readonly changed: boolean;
+}
+/** The parts of a Stripe event the block reads. */
+interface StripeEvent {
+  readonly id: string;
+  readonly type: string;
+  readonly data: {
+    readonly object: unknown;
+  };
+}
+interface StripeEventOutcome {
+  /** The `billing.*` block event it emitted, if any. */
+  readonly event: BlockEventType | undefined;
+  readonly organizationId: string | undefined;
+  readonly customerId: string | undefined;
+  /** Members whose sessions were invalidated. */
+  readonly invalidated: readonly string[];
+}
+/** A plan change: a price id, or a plan key from the catalog. */
+interface PlanChange {
+  readonly price?: string;
+  readonly plan?: string;
+  readonly interval?: string;
+  readonly variant?: string;
+  /** Stripe `proration_behavior`, default `create_prorations`. */
+  readonly prorationBehavior?: "create_prorations" | "none" | "always_invoice";
+  /** Also clears a scheduled cancellation. Default true. */
+  readonly resume?: boolean;
+  readonly idempotencyKey?: string;
+}
+/**
+ * A row of the Stripe Sync Engine's `stripe` schema as stored, such as an
+ * invoice (`id`, `status`, `total`, `currency`, `hosted_invoice_url`) or a
+ * payment method (`id`, `type`, `card`).
+ */
+type StripeRow = Readonly<Record<string, unknown>>;
+/** A Sync Engine row with the tenant and customer it belongs to, from a platform read. */
+interface TenantStripeRow {
+  readonly organizationId: string;
+  readonly customerId: string;
+  readonly row: StripeRow;
+}
+/** A linked Stripe customer, from `billing_all_customers`. */
+interface BillingCustomer {
+  readonly organizationId: string;
+  readonly customerId: string;
+  /** From the Sync Engine's `stripe.customers`; `undefined` before it syncs. */
+  readonly email: string | undefined;
+  readonly name: string | undefined;
+  readonly created: Temporal.Instant | undefined;
+}
+interface PlatformListOptions extends CursorPageOptions<number> {
+  /** Only rows with this Stripe status, such as `active` or `open`. */
+  readonly status?: string;
+  /** Defaults to 100, at most 500. */
+  readonly limit?: number;
+  /** Only rows Stripe created before this (epoch seconds), for the next page. */
+  readonly cursor?: number;
+}
+interface BillingCustomerUpdate {
+  readonly email?: string;
+  readonly name?: string;
+  readonly phone?: string;
+  readonly address?: Readonly<Record<string, string>>;
+  /** Stripe customer parameters merged over these, such as `invoice_settings`. */
+  readonly params?: Readonly<Record<string, unknown>>;
+}
+interface Billing {
+  /** The tenant's Stripe customer, or `undefined` before the first checkout. */
+  customer(organizationId: string): AsyncResult<string | undefined>;
+  /** The tenant's customer, created in Stripe (with the tenant in `metadata`) when there is none. */
+  ensureCustomer(organizationId: string, details?: CustomerDetails): AsyncResult<string>;
+  checkout(organizationId: string, options: CheckoutOptions): AsyncResult<{
+    readonly id: string;
+    readonly url: string | undefined;
+  }>;
+  /** A customer portal session; `not_found` before the tenant has a customer. */
+  portal(organizationId: string, options: {
+    readonly returnUrl: string;
+  }): AsyncResult<{
+    readonly url: string;
+  }>;
+  status(organizationId: string): AsyncResult<BillingStatus>;
+  /**
+   * The tenant's newest subscription as the Sync Engine stores it (every
+   * column, with `items`), preferring an active one; `undefined` without
+   * one. For `billing.read` in the tenant, or platform staff.
+   */
+  subscription(organizationId: string): AsyncResult<StripeRow | undefined>;
+  /**
+   * Every tenant's newest subscription, newest first, for platform staff
+   * (`billing.read` in the platform scope) or a service transport.
+   */
+  allSubscriptions(options?: PlatformListOptions): AsyncResult<readonly TenantStripeRow[]>;
+  /**
+   * Every linked customer, with or without a subscription, by tenant, for
+   * platform staff (`billing.read` in the platform scope) or a service
+   * transport.
+   */
+  allCustomers(): AsyncResult<readonly BillingCustomer[]>;
+  /**
+   * Cancels the tenant's active subscription in Stripe now; `undefined`
+   * when it has none. The `customer.subscription.deleted` webhook then
+   * emits `billing.subscription_deleted`.
+   */
+  cancelSubscription(organizationId: string): AsyncResult<string | undefined>;
+  /** Sets the seat item's quantity to the tenant's seat count. */
+  syncSeats(organizationId: string, options?: {
+    readonly key?: string;
+  }): AsyncResult<SeatSync>;
+  /**
+   * An outbox sink that syncs seats after `organization.member_*` and
+   * `organization.role_changed` events: `outbox.relay('billing-seats', billing.seatSink())`.
+   */
+  seatSink(): EventSink;
+  /**
+   * Moves the tenant's subscription item to another price (an upgrade or
+   * downgrade). Needs a subscription; `not_found` otherwise. Admin consoles
+   * call it with a service transport after their own permission check.
+   */
+  changePlan(organizationId: string, change: PlanChange): AsyncResult<SubscriptionItem>;
+  /** Schedules (true) or clears (false) the cancellation at the end of the period. */
+  cancelAtPeriodEnd(organizationId: string, cancel: boolean): AsyncResult<string>;
+  /**
+   * Every tenant's invoices, newest first, for platform staff (`billing.read`
+   * in the platform scope) or a service transport.
+   */
+  allInvoices(options?: PlatformListOptions): AsyncResult<readonly TenantStripeRow[]>;
+  /** The tenant's invoices from the Sync Engine, newest first (`billing.read`, or platform staff). */
+  invoices(organizationId: string, options?: {
+    readonly limit?: number;
+  }): AsyncResult<readonly StripeRow[]>;
+  /** The tenant's payment methods from the Sync Engine (`billing.read`). */
+  paymentMethods(organizationId: string): AsyncResult<readonly StripeRow[]>;
+  /** Voids an open invoice of the tenant's customer. */
+  voidInvoice(organizationId: string, invoiceId: string): AsyncResult<string>;
+  /** Marks an open invoice of the tenant's customer uncollectible. */
+  markInvoiceUncollectible(organizationId: string, invoiceId: string): AsyncResult<string>;
+  /** The billing contact as Stripe holds it, from the Sync Engine's customers table. */
+  customerDetails(organizationId: string): AsyncResult<StripeRow | undefined>;
+  /**
+   * The tenant customer's tax ids, `[]` before the tenant has a customer.
+   * From Stripe by default, which needs `customers.listTaxIds` on the
+   * client; `{ from: "sync" }` reads the Sync Engine's `stripe.tax_ids`
+   * through `billing_tax_ids` instead (`billing.read`, or platform staff).
+   */
+  taxIds(organizationId: string, options?: {
+    readonly from?: "stripe" | "sync";
+  }): AsyncResult<readonly StripeTaxId[]>;
+  /**
+   * Adds a tax id (`{ type: 'eu_vat', value: 'DE123456789' }`) to the
+   * tenant's customer, creating the customer first when there is none.
+   */
+  addTaxId(organizationId: string, taxId: {
+    readonly type: string;
+    readonly value: string;
+  }): AsyncResult<StripeTaxId>;
+  /** Removes a tax id from the tenant's customer; `not_found` before the tenant has a customer. */
+  removeTaxId(organizationId: string, taxId: string): AsyncResult<string>;
+  /** Updates the billing contact on the Stripe customer, the record for it. */
+  updateCustomer(organizationId: string, update: BillingCustomerUpdate): AsyncResult<string>;
+  /**
+   * Handles `checkout.session.completed` and `customer.subscription.*`:
+   * links the customer, emits `billing.*` events and invalidates sessions.
+   * Other events are ignored. Call it from `inbox.process`.
+   */
+  handleStripeEvent(event: unknown): AsyncResult<StripeEventOutcome>;
+}
+/** Stripe customers, checkout, the portal and seat sync over the `billing` module. */
+export declare function createBilling(options: BillingOptions): Billing;
+//#endregion
+export { type Billing, type BillingCustomer, type BillingCustomerUpdate, type BillingEventData, type BillingOptions, type BillingStatus, type BlockTransport, type CheckoutItem, type CheckoutOptions, type CustomerDetails, type PlanChange, type PlatformListOptions, type SeatSync, type StripeClient, type StripeEvent, type StripeEventOutcome, type StripeRow, type StripeSource, type StripeTaxId, type SubscriptionItem, type TenantStripeRow, rpcTransport, signStripeWebhook, sqlTransport, stripeInboxVerify, verifyStripeWebhook };

package/dist/blocks/billing/index.js

@@ -0,0 +1,400 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { i as emitBlockEvent } from "../../block-events-CrT8r7Fe.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { O as textOf, d as isRecord, g as pageOf, h as optionalText, i as blockCall, m as optionalInstant, n as applyTemporal, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { a as signStripeWebhook, s as stripeInboxVerify, u as verifyStripeWebhook } from "../../verify-DL41hbvY.js";
+import { n as entitlementMembers } from "../../entitlements-DRl6ZJUm.js";
+import { t as lazyStripe } from "../../stripe-BMj5LtsT.js";
+//#region src/blocks/billing/billing.ts
+const ORGANIZATION_KEY = "organization_id";
+const SEAT_EVENT = /(?:^|\.)organization\.(?:member_added|member_removed|member_left|role_changed)$/;
+function subscriptionItemOf(value) {
+	if (!isRecord(value)) return void 0;
+	return {
+		subscriptionId: textOf(value["subscription"]),
+		itemId: textOf(value["item"]),
+		price: optionalText(value["price"]),
+		quantity: Number(value["quantity"] ?? 0),
+		status: textOf(value["status"])
+	};
+}
+/** A row of `billing_tax_ids` as Stripe's tax id object. */
+function syncedTaxId(row) {
+	const verification = row["verification"];
+	const raw = row["created"];
+	const created = typeof raw === "number" || typeof raw === "string" && /^\d+$/.test(raw) ? Number(raw) : NaN;
+	return {
+		id: textOf(row["id"]),
+		type: textOf(row["type"]),
+		value: textOf(row["value"]),
+		country: optionalText(row["country"]) ?? null,
+		verification: isRecord(verification) ? { status: optionalText(verification["status"]) ?? null } : null,
+		created: Number.isSafeInteger(created) ? created : null
+	};
+}
+const customerIdOf = (value) => {
+	if (typeof value === "string") return value;
+	return isRecord(value) ? optionalText(value["id"]) : void 0;
+};
+const metadataTenant = (object) => {
+	const metadata = object["metadata"];
+	return isRecord(metadata) ? optionalText(metadata[ORGANIZATION_KEY]) : void 0;
+};
+function isStripeEvent(value) {
+	return isRecord(value) && typeof value["id"] === "string" && typeof value["type"] === "string" && isRecord(value["data"]);
+}
+/** `extra` merged into `base`: nested objects merge, arrays and other values replace. */
+function deepMerge(base, extra) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(extra)) {
+		const current = merged[key];
+		merged[key] = isRecord(current) && isRecord(value) ? deepMerge(current, value) : value;
+	}
+	return merged;
+}
+/**
+* The block's Checkout Session parameters with the app's `params` merged in
+* deeply, then the customer, `client_reference_id` and the tenant metadata
+* (on the session and, for a subscription, on `subscription_data`) set
+* again, so `params` adds metadata without dropping the link the webhook needs.
+*/
+function checkoutParams(base, extra, organizationId, customerId) {
+	const merged = extra === void 0 ? { ...base } : deepMerge(base, extra);
+	const tenant = { metadata: { [ORGANIZATION_KEY]: organizationId } };
+	return deepMerge(merged, {
+		customer: customerId,
+		client_reference_id: organizationId,
+		...tenant,
+		...merged["mode"] === "subscription" ? { subscription_data: tenant } : {}
+	});
+}
+/** Stripe calls as results: a thrown Stripe error becomes a `DbError`. */
+function stripeCall(work) {
+	return AsyncResult.from(async () => {
+		try {
+			return ok(await work());
+		} catch (cause) {
+			return err(toDbError(cause));
+		}
+	});
+}
+/** Stripe customers, checkout, the portal and seat sync over the `billing` module. */
+function createBilling(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const stripe = lazyStripe(options.stripe);
+	const withStripe = (work) => stripeCall(async () => work(await stripe()));
+	const emit = (type, data) => {
+		if (!options.events) return;
+		emitBlockEvent(options.events, type, data, {
+			tenant: data.organizationId,
+			subject: `organizations/${data.organizationId}`
+		});
+	};
+	const customer = (organizationId) => call("billing_customer", { tenant: organizationId }, optionalText);
+	const link = (organizationId, customerId) => call("link_billing_customer", {
+		tenant: organizationId,
+		customer: customerId
+	}, textOf);
+	const ensureCustomer = (organizationId, details = {}) => customer(organizationId).andThen(async (existing) => {
+		if (existing !== void 0) return ok(existing);
+		const created = await withStripe((client) => client.customers.create({
+			...details.email === void 0 ? {} : { email: details.email },
+			...details.name === void 0 ? {} : { name: details.name },
+			metadata: { [ORGANIZATION_KEY]: organizationId }
+		}, { idempotencyKey: `customer:${organizationId}` }));
+		if (!created.ok) return created;
+		const linked = await link(organizationId, created.data.id);
+		if (linked.ok && linked.data === created.data.id) emit("billing.customer_linked", {
+			organizationId,
+			customerId: linked.data
+		});
+		return linked;
+	});
+	const seats = (organizationId) => call("billing_seat_count", { tenant: organizationId }, (value) => Number(value ?? 0));
+	const item = (organizationId) => call("billing_subscription_item", {
+		tenant: organizationId,
+		price: options.seatPrice
+	}, subscriptionItemOf);
+	const syncSeats = (organizationId, sync = {}) => seats(organizationId).andThen(async (quantity) => {
+		const current = await item(organizationId);
+		if (!current.ok) return current;
+		const found = current.data;
+		if (found === void 0 || found.quantity === quantity) return ok({
+			quantity,
+			previousQuantity: found?.quantity,
+			changed: false
+		});
+		const key = `seats:${found.itemId}:${String(found.quantity)}:${String(quantity)}:${sync.key ?? crypto.randomUUID()}`;
+		const updated = await withStripe((client) => client.subscriptionItems.update(found.itemId, {
+			quantity,
+			proration_behavior: options.prorationBehavior ?? "create_prorations"
+		}, { idempotencyKey: key }));
+		if (!updated.ok) return updated;
+		emit("billing.seats_synced", {
+			organizationId,
+			subscriptionId: found.subscriptionId,
+			quantity,
+			previousQuantity: found.quantity
+		});
+		return ok({
+			quantity,
+			previousQuantity: found.quantity,
+			changed: true
+		});
+	});
+	const invalidate = async (event) => {
+		if (!options.sessions) return [];
+		const members = await entitlementMembers(options.sessions.sql, event);
+		if (!members.ok) return [];
+		for (const userId of members.data) options.sessions.invalidate(userId);
+		return members.data;
+	};
+	const handleStripeEvent = (input) => AsyncResult.from(async () => {
+		const ignored = {
+			event: void 0,
+			organizationId: void 0,
+			customerId: void 0,
+			invalidated: []
+		};
+		if (!isStripeEvent(input)) return ok(ignored);
+		const object = input.data.object;
+		if (!isRecord(object)) return ok(ignored);
+		const customerId = customerIdOf(object["customer"]);
+		if (input.type === "checkout.session.completed") {
+			const organizationId = metadataTenant(object) ?? optionalText(object["client_reference_id"]);
+			if (organizationId === void 0 || customerId === void 0) return ok({
+				...ignored,
+				customerId
+			});
+			const linked = await link(organizationId, customerId);
+			if (!linked.ok) return linked;
+			emit("billing.checkout_completed", {
+				organizationId,
+				customerId: linked.data,
+				stripeEventId: input.id,
+				...typeof object["subscription"] === "string" ? { subscriptionId: object["subscription"] } : {}
+			});
+			return ok({
+				event: "billing.checkout_completed",
+				organizationId,
+				customerId: linked.data,
+				invalidated: []
+			});
+		}
+		const type = {
+			"customer.subscription.created": "billing.subscription_created",
+			"customer.subscription.updated": "billing.subscription_updated",
+			"customer.subscription.deleted": "billing.subscription_deleted"
+		}[input.type];
+		if (type === void 0 || customerId === void 0) return ok(ignored);
+		const tenant = await call("billing_customer_tenant", { customer: customerId }, optionalText);
+		if (!tenant.ok) return tenant;
+		let organizationId = tenant.data;
+		const claimed = metadataTenant(object);
+		if (organizationId === void 0 && claimed !== void 0) {
+			const linked = await link(claimed, customerId);
+			if (!linked.ok) return linked;
+			if (linked.data === customerId) organizationId = claimed;
+		}
+		if (organizationId === void 0) return ok({
+			...ignored,
+			customerId
+		});
+		emit(type, {
+			organizationId,
+			customerId,
+			subscriptionId: textOf(object["id"]),
+			stripeEventId: input.id,
+			...typeof object["status"] === "string" ? { status: object["status"] } : {}
+		});
+		return ok({
+			event: type,
+			organizationId,
+			customerId,
+			invalidated: await invalidate(input)
+		});
+	});
+	const priceOf = (choice) => {
+		const given = choice.price;
+		if (given !== void 0) return AsyncResult.from(() => Promise.resolve(ok(given)));
+		if (choice.plan === void 0) return AsyncResult.from(() => Promise.resolve(err(dbError("invalid_input", "Pass a price or a plan", { hint: "BILLING_PRICE_REQUIRED" }))));
+		const plan = choice.plan;
+		return call("billing_plan_price", {
+			plan,
+			billing_interval: choice.interval,
+			variant: choice.variant
+		}, optionalText).andThen((price) => Promise.resolve(price === void 0 ? err(dbError("not_found", `No price for plan "${plan}"`, { hint: "BILLING_PLAN_UNKNOWN" })) : ok(price)));
+	};
+	const missing = (what) => err(dbError("invalid_request", `The Stripe client has no ${what}`, { hint: "BILLING_STRIPE_CLIENT" }));
+	const subscription = (organizationId) => call("billing_subscription_item", { tenant: organizationId }, subscriptionItemOf).andThen((found) => Promise.resolve(found === void 0 ? err(dbError("not_found", "This tenant has no active subscription", { hint: "BILLING_NO_SUBSCRIPTION" })) : ok(found)));
+	const rows = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+	const tenantRows = (key) => (value) => rows(value).flatMap((entry) => {
+		const row = entry[key];
+		return isRecord(row) ? [{
+			organizationId: textOf(entry["tenant"]),
+			customerId: textOf(entry["customer"]),
+			row
+		}] : [];
+	});
+	const platformArgs = (list = {}) => ({
+		for_status: list.status,
+		max_rows: list.limit ?? 100,
+		before_created: pageOf(list).cursor
+	});
+	const invoices = (organizationId, list = {}) => call("billing_invoices", {
+		tenant: organizationId,
+		max_rows: list.limit ?? 50
+	}, rows);
+	const ownInvoice = (organizationId, invoiceId) => invoices(organizationId, { limit: 500 }).andThen((list) => Promise.resolve(list.some((row) => row["id"] === invoiceId) ? ok(invoiceId) : err(dbError("not_found", "This tenant has no such invoice", { hint: "BILLING_INVOICE_NOT_FOUND" }))));
+	return {
+		customer,
+		ensureCustomer,
+		changePlan: (organizationId, change) => priceOf(change).andThen((price) => subscription(organizationId).andThen(async (found) => {
+			const updated = await withStripe(async (client) => client.subscriptions.update?.(found.subscriptionId, {
+				items: [{
+					id: found.itemId,
+					price
+				}],
+				proration_behavior: change.prorationBehavior ?? "create_prorations",
+				...change.resume === false ? {} : { cancel_at_period_end: false }
+			}, change.idempotencyKey === void 0 ? void 0 : { idempotencyKey: change.idempotencyKey }));
+			if (!updated.ok) return updated;
+			if (updated.data === void 0) return missing("subscriptions.update");
+			emit("billing.subscription_updated", {
+				organizationId,
+				subscriptionId: found.subscriptionId
+			});
+			return ok({
+				...found,
+				price
+			});
+		})),
+		cancelAtPeriodEnd: (organizationId, cancel) => subscription(organizationId).andThen(async (found) => {
+			const updated = await withStripe(async (client) => client.subscriptions.update?.(found.subscriptionId, { cancel_at_period_end: cancel }));
+			if (!updated.ok) return updated;
+			return updated.data === void 0 ? missing("subscriptions.update") : ok(updated.data.id);
+		}),
+		invoices,
+		paymentMethods: (organizationId) => call("billing_payment_methods", { tenant: organizationId }, rows),
+		voidInvoice: (organizationId, invoiceId) => ownInvoice(organizationId, invoiceId).andThen(async () => {
+			const voided = await withStripe(async (client) => client.invoices?.voidInvoice(invoiceId));
+			if (!voided.ok) return voided;
+			return voided.data === void 0 ? missing("invoices.voidInvoice") : ok(voided.data.id);
+		}),
+		markInvoiceUncollectible: (organizationId, invoiceId) => ownInvoice(organizationId, invoiceId).andThen(async () => {
+			const marked = await withStripe(async (client) => client.invoices?.markUncollectible(invoiceId));
+			if (!marked.ok) return marked;
+			return marked.data === void 0 ? missing("invoices.markUncollectible") : ok(marked.data.id);
+		}),
+		customerDetails: (organizationId) => call("billing_customer_details", { tenant: organizationId }, (value) => isRecord(value) ? value : void 0),
+		taxIds: (organizationId, taxOptions = {}) => taxOptions.from === "sync" ? call("billing_tax_ids", { tenant: organizationId }, (value) => Array.isArray(value) ? value.filter(isRecord).map(syncedTaxId) : []) : customer(organizationId).andThen(async (customerId) => {
+			if (customerId === void 0) return ok([]);
+			const listed = await withStripe(async (client) => client.customers.listTaxIds?.(customerId, { limit: 100 }));
+			if (!listed.ok) return listed;
+			return listed.data === void 0 ? missing("customers.listTaxIds") : ok(listed.data.data);
+		}),
+		addTaxId: (organizationId, taxId) => ensureCustomer(organizationId).andThen(async (customerId) => {
+			const created = await withStripe(async (client) => client.customers.createTaxId?.(customerId, {
+				type: taxId.type,
+				value: taxId.value
+			}));
+			if (!created.ok) return created;
+			return created.data === void 0 ? missing("customers.createTaxId") : ok(created.data);
+		}),
+		removeTaxId: (organizationId, taxId) => customer(organizationId).andThen(async (customerId) => {
+			if (customerId === void 0) return err(dbError("not_found", "This tenant has no Stripe customer yet", { hint: "BILLING_NO_CUSTOMER" }));
+			const deleted = await withStripe(async (client) => client.customers.deleteTaxId?.(customerId, taxId));
+			if (!deleted.ok) return deleted;
+			return deleted.data === void 0 ? missing("customers.deleteTaxId") : ok(deleted.data.id);
+		}),
+		updateCustomer: (organizationId, update) => ensureCustomer(organizationId).andThen(async (customerId) => {
+			const updated = await withStripe(async (client) => client.customers.update?.(customerId, {
+				...update.email === void 0 ? {} : { email: update.email },
+				...update.name === void 0 ? {} : { name: update.name },
+				...update.phone === void 0 ? {} : { phone: update.phone },
+				...update.address === void 0 ? {} : { address: update.address },
+				...update.params
+			}));
+			if (!updated.ok) return updated;
+			return updated.data === void 0 ? missing("customers.update") : ok(updated.data.id);
+		}),
+		checkout: (organizationId, checkout) => priceOf(checkout).andThen((price) => ensureCustomer(organizationId, checkout).andThen(async (customerId) => {
+			const quantity = checkout.quantity === "seats" ? await seats(organizationId) : ok(checkout.quantity ?? 1);
+			if (!quantity.ok) return quantity;
+			const lineItems = [{
+				price,
+				quantity: quantity.data
+			}];
+			for (const extra of checkout.items ?? []) {
+				const extraPrice = await priceOf(extra);
+				if (!extraPrice.ok) return extraPrice;
+				lineItems.push({
+					price: extraPrice.data,
+					quantity: extra.quantity ?? 1
+				});
+			}
+			const mode = checkout.mode ?? "subscription";
+			return withStripe(async (client) => {
+				const params = checkoutParams({
+					customer: customerId,
+					mode,
+					client_reference_id: organizationId,
+					line_items: lineItems,
+					success_url: checkout.successUrl,
+					...checkout.cancelUrl === void 0 ? {} : { cancel_url: checkout.cancelUrl }
+				}, checkout.params, organizationId, customerId);
+				const session = await client.checkout.sessions.create(params, checkout.idempotencyKey === void 0 ? void 0 : { idempotencyKey: checkout.idempotencyKey });
+				return {
+					id: session.id,
+					url: session.url ?? void 0
+				};
+			});
+		})),
+		portal: (organizationId, portal) => customer(organizationId).andThen(async (customerId) => {
+			if (customerId === void 0) return err(dbError("not_found", "This tenant has no Stripe customer yet", { hint: "BILLING_NO_CUSTOMER" }));
+			return withStripe(async (client) => {
+				return { url: (await client.billingPortal.sessions.create({
+					customer: customerId,
+					return_url: portal.returnUrl
+				})).url };
+			});
+		}),
+		status: (organizationId) => call("billing_status", { tenant: organizationId }, (value) => {
+			const row = recordOf(value, "billing_status");
+			return {
+				customerId: optionalText(row["customer"]),
+				seats: Number(row["seats"] ?? 0),
+				subscription: subscriptionItemOf(row["subscription"])
+			};
+		}),
+		syncSeats,
+		subscription: (organizationId) => call("billing_subscription", { tenant: organizationId }, (value) => isRecord(value) ? value : void 0),
+		allInvoices: (list) => call("billing_all_invoices", platformArgs(list), tenantRows("invoice")),
+		allCustomers: () => call("billing_all_customers", {}, (value) => (Array.isArray(value) ? value : []).filter(isRecord).map((row) => ({
+			organizationId: textOf(row["tenant"]),
+			customerId: textOf(row["customer"]),
+			email: optionalText(row["email"]),
+			name: optionalText(row["name"]),
+			created: optionalInstant(row["created"])
+		}))),
+		allSubscriptions: (list) => call("billing_all_subscriptions", platformArgs(list), tenantRows("subscription")),
+		cancelSubscription: (organizationId) => item(organizationId).andThen(async (found) => {
+			if (found === void 0) return ok(void 0);
+			const cancelled = await withStripe((client) => client.subscriptions.cancel(found.subscriptionId));
+			return cancelled.ok ? ok(cancelled.data.id) : cancelled;
+		}),
+		seatSink: () => ({ async send(events) {
+			const latest = /* @__PURE__ */ new Map();
+			for (const event of events) {
+				const tenant = optionalText(event["partitionkey"]);
+				if (tenant !== void 0 && SEAT_EVENT.test(event.type)) latest.set(tenant, event.id);
+			}
+			for (const [tenant, id] of latest) await syncSeats(tenant, { key: id }).orThrow();
+		} }),
+		handleStripeEvent
+	};
+}
+//#endregion
+export { createBilling, rpcTransport, signStripeWebhook, sqlTransport, stripeInboxVerify, verifyStripeWebhook };