@dineway-ai/plugin-payment 0.2.6 → 0.2.7

package/src/database/migrations/003_purchases.ts

@@ -0,0 +1,193 @@
+import { sql, type Kysely } from "kysely";
+
+import { up as subscriptionSchema, down as removeSubscriptionSchema } from "./002_subscriptions.js";
+import { schemaExists } from "./adoption.js";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (
+		await schemaExists(
+			db,
+			{
+				payment_subscription_purchases: [
+					"scope",
+					"id",
+					"user_id",
+					"group_key",
+					"contract",
+					"fingerprint",
+					"created_at",
+					"expires_at",
+					"session_id",
+					"subscription_id",
+					"closed",
+					"cancel_mode",
+					"last_attempt_at",
+					"last_error",
+				],
+				payment_subscription_changes: [
+					"scope",
+					"id",
+					"subscription_id",
+					"revision",
+					"snapshot",
+					"created_at",
+					"acknowledged_at",
+				],
+			},
+			{
+				payment_subscription_customers: ["subject"],
+				payment_member_subscriptions: ["purchase_reference", "revision", "sync_attempted_at"],
+				payment_subscription_periods: ["eligible", "evidence"],
+				payment_subscription_events: [
+					"digest",
+					"event_type",
+					"object_type",
+					"object_id",
+					"subscription_id",
+					"last_error",
+					"payload",
+					"processed_at",
+					"last_attempt_at",
+				],
+			},
+		)
+	)
+		return;
+	await db.schema
+		.alterTable("payment_subscription_customers")
+		.addColumn("subject", "text")
+		.execute();
+	await sql`CREATE TABLE payment_subscription_purchases (
+		scope TEXT NOT NULL, id TEXT NOT NULL, user_id TEXT NOT NULL,
+		group_key TEXT NOT NULL, contract TEXT NOT NULL, fingerprint TEXT NOT NULL,
+		created_at INTEGER NOT NULL, expires_at INTEGER NOT NULL,
+		session_id TEXT, subscription_id TEXT, closed INTEGER NOT NULL DEFAULT 0,
+		cancel_mode TEXT, last_attempt_at INTEGER, last_error TEXT,
+		PRIMARY KEY (scope, id),
+		FOREIGN KEY (scope, user_id) REFERENCES payment_subscription_customers(scope, id)
+	)`.execute(db);
+	await sql`CREATE UNIQUE INDEX idx_payment_purchase_open_group ON payment_subscription_purchases(scope, user_id, group_key) WHERE closed = 0`.execute(
+		db,
+	);
+	await sql`CREATE UNIQUE INDEX idx_payment_purchase_session ON payment_subscription_purchases(scope, session_id) WHERE session_id IS NOT NULL`.execute(
+		db,
+	);
+	await sql`CREATE UNIQUE INDEX idx_payment_purchase_subscription ON payment_subscription_purchases(scope, subscription_id) WHERE subscription_id IS NOT NULL`.execute(
+		db,
+	);
+	await sql`CREATE INDEX idx_payment_purchase_recovery ON payment_subscription_purchases(scope, last_attempt_at, id)`.execute(
+		db,
+	);
+
+	// Dynamic prices are verified against their immutable purchase contract, not the plan catalogue.
+	await sql`CREATE TABLE _payment_periods_121 AS SELECT * FROM payment_subscription_periods`.execute(
+		db,
+	);
+	await db.schema.dropTable("payment_subscription_periods").execute();
+	await sql`CREATE TABLE _payment_subscriptions_121 (
+		scope TEXT NOT NULL, id TEXT NOT NULL, user_id TEXT NOT NULL, customer_id TEXT NOT NULL,
+		plan_code TEXT NOT NULL, price_id TEXT NOT NULL, status TEXT NOT NULL,
+		period_end INTEGER NOT NULL, cancel_at_period_end INTEGER NOT NULL,
+		verified_at INTEGER NOT NULL, last_error TEXT,
+		purchase_reference TEXT, revision INTEGER NOT NULL DEFAULT 0, sync_attempted_at INTEGER NOT NULL DEFAULT 0,
+		PRIMARY KEY (scope, id),
+		FOREIGN KEY (scope, user_id) REFERENCES payment_subscription_customers(scope, id)
+	)`.execute(db);
+	await sql`INSERT INTO _payment_subscriptions_121 (scope,id,user_id,customer_id,plan_code,price_id,status,period_end,cancel_at_period_end,verified_at,last_error)
+		SELECT scope,id,user_id,customer_id,plan_code,price_id,status,period_end,cancel_at_period_end,verified_at,last_error FROM payment_member_subscriptions`.execute(
+		db,
+	);
+	await db.schema.dropTable("payment_member_subscriptions").execute();
+	await db.schema
+		.alterTable("_payment_subscriptions_121")
+		.renameTo("payment_member_subscriptions")
+		.execute();
+	for (const column of [
+		"user_id",
+		"price_id",
+		"purchase_reference",
+		"verified_at",
+		"sync_attempted_at",
+	]) {
+		await db.schema
+			.createIndex("idx_payment_subscription_" + column)
+			.on("payment_member_subscriptions")
+			.columns(["scope", column])
+			.execute();
+	}
+	await sql`CREATE TABLE payment_subscription_periods (
+		scope TEXT NOT NULL, id TEXT NOT NULL, subscription_id TEXT NOT NULL,
+		invoice_id TEXT NOT NULL, plan_code TEXT NOT NULL, starts_at INTEGER NOT NULL, ends_at INTEGER NOT NULL,
+		eligible INTEGER NOT NULL DEFAULT 0, evidence TEXT NOT NULL DEFAULT '{}',
+		PRIMARY KEY (scope,id), FOREIGN KEY (scope,subscription_id) REFERENCES payment_member_subscriptions(scope,id)
+	)`.execute(db);
+	await sql`INSERT INTO payment_subscription_periods (scope,id,subscription_id,invoice_id,plan_code,starts_at,ends_at)
+		SELECT scope,id,subscription_id,invoice_id,plan_code,starts_at,ends_at FROM _payment_periods_121`.execute(
+		db,
+	);
+	await db.schema.dropTable("_payment_periods_121").execute();
+	for (const column of ["subscription_id", "invoice_id"]) {
+		await db.schema
+			.createIndex("idx_payment_period_" + column)
+			.on("payment_subscription_periods")
+			.columns(["scope", column])
+			.execute();
+	}
+	for (const column of [
+		"digest",
+		"event_type",
+		"object_type",
+		"object_id",
+		"subscription_id",
+		"last_error",
+		"payload",
+	]) {
+		await db.schema.alterTable("payment_subscription_events").addColumn(column, "text").execute();
+	}
+	for (const column of ["processed_at", "last_attempt_at"]) {
+		await db.schema
+			.alterTable("payment_subscription_events")
+			.addColumn(column, "integer")
+			.execute();
+	}
+	await sql`UPDATE payment_subscription_events SET processed_at = received_at`.execute(db);
+	await sql`CREATE INDEX idx_payment_event_pending ON payment_subscription_events(scope, processed_at, last_attempt_at)`.execute(
+		db,
+	);
+	await sql`CREATE TABLE payment_subscription_changes (
+		scope TEXT NOT NULL, id TEXT NOT NULL, subscription_id TEXT NOT NULL,
+		revision INTEGER NOT NULL, snapshot TEXT NOT NULL, created_at INTEGER NOT NULL, acknowledged_at INTEGER,
+		PRIMARY KEY (scope,id), FOREIGN KEY (scope,subscription_id) REFERENCES payment_member_subscriptions(scope,id)
+	)`.execute(db);
+	await sql`CREATE INDEX idx_payment_change_pending ON payment_subscription_changes(scope, acknowledged_at, created_at, id)`.execute(
+		db,
+	);
+	await sql`CREATE INDEX idx_payment_change_subscription ON payment_subscription_changes(scope, subscription_id)`.execute(
+		db,
+	);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	for (const table of [
+		"payment_subscription_changes",
+		"payment_subscription_purchases",
+		"payment_subscription_plans",
+		"payment_subscription_prices",
+		"payment_subscription_customers",
+		"payment_member_subscriptions",
+		"payment_subscription_periods",
+		"payment_subscription_events",
+		"payment_subscription_attempts",
+		"payment_subscription_locks",
+		"payment_subscription_portals",
+	]) {
+		if ((await sql`SELECT 1 FROM ${sql.table(table)} LIMIT 1`.execute(db)).rows.length)
+			throw new Error(
+				"Restore a database snapshot to roll back populated payment tables; automatic rollback would discard payment evidence.",
+			);
+	}
+	await db.schema.dropTable("payment_subscription_changes").execute();
+	await db.schema.dropTable("payment_subscription_purchases").execute();
+	await removeSubscriptionSchema(db);
+	await subscriptionSchema(db);
+}

package/src/database/migrations/adoption.ts

@@ -0,0 +1,27 @@
+import type { Kysely } from "kysely";
+
+/** Adopt complete schemas installed by core; reject partial schemas without modifying their data. */
+export async function schemaExists(
+	db: Kysely<unknown>,
+	owned: Record<string, readonly string[]>,
+	additions: Record<string, readonly string[]> = {},
+): Promise<boolean> {
+	const tables = await db.introspection.getTables();
+	const names = new Map(
+		tables.map((table) => [table.name, new Set(table.columns.map((column) => column.name))]),
+	);
+	const checks: boolean[] = [];
+	for (const [name, columns] of Object.entries(owned)) {
+		checks.push(names.has(name), ...columns.map((column) => names.get(name)?.has(column) ?? false));
+	}
+	for (const [name, columns] of Object.entries(additions)) {
+		if (!names.has(name)) throw new Error(`Payment migration requires table ${name}`);
+		checks.push(...columns.map((column) => names.get(name)!.has(column)));
+	}
+	if (checks.every(Boolean)) return true;
+	if (checks.some(Boolean))
+		throw new Error(
+			"Payment schema is incomplete; restore or repair it before retrying migrations",
+		);
+	return false;
+}

package/src/database/types.ts

@@ -0,0 +1,137 @@
+import type { Database } from "dineway";
+import type { Generated } from "kysely";
+
+export interface PaymentSubscriptionKey {
+	scope: string;
+	id: string;
+}
+export type PaymentSubscriptionTables = {
+	payment_subscription_plans: PaymentSubscriptionPlanTable;
+	payment_subscription_prices: PaymentSubscriptionPriceTable;
+	payment_subscription_customers: PaymentSubscriptionCustomerTable;
+	payment_member_subscriptions: PaymentMemberSubscriptionTable;
+	payment_subscription_periods: PaymentSubscriptionPeriodTable;
+	payment_subscription_events: PaymentSubscriptionEventTable;
+	payment_subscription_attempts: PaymentSubscriptionAttemptTable;
+	payment_subscription_locks: PaymentSubscriptionLockTable;
+	payment_subscription_portals: PaymentSubscriptionPortalTable;
+	payment_subscription_purchases: PaymentSubscriptionPurchaseTable;
+	payment_subscription_changes: PaymentSubscriptionChangeTable;
+};
+export interface PaymentSubscriptionPlanTable extends PaymentSubscriptionKey {
+	name: string;
+	enabled: number;
+	entitlements: string;
+	version: number;
+}
+export interface PaymentSubscriptionPriceTable extends PaymentSubscriptionKey {
+	plan_code: string;
+	product_id: string;
+	currency: string;
+	amount: number;
+	interval: string;
+	enabled: number;
+}
+export interface PaymentSubscriptionCustomerTable extends PaymentSubscriptionKey {
+	customer_id: string;
+	subject: Generated<string | null>;
+}
+export interface PaymentMemberSubscriptionTable extends PaymentSubscriptionKey {
+	user_id: string;
+	customer_id: string;
+	plan_code: string;
+	price_id: string;
+	status: string;
+	period_end: number;
+	cancel_at_period_end: number;
+	verified_at: number;
+	last_error: string | null;
+	purchase_reference: Generated<string | null>;
+	revision: Generated<number>;
+	sync_attempted_at: Generated<number>;
+}
+export interface PaymentSubscriptionPeriodTable extends PaymentSubscriptionKey {
+	subscription_id: string;
+	invoice_id: string;
+	plan_code: string;
+	starts_at: number;
+	ends_at: number;
+	eligible: Generated<number>;
+	evidence: Generated<string>;
+}
+export interface PaymentSubscriptionEventTable extends PaymentSubscriptionKey {
+	received_at: number;
+	payload: Generated<string | null>;
+	digest: Generated<string | null>;
+	event_type: Generated<string | null>;
+	object_type: Generated<string | null>;
+	object_id: Generated<string | null>;
+	subscription_id: Generated<string | null>;
+	processed_at: Generated<number | null>;
+	last_attempt_at: Generated<number | null>;
+	last_error: Generated<string | null>;
+}
+export interface PaymentSubscriptionAttemptTable extends PaymentSubscriptionKey {
+	fingerprint: string;
+	request_id: string;
+	session_id: string | null;
+	created_at: number;
+}
+export interface PaymentSubscriptionLockTable extends PaymentSubscriptionKey {
+	token: string;
+	expires_at: number;
+}
+export interface PaymentSubscriptionPortalTable extends PaymentSubscriptionKey {
+	configuration_id: string;
+}
+
+export interface PaymentSubscriptionPurchaseTable extends PaymentSubscriptionKey {
+	user_id: string;
+	group_key: string;
+	contract: string;
+	fingerprint: string;
+	created_at: number;
+	expires_at: number;
+	session_id: Generated<string | null>;
+	subscription_id: Generated<string | null>;
+	closed: Generated<number>;
+	cancel_mode: Generated<string | null>;
+	last_attempt_at: Generated<number | null>;
+	last_error: Generated<string | null>;
+}
+
+export interface PaymentSubscriptionChangeTable extends PaymentSubscriptionKey {
+	subscription_id: string;
+	revision: number;
+	snapshot: string;
+	created_at: number;
+	acknowledged_at: Generated<number | null>;
+}
+
+export type PaymentStripeMode = "test" | "live";
+export type PaymentStripeConfigurationStatus = "unconfigured" | "unverified" | "valid" | "invalid";
+export type PaymentStripeTaxStatus = "unknown" | "active" | "pending" | "unavailable";
+export type PaymentStripeConnectStatus = "not_configured" | "restricted" | "ready";
+
+export interface PaymentStripeSettingsTable {
+	id: string;
+	default_key: Generated<"default">;
+	mode: Generated<PaymentStripeMode>;
+	publishable_key: string | null;
+	configuration_status: Generated<PaymentStripeConfigurationStatus>;
+	stripe_account_id: string | null;
+	charges_enabled: number | null;
+	details_submitted: number | null;
+	tax_status: Generated<PaymentStripeTaxStatus>;
+	validation_error_code: string | null;
+	last_validated_at: string | null;
+	connect_status: Generated<PaymentStripeConnectStatus>;
+	version: Generated<number>;
+	created_at: Generated<string>;
+	updated_at: Generated<string>;
+}
+
+export type PaymentTables = PaymentSubscriptionTables & {
+	payment_stripe_settings: PaymentStripeSettingsTable;
+};
+export type PaymentDatabase = Database & PaymentTables;

package/src/index.ts

@@ -4,6 +4,7 @@ import type { PluginDescriptor, PluginHooks, ResolvedPlugin } from "dineway";
 import { version as packageVersion } from "../package.json";
 import { PaymentStripeConfigurationRepository } from "./configuration/repository.js";
 import { PAYMENT_PLUGIN_ID } from "./constants.js";
+import { paymentMigrations } from "./database/index.js";
 import { createPaymentRoutes } from "./routes/index.js";
 import { createSubscriptionRoutes } from "./subscriptions/routes.js";
 import type { SubscriptionOptions } from "./subscriptions/types.js";
@@ -61,6 +62,7 @@ export function createPlugin(options: PaymentPluginOptions = {}): ResolvedPlugin
 					: []),
 			],
 		},
+		migrations: paymentMigrations,
 		hooks,
 		routes: {
 			...createPaymentRoutes(),

package/src/subscriptions/funding.ts

@@ -0,0 +1,256 @@
+import type Stripe from "stripe";
+
+import { relationId } from "./purchases.js";
+import {
+	SubscriptionError,
+	type ChargeEvidence,
+	type InvoiceFundingEvidence,
+	type PurchaseContract,
+	type SubscriptionScope,
+} from "./types.js";
+
+/** Fail instead of silently truncating provider evidence. */
+export async function collectBounded<T>(items: AsyncIterable<T>, limit = 1000): Promise<T[]> {
+	const result: T[] = [];
+	for await (const item of items) {
+		if (result.length === limit)
+			throw new SubscriptionError(
+				"RECONCILIATION_LIMIT",
+				"Payment evidence exceeds its safe limit",
+				503,
+			);
+		result.push(item);
+	}
+	return result;
+}
+
+export async function inspectCharge(
+	stripe: Stripe,
+	scope: SubscriptionScope,
+	chargeId: string,
+): Promise<ChargeEvidence> {
+	const charge = await stripe.charges.retrieve(chargeId);
+	if (charge.livemode !== (scope.mode === "live"))
+		throw new SubscriptionError("MODE_MISMATCH", "Invalid charge mode");
+	const refunds = await collectBounded(stripe.refunds.list({ charge: charge.id, limit: 100 }));
+	const disputes = await collectBounded(stripe.disputes.list({ charge: charge.id, limit: 100 }));
+	if (
+		refunds.some(
+			(refund) => relationId(refund.charge) !== charge.id || refund.currency !== charge.currency,
+		) ||
+		disputes.some(
+			(dispute) =>
+				relationId(dispute.charge) !== charge.id ||
+				dispute.currency !== charge.currency ||
+				dispute.livemode !== charge.livemode,
+		)
+	)
+		throw new SubscriptionError(
+			"INVALID_EVIDENCE",
+			"Payment evidence does not match the charge",
+			409,
+		);
+	return {
+		id: charge.id,
+		paymentIntentId: relationId(charge.payment_intent),
+		customerId: relationId(charge.customer),
+		currency: charge.currency,
+		amount: charge.amount,
+		captured: charge.amount_captured,
+		refunded: charge.amount_refunded,
+		settled:
+			charge.paid &&
+			charge.captured &&
+			charge.status === "succeeded" &&
+			charge.amount_captured === charge.amount &&
+			Number.isSafeInteger(charge.amount) &&
+			charge.amount > 0 &&
+			Number.isSafeInteger(charge.amount_refunded) &&
+			charge.amount_refunded >= 0 &&
+			charge.amount_refunded <= charge.amount &&
+			(!charge.disputed ||
+				(disputes.length > 0 &&
+					disputes.every((dispute) => ["won", "warning_closed"].includes(dispute.status)))),
+		refunds: refunds.map((refund) => ({
+			id: refund.id,
+			amount: refund.amount,
+			status: refund.status ?? "unknown",
+			metadata: refund.metadata ?? {},
+		})),
+		disputes: disputes.map((dispute) => ({
+			id: dispute.id,
+			amount: dispute.amount,
+			status: dispute.status,
+		})),
+	};
+}
+
+export async function invoiceFunding(
+	stripe: Stripe,
+	scope: SubscriptionScope,
+	subscription: Stripe.Subscription,
+	invoice: Stripe.Invoice,
+	contract: PurchaseContract | null,
+	now: number,
+): Promise<InvoiceFundingEvidence> {
+	const item = subscription.items.data[0]!;
+	const amount = contract?.amount ?? item.price.unit_amount ?? 0;
+	const currency = contract?.currency ?? item.price.currency;
+	const credit =
+		invoice.billing_reason === "subscription_create" ? (contract?.firstPeriodCredit ?? 0) : 0;
+	const cash = amount - credit;
+	const evidence: InvoiceFundingEvidence = {
+		verifiedAt: now,
+		amount,
+		currency,
+		credit,
+		cash,
+		charges: [],
+		paymentMethodId: null,
+		reason: null,
+	};
+	const invalid = (reason: string) => ({ ...evidence, reason });
+	const line = invoice.lines.data[0];
+	const details = line?.parent?.subscription_item_details;
+	const customer = relationId(subscription.customer);
+	if (
+		invoice.status !== "paid" ||
+		invoice.livemode !== (scope.mode === "live") ||
+		!customer ||
+		relationId(invoice.customer) !== customer ||
+		relationId(invoice.parent?.subscription_details?.subscription) !== subscription.id ||
+		!["subscription_create", "subscription_cycle"].includes(invoice.billing_reason ?? "") ||
+		invoice.currency !== currency ||
+		invoice.lines.has_more ||
+		invoice.lines.data.length !== 1 ||
+		!line ||
+		!details ||
+		details.proration ||
+		details.subscription_item !== item.id ||
+		details.subscription !== subscription.id ||
+		relationId(line.pricing?.price_details?.price) !== item.price.id ||
+		line.quantity !== 1 ||
+		line.currency !== currency ||
+		line.amount !== amount ||
+		line.subtotal !== amount ||
+		invoice.subtotal !== amount ||
+		invoice.total !== cash ||
+		invoice.amount_due !== cash ||
+		invoice.amount_paid !== cash ||
+		invoice.amount_remaining !== 0 ||
+		invoice.starting_balance !== 0 ||
+		invoice.ending_balance !== 0 ||
+		invoice.pre_payment_credit_notes_amount !== 0 ||
+		invoice.post_payment_credit_notes_amount !== 0 ||
+		invoice.total_taxes?.some((tax) => tax.amount !== 0) ||
+		!Number.isSafeInteger(line.period.start) ||
+		!Number.isSafeInteger(line.period.end) ||
+		line.period.start >= line.period.end
+	)
+		return invalid("INVOICE_CONTRACT_MISMATCH");
+	if (
+		contract?.interval === "day" &&
+		line.period.end - line.period.start !== contract.intervalCount * 86400
+	)
+		return invalid("SERVICE_PERIOD_MISMATCH");
+	const discounts = invoice.total_discount_amounts ?? [];
+	if (credit) {
+		if (discounts.length !== 1 || discounts[0]!.amount !== credit)
+			return invalid("CREDIT_MISMATCH");
+		const discount = invoice.discounts.find(
+			(value) => typeof value !== "string" && value.id === relationId(discounts[0]!.discount),
+		);
+		if (
+			!discount ||
+			typeof discount === "string" ||
+			discount.source.type !== "coupon" ||
+			relationId(discount.source.coupon) !== contract?.couponId
+		)
+			return invalid("CREDIT_MISMATCH");
+		const coupon =
+			typeof discount.source.coupon === "string"
+				? await stripe.coupons.retrieve(discount.source.coupon)
+				: discount.source.coupon;
+		if (
+			!coupon ||
+			coupon.livemode !== invoice.livemode ||
+			coupon.amount_off !== credit ||
+			coupon.currency !== currency ||
+			coupon.percent_off !== null ||
+			coupon.duration !== "once" ||
+			coupon.max_redemptions !== 1 ||
+			coupon.metadata?.dineway_app !== scope.namespace ||
+			coupon.metadata.purchase_reference !== contract?.reference ||
+			coupon.metadata.user_id !== subscription.metadata.user_id
+		)
+			return invalid("CREDIT_MISMATCH");
+	} else if (discounts.some((discount) => discount.amount !== 0))
+		return invalid("UNEXPECTED_DISCOUNT");
+	const payments = await collectBounded(
+		stripe.invoicePayments.list({
+			invoice: invoice.id,
+			status: "paid",
+			limit: 100,
+			expand: ["data.payment.payment_intent"],
+		}),
+	);
+	if (payments.length !== (cash ? 1 : 0)) return invalid("UNVERIFIED_CASH");
+	if (cash) {
+		const payment = payments[0]!;
+		const intentRef = payment.payment.payment_intent;
+		const intent =
+			typeof intentRef === "string" ? await stripe.paymentIntents.retrieve(intentRef) : intentRef;
+		if (
+			payment.status !== "paid" ||
+			payment.livemode !== invoice.livemode ||
+			payment.currency !== currency ||
+			relationId(payment.invoice) !== invoice.id ||
+			payment.amount_paid !== cash ||
+			payment.payment.type !== "payment_intent" ||
+			!intent ||
+			intent.status !== "succeeded" ||
+			intent.livemode !== invoice.livemode ||
+			intent.currency !== currency ||
+			intent.amount_received !== cash ||
+			relationId(intent.customer) !== customer ||
+			!intent.latest_charge
+		)
+			return invalid("UNVERIFIED_CASH");
+		const charge = await inspectCharge(stripe, scope, relationId(intent.latest_charge)!);
+		evidence.charges.push(charge);
+		if (
+			!charge.settled ||
+			charge.amount !== cash ||
+			charge.captured !== cash ||
+			charge.currency !== currency ||
+			charge.customerId !== customer ||
+			charge.paymentIntentId !== intent.id
+		)
+			return invalid("UNSETTLED_CHARGE");
+		if (
+			charge.refunded > 0 ||
+			charge.refunds.some((refund) => !["failed", "canceled"].includes(refund.status)) ||
+			charge.disputes.some((dispute) => !["won", "warning_closed"].includes(dispute.status))
+		)
+			return invalid("FUNDING_REVERSED");
+	} else {
+		let method = subscription.default_payment_method;
+		if (!method) {
+			const account = await stripe.customers.retrieve(customer);
+			if (account.deleted || account.livemode !== invoice.livemode)
+				return invalid("PAYMENT_METHOD_REQUIRED");
+			method = account.invoice_settings.default_payment_method;
+		}
+		if (!method) return invalid("PAYMENT_METHOD_REQUIRED");
+		const resolved =
+			typeof method === "string" ? await stripe.paymentMethods.retrieve(method) : method;
+		if (
+			resolved.type !== "card" ||
+			resolved.livemode !== invoice.livemode ||
+			relationId(resolved.customer) !== customer
+		)
+			return invalid("PAYMENT_METHOD_REQUIRED");
+		evidence.paymentMethodId = resolved.id;
+	}
+	return evidence;
+}

package/src/subscriptions/index.ts

@@ -4,3 +4,4 @@ export { getPaymentSubscriptionService, getSubscriptionConfiguration } from "./r
 export { createSubscriptionRoutes } from "./routes.js";
 export * from "./types.js";
 export { formatSubscriptionPrice } from "./format.js";
+export type { SubscriptionRefundInput } from "./refunds.js";