@revojs/billing 0.2.45 → 0.2.47

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+import { type Resolvable, type Scope, type Source, type SourceScope, type SourceValue } from "revojs";
+import type { Awaitable } from "revojs/shared";
+export type SubscriptionStatus = "incomplete" | "expired" | "trialing" | "active" | "past_due" | "canceled" | "unpaid" | "paused";
+export interface Customer {
+    id: string;
+    provider: string;
+    externalId: string;
+    reference: string;
+    email: string;
+    createdAt: Date;
+}
+export interface Subscription {
+    id: string;
+    provider: string;
+    externalId: string;
+    status: SubscriptionStatus;
+    price: string;
+    quantity: number;
+    currentPeriodEnd: Date;
+    cancelAtPeriodEnd: boolean;
+    updatedAt: Date;
+    createdAt: Date;
+    customerId: string;
+}
+export type SubscriptionValues = Pick<Subscription, "status" | "price" | "quantity" | "currentPeriodEnd" | "cancelAtPeriodEnd">;
+export interface BillingStorage {
+    getCustomerByReference: (provider: string, reference: string) => Promise<Customer | undefined>;
+    getCustomerByExternalId: (provider: string, externalId: string) => Promise<Customer | undefined>;
+    createCustomer: (customer: Pick<Customer, "provider" | "externalId" | "reference" | "email">) => Promise<void>;
+    getSubscriptionByExternalId: (provider: string, externalId: string) => Promise<Subscription | undefined>;
+    getSubscriptions: (customerId: string) => Promise<Array<Subscription>>;
+    createSubscription: (subscription: SubscriptionValues & Pick<Subscription, "provider" | "externalId" | "customerId">) => Promise<void>;
+    updateSubscription: (id: string, values: SubscriptionValues) => Promise<void>;
+}
+export type CheckoutItem = {
+    price: string;
+    quantity?: number;
+} | {
+    name: string;
+    amount: number;
+    currency: string;
+    quantity?: number;
+};
+export interface CheckoutOptions {
+    reference: string;
+    email: string;
+    name?: string;
+    mode: "payment" | "subscription";
+    items: Array<CheckoutItem>;
+    successUrl: string;
+    cancelUrl: string;
+    metadata?: Record<string, string>;
+}
+export interface Checkout {
+    id: string;
+    provider: string;
+    paid: boolean;
+    reference: string | null;
+    customer: string | null;
+    subscription: string | null;
+    amount: number | null;
+    currency: string | null;
+    metadata: Record<string, string>;
+}
+export interface ProviderSubscription extends SubscriptionValues {
+    id: string;
+    customer: string;
+}
+export interface BillingEvent {
+    id: string;
+    provider: string;
+    type: string;
+    checkout?: string;
+    subscription?: string;
+    data: unknown;
+}
+export interface BillingProvider {
+    createCustomer: (input: {
+        reference: string;
+        email: string;
+        name?: string;
+    }) => Promise<{
+        id: string;
+    }>;
+    createCheckout: (input: Omit<CheckoutOptions, "email" | "name"> & {
+        customer: string;
+    }) => Promise<{
+        id: string;
+        url: string;
+    }>;
+    createPortal: (input: {
+        customer: string;
+        returnUrl: string;
+    }) => Promise<{
+        url: string;
+    }>;
+    getCheckout: (id: string) => Promise<Omit<Checkout, "provider">>;
+    getSubscription: (id: string) => Promise<ProviderSubscription>;
+    receiveWebhook: (request: Request) => Promise<Omit<BillingEvent, "provider"> | undefined>;
+}
+export declare class Billing {
+    readonly name: string;
+    readonly provider: BillingProvider;
+    protected $scope: Scope;
+    constructor(scope: Scope, name: string, provider: BillingProvider);
+    ensureCustomer(input: {
+        reference: string;
+        email: string;
+        name?: string;
+    }): Promise<Customer>;
+    getCustomer(reference: string): Promise<Customer | undefined>;
+    createCheckout(options: CheckoutOptions): Promise<{
+        id: string;
+        url: string;
+    }>;
+    createPortal(options: {
+        reference: string;
+        returnUrl: string;
+    }): Promise<{
+        url: string;
+    }>;
+    getSubscriptions(reference: string): Promise<Subscription[]>;
+    syncSubscription(externalId: string): Promise<Subscription | undefined>;
+    handleWebhook(request: Request): Promise<boolean>;
+}
+export declare function useBillingStorage(scope: Scope): Promise<BillingStorage>;
+export declare function useBillingContext(scope: Scope): Record<string, Record<string, Billing>>;
+export declare function useBilling<TSource extends Source<Resolvable<Awaitable<BillingProvider>>> = typeof import("#billing").default, TScope extends SourceScope<TSource> = SourceScope<TSource>>(scope: Scope, scopeName: TScope): Record<SourceValue<TSource, TScope>, Billing>;
+export declare function findBilling(scope: Scope, name: string): Billing;
+export declare const BILLING_CONTEXT: import("revojs").Descriptor<Record<string, Record<string, Billing>>>;
+export declare const CHECKOUT_PAID_HOOK: import("revojs").Descriptor<import("revojs").Hook<Readonly<Checkout>, Awaitable<void>>>;
+export declare const SUBSCRIPTION_UPDATED_HOOK: import("revojs").Descriptor<import("revojs").Hook<Readonly<Subscription>, Awaitable<void>>>;
+export declare const BILLING_EVENT_HOOK: import("revojs").Descriptor<import("revojs").Hook<Readonly<BillingEvent>, Awaitable<void>>>;

package/dist/index.js

@@ -0,0 +1,133 @@
+import { useStorageProvider } from "@revojs/storage";
+import { defineContext, defineHook, dispatchHook, getContext, setContext } from "revojs";
+//#region src/index.ts
+var Billing = class {
+	name;
+	provider;
+	$scope;
+	constructor(scope, name, provider) {
+		this.$scope = scope;
+		this.name = name;
+		this.provider = provider;
+	}
+	async ensureCustomer(input) {
+		const storage = await useBillingStorage(this.$scope);
+		const existing = await storage.getCustomerByReference(this.name, input.reference);
+		if (existing) return existing;
+		const customer = await this.provider.createCustomer(input);
+		try {
+			await storage.createCustomer({
+				provider: this.name,
+				externalId: customer.id,
+				reference: input.reference,
+				email: input.email
+			});
+		} catch (error) {
+			const concurrent = await storage.getCustomerByReference(this.name, input.reference);
+			if (concurrent) return concurrent;
+			throw error;
+		}
+		const created = await storage.getCustomerByReference(this.name, input.reference);
+		if (!created) throw new Error(`The ${this.name} customer for reference "${input.reference}" could not be stored.`);
+		return created;
+	}
+	async getCustomer(reference) {
+		return (await useBillingStorage(this.$scope)).getCustomerByReference(this.name, reference);
+	}
+	async createCheckout(options) {
+		const customer = await this.ensureCustomer(options);
+		return this.provider.createCheckout({
+			customer: customer.externalId,
+			reference: options.reference,
+			mode: options.mode,
+			items: options.items,
+			successUrl: options.successUrl,
+			cancelUrl: options.cancelUrl,
+			metadata: options.metadata
+		});
+	}
+	async createPortal(options) {
+		const customer = await this.getCustomer(options.reference);
+		if (!customer) throw new Error(`No ${this.name} customer exists for reference "${options.reference}".`);
+		return this.provider.createPortal({
+			customer: customer.externalId,
+			returnUrl: options.returnUrl
+		});
+	}
+	async getSubscriptions(reference) {
+		const storage = await useBillingStorage(this.$scope);
+		const customer = await storage.getCustomerByReference(this.name, reference);
+		if (!customer) return [];
+		return storage.getSubscriptions(customer.id);
+	}
+	async syncSubscription(externalId) {
+		const subscription = await this.provider.getSubscription(externalId);
+		const storage = await useBillingStorage(this.$scope);
+		const customer = await storage.getCustomerByExternalId(this.name, subscription.customer);
+		if (!customer) return;
+		const values = {
+			status: subscription.status,
+			price: subscription.price,
+			quantity: subscription.quantity,
+			currentPeriodEnd: subscription.currentPeriodEnd,
+			cancelAtPeriodEnd: subscription.cancelAtPeriodEnd
+		};
+		const existing = await storage.getSubscriptionByExternalId(this.name, subscription.id);
+		await (existing ? storage.updateSubscription(existing.id, values) : storage.createSubscription({
+			provider: this.name,
+			externalId: subscription.id,
+			customerId: customer.id,
+			...values
+		}));
+		return storage.getSubscriptionByExternalId(this.name, subscription.id);
+	}
+	async handleWebhook(request) {
+		const received = await this.provider.receiveWebhook(request);
+		if (!received) return false;
+		const event = {
+			...received,
+			provider: this.name
+		};
+		if (event.checkout) {
+			const checkout = await this.provider.getCheckout(event.checkout);
+			if (checkout.paid) await dispatchHook(this.$scope, CHECKOUT_PAID_HOOK, {
+				...checkout,
+				provider: this.name
+			});
+		}
+		if (event.subscription) {
+			const subscription = await this.syncSubscription(event.subscription);
+			if (subscription) await dispatchHook(this.$scope, SUBSCRIPTION_UPDATED_HOOK, subscription);
+		}
+		await dispatchHook(this.$scope, BILLING_EVENT_HOOK, event);
+		return true;
+	}
+};
+async function useBillingStorage(scope) {
+	return useStorageProvider(scope, await Promise.all([
+		import("./storage/sqlite.js"),
+		import("./storage/postgresql.js"),
+		import("./storage/mysql.js")
+	]), (provider) => provider.billingSchema).useBillingStorage(scope);
+}
+function useBillingContext(scope) {
+	return getContext(scope, BILLING_CONTEXT);
+}
+function useBilling(scope, scopeName) {
+	const billings = useBillingContext(scope);
+	const billing = billings[scopeName] ?? {};
+	billings[scopeName] = billing;
+	setContext(scope, BILLING_CONTEXT, billings);
+	return billing;
+}
+function findBilling(scope, name) {
+	const matches = Object.values(useBillingContext(scope)).map((entries) => entries[name]).filter((billing) => billing !== void 0);
+	if (matches.length > 1) throw new Error(`The billing provider name "${name}" is defined in more than one package.`);
+	return matches[0];
+}
+var BILLING_CONTEXT = defineContext("BILLING_CONTEXT");
+var CHECKOUT_PAID_HOOK = defineHook("CHECKOUT_PAID_HOOK");
+var SUBSCRIPTION_UPDATED_HOOK = defineHook("SUBSCRIPTION_UPDATED_HOOK");
+var BILLING_EVENT_HOOK = defineHook("BILLING_EVENT_HOOK");
+//#endregion
+export { BILLING_CONTEXT, BILLING_EVENT_HOOK, Billing, CHECKOUT_PAID_HOOK, SUBSCRIPTION_UPDATED_HOOK, findBilling, useBilling, useBillingContext, useBillingStorage };

package/dist/module/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("revojs/module").Module<"billing", Record<string, never>, readonly [import("revojs/module").Module<"server", Record<string, never>, []>]>;
+export default _default;

package/dist/module/index.js

@@ -0,0 +1,26 @@
+import server, { addRoutes } from "@revojs/server/module";
+import { defineModule, useModule } from "revojs/module";
+//#region src/module/index.ts
+var module_default = defineModule({
+	name: "billing",
+	modules: [server],
+	setup(config) {
+		const { fromModule } = useModule(import.meta.url);
+		addRoutes(config, fromModule("../routes"));
+		return { sources: {
+			billing: {
+				from: ["./billing"],
+				match: [
+					"**/*.js",
+					"**/*.ts",
+					"!**/*.d.ts"
+				],
+				format: "object",
+				consumers: ["server"]
+			},
+			plugins: { from: [fromModule("../plugins")] }
+		} };
+	}
+});
+//#endregion
+export { module_default as default };

package/dist/plugins/index.server.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    setup(scope: import("revojs").Scope): Promise<void>;
+};
+export default _default;

package/dist/plugins/index.server.js

@@ -0,0 +1,17 @@
+import { BILLING_CONTEXT, Billing, useBillingContext } from "../index.js";
+import { definePlugin, setContext } from "revojs";
+//#region src/plugins/index.server.ts
+var index_server_default = definePlugin({ async setup(scope) {
+	const billings = useBillingContext(scope);
+	for (const [scopeName, files] of Object.entries((await import("#billing")).default)) {
+		const entries = billings[scopeName] ?? {};
+		for (const [name, resolve] of Object.entries(files)) {
+			if (entries[name]) continue;
+			entries[name] = new Billing(scope, name, await (await resolve())(scope));
+		}
+		billings[scopeName] = entries;
+	}
+	setContext(scope, BILLING_CONTEXT, billings);
+} });
+//#endregion
+export { index_server_default as default };

package/dist/providers/stripe.d.ts

@@ -0,0 +1,68 @@
+import type { BillingEvent, BillingProvider, SubscriptionStatus } from "../index";
+export type StripeParameter = string | number | boolean | null | undefined | Array<StripeParameter> | {
+    [key: string]: StripeParameter;
+};
+export interface StripeOptions {
+    secretKey: string;
+    webhookSecret: string;
+    tolerance?: number;
+}
+export interface StripeRequestOptions {
+    parameters?: Record<string, StripeParameter>;
+    idempotencyKey?: string;
+}
+export interface StripeEvent {
+    id: string;
+    type: string;
+    created: number;
+    livemode: boolean;
+    data: {
+        object: {
+            id?: string;
+            object?: string;
+        } & Record<string, unknown>;
+    };
+}
+export interface StripeCheckoutSession {
+    id: string;
+    mode: "payment" | "subscription" | "setup";
+    status: "open" | "complete" | "expired" | null;
+    payment_status: "paid" | "unpaid" | "no_payment_required";
+    client_reference_id: string | null;
+    customer: string | null;
+    subscription: string | null;
+    amount_total: number | null;
+    currency: string | null;
+    metadata: Record<string, string> | null;
+    url: string | null;
+}
+export interface StripeSubscription {
+    id: string;
+    status: Exclude<SubscriptionStatus, "expired"> | "incomplete_expired";
+    customer: string;
+    cancel_at_period_end: boolean;
+    items: {
+        data: Array<{
+            price: {
+                id: string;
+            };
+            quantity?: number;
+            current_period_end: number;
+        }>;
+    };
+}
+export declare class StripeError extends Error {
+    status: number;
+    code: string | undefined;
+    type: string | undefined;
+    constructor(message: string, status: number, code?: string, type?: string);
+}
+export declare function toStripeForm(parameters: Record<string, StripeParameter>): URLSearchParams;
+export declare function requestStripe<T>(secretKey: string, method: "GET" | "POST" | "DELETE", path: string, options?: StripeRequestOptions): Promise<T>;
+export declare function verifyStripeSignature(payload: string, header: string | null, secret: string, tolerance: number, now?: number): Promise<boolean>;
+export declare function toStripeEvent(event: StripeEvent): Omit<BillingEvent, "provider">;
+export declare function stripe(options: StripeOptions): BillingProvider;
+export declare const STRIPE_API_URL = "https://api.stripe.com/";
+export declare const STRIPE_API_VERSION = "2025-03-31.basil";
+export declare const STRIPE_CHECKOUT_EVENTS: Set<string>;
+export declare const STRIPE_SUBSCRIPTION_EVENTS: Set<string>;

package/dist/providers/stripe.js

@@ -0,0 +1,194 @@
+import { equalsConstantTime } from "revojs";
+//#region src/providers/stripe.ts
+var StripeError = class extends Error {
+	status;
+	code;
+	type;
+	constructor(message, status, code, type) {
+		super(message);
+		this.name = "StripeError";
+		this.status = status;
+		this.code = code;
+		this.type = type;
+	}
+};
+function toStripeForm(parameters) {
+	const form = new URLSearchParams();
+	const append = (key, value) => {
+		if (value === void 0) return;
+		if (value === null) {
+			form.append(key, "");
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const [index, item] of value.entries()) append(`${key}[${index}]`, item);
+			return;
+		}
+		if (typeof value === "object") {
+			for (const [name, item] of Object.entries(value)) append(`${key}[${name}]`, item);
+			return;
+		}
+		form.append(key, String(value));
+	};
+	for (const [key, value] of Object.entries(parameters)) append(key, value);
+	return form;
+}
+async function requestStripe(secretKey, method, path, options = {}) {
+	const url = new URL(path, STRIPE_API_URL);
+	const headers = new Headers({
+		authorization: `Bearer ${secretKey}`,
+		"stripe-version": STRIPE_API_VERSION
+	});
+	if (options.idempotencyKey) headers.set("idempotency-key", options.idempotencyKey);
+	const form = toStripeForm(options.parameters ?? {});
+	const init = {
+		method,
+		headers,
+		redirect: "manual"
+	};
+	if (method === "GET") url.search = form.toString();
+	else init.body = form;
+	const response = await fetch(url, init);
+	const result = await response.json().catch(() => void 0);
+	if (!response.ok) {
+		const error = result?.error;
+		throw new StripeError(`Stripe rejected ${method} ${url.pathname} with HTTP ${response.status}: ${error?.message ?? response.statusText}`, response.status, error?.code, error?.type);
+	}
+	return result;
+}
+async function verifyStripeSignature(payload, header, secret, tolerance, now = Date.now()) {
+	if (!header) return false;
+	let timestamp;
+	const signatures = new Array();
+	for (const part of header.split(",")) {
+		const separator = part.indexOf("=");
+		const key = part.slice(0, separator).trim();
+		const value = part.slice(separator + 1).trim();
+		if (separator === -1 || !value) continue;
+		if (key === "t") timestamp = Number(value);
+		if (key === "v1") signatures.push(value);
+	}
+	if (timestamp === void 0 || !Number.isInteger(timestamp) || signatures.length === 0) return false;
+	if (Math.abs(now / 1e3 - timestamp) > tolerance) return false;
+	const encoder = new TextEncoder();
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const digest = await crypto.subtle.sign("HMAC", key, encoder.encode(`${timestamp}.${payload}`));
+	const expected = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return signatures.some((signature) => equalsConstantTime(signature, expected));
+}
+function toStripeEvent(event) {
+	const id = event.data.object.id;
+	return {
+		id: event.id,
+		type: event.type,
+		checkout: id && STRIPE_CHECKOUT_EVENTS.has(event.type) ? id : void 0,
+		subscription: id && STRIPE_SUBSCRIPTION_EVENTS.has(event.type) ? id : void 0,
+		data: event
+	};
+}
+function stripe(options) {
+	return {
+		async createCustomer(input) {
+			return requestStripe(options.secretKey, "POST", "/v1/customers", {
+				parameters: {
+					email: input.email,
+					name: input.name,
+					metadata: { reference: input.reference }
+				},
+				idempotencyKey: `customer:${input.reference}`
+			});
+		},
+		async createCheckout(input) {
+			const session = await requestStripe(options.secretKey, "POST", "/v1/checkout/sessions", { parameters: {
+				mode: input.mode,
+				customer: input.customer,
+				client_reference_id: input.reference,
+				success_url: input.successUrl,
+				cancel_url: input.cancelUrl,
+				line_items: input.items.map(toLineItem),
+				metadata: input.metadata,
+				billing_address_collection: "required",
+				tax_id_collection: { enabled: true },
+				customer_update: {
+					address: "auto",
+					name: "auto"
+				},
+				invoice_creation: input.mode === "payment" ? { enabled: true } : void 0,
+				payment_intent_data: input.mode === "payment" ? { metadata: input.metadata } : void 0,
+				subscription_data: input.mode === "subscription" ? { metadata: input.metadata } : void 0
+			} });
+			if (!session.url) throw new Error(`Stripe returned checkout session ${session.id} without a URL.`);
+			return {
+				id: session.id,
+				url: session.url
+			};
+		},
+		async createPortal(input) {
+			return { url: (await requestStripe(options.secretKey, "POST", "/v1/billing_portal/sessions", { parameters: {
+				customer: input.customer,
+				return_url: input.returnUrl
+			} })).url };
+		},
+		async getCheckout(id) {
+			const session = await requestStripe(options.secretKey, "GET", `/v1/checkout/sessions/${encodeURIComponent(id)}`);
+			return {
+				id: session.id,
+				paid: session.payment_status === "paid" || session.payment_status === "no_payment_required",
+				reference: session.client_reference_id,
+				customer: session.customer,
+				subscription: session.subscription,
+				amount: session.amount_total,
+				currency: session.currency,
+				metadata: session.metadata ?? {}
+			};
+		},
+		async getSubscription(id) {
+			const subscription = await requestStripe(options.secretKey, "GET", `/v1/subscriptions/${encodeURIComponent(id)}`);
+			const [item] = subscription.items.data;
+			if (!item) throw new Error(`Stripe subscription ${subscription.id} has no items.`);
+			return {
+				id: subscription.id,
+				customer: subscription.customer,
+				status: subscription.status === "incomplete_expired" ? "expired" : subscription.status,
+				price: item.price.id,
+				quantity: item.quantity ?? 1,
+				currentPeriodEnd: /* @__PURE__ */ new Date(item.current_period_end * 1e3),
+				cancelAtPeriodEnd: subscription.cancel_at_period_end
+			};
+		},
+		async receiveWebhook(request) {
+			const payload = await request.text();
+			if (!await verifyStripeSignature(payload, request.headers.get("stripe-signature"), options.webhookSecret, options.tolerance ?? 300)) return;
+			return toStripeEvent(JSON.parse(payload));
+		}
+	};
+}
+function toLineItem(item) {
+	if ("price" in item) return {
+		price: item.price,
+		quantity: item.quantity ?? 1
+	};
+	return {
+		price_data: {
+			currency: item.currency,
+			unit_amount: item.amount,
+			product_data: { name: item.name }
+		},
+		quantity: item.quantity ?? 1
+	};
+}
+var STRIPE_API_URL = "https://api.stripe.com/";
+var STRIPE_API_VERSION = "2025-03-31.basil";
+var STRIPE_CHECKOUT_EVENTS = /* @__PURE__ */ new Set(["checkout.session.completed", "checkout.session.async_payment_succeeded"]);
+var STRIPE_SUBSCRIPTION_EVENTS = /* @__PURE__ */ new Set([
+	"customer.subscription.created",
+	"customer.subscription.updated",
+	"customer.subscription.deleted",
+	"customer.subscription.paused",
+	"customer.subscription.resumed"
+]);
+//#endregion
+export { STRIPE_API_URL, STRIPE_API_VERSION, STRIPE_CHECKOUT_EVENTS, STRIPE_SUBSCRIPTION_EVENTS, StripeError, requestStripe, stripe, toStripeEvent, toStripeForm, verifyStripeSignature };

package/dist/routes/billing/[provider]/post.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(scope: import("revojs").Scope): Promise<Response>;
+};
+export default _default;

package/dist/routes/billing/[provider]/post.js

@@ -0,0 +1,13 @@
+import { findBilling } from "../../../index.js";
+import { defineRoute, sendBadRequest, sendNotFound, sendOk, useParameters, useServer } from "@revojs/server";
+//#region src/routes/billing/[provider]/post.ts
+var post_default = defineRoute({ async fetch(scope) {
+	const { provider } = useParameters(scope);
+	const { request } = useServer(scope);
+	const billing = provider ? findBilling(scope, provider) : void 0;
+	if (!billing) return sendNotFound(scope);
+	if (!await billing.handleWebhook(request)) return sendBadRequest(scope);
+	return sendOk(scope);
+} });
+//#endregion
+export { post_default as default };