@dineway-ai/plugin-payment 0.2.3 → 0.2.4

package/src/subscriptions/projection.ts

@@ -0,0 +1,185 @@
+import type Stripe from "stripe";
+
+import {
+	SubscriptionError,
+	type MemberBilling,
+	type MemberSubscription,
+	type PaidSubscriptionPeriod,
+	type SubscriptionPlan,
+	type SubscriptionPrice,
+	type SubscriptionScope,
+} from "./types.js";
+
+export function recurringPrice(
+	price: Stripe.Price,
+	scope: SubscriptionScope,
+	requireActive = true,
+): SubscriptionPrice {
+	const interval = price.recurring?.interval;
+	const productId = typeof price.product === "string" ? price.product : price.product.id;
+	if (
+		price.livemode !== (scope.mode === "live") ||
+		(requireActive && !price.active) ||
+		price.type !== "recurring" ||
+		!price.recurring ||
+		!["month", "year"].includes(interval ?? "") ||
+		price.recurring.interval_count !== 1 ||
+		price.recurring.usage_type !== "licensed" ||
+		price.billing_scheme !== "per_unit" ||
+		price.transform_quantity ||
+		price.unit_amount === null ||
+		!Number.isSafeInteger(price.unit_amount) ||
+		price.unit_amount <= 0 ||
+		(interval !== "month" && interval !== "year")
+	) {
+		throw new SubscriptionError(
+			"INVALID_PRICE",
+			"Use an active fixed monthly or yearly recurring price",
+		);
+	}
+	return {
+		id: price.id,
+		productId,
+		currency: price.currency,
+		amount: price.unit_amount,
+		interval,
+		enabled: price.active,
+	};
+}
+
+export function ownedSubscription(
+	subscription: Stripe.Subscription,
+	scope: SubscriptionScope,
+	userId: string,
+	customerId: string,
+) {
+	const customer =
+		typeof subscription.customer === "string" ? subscription.customer : subscription.customer.id;
+	if (
+		subscription.livemode !== (scope.mode === "live") ||
+		customer !== customerId ||
+		subscription.metadata.dineway_app !== scope.namespace ||
+		subscription.metadata.user_id !== userId
+	) {
+		throw new SubscriptionError("OWNER_CONFLICT", "Subscription ownership conflict", 409);
+	}
+}
+
+export function subscriptionProjection(
+	subscription: Stripe.Subscription,
+	plans: SubscriptionPlan[],
+	scope: SubscriptionScope,
+	userId: string,
+	customerId: string,
+	now: number,
+): MemberSubscription {
+	ownedSubscription(subscription, scope, userId, customerId);
+	const item = subscription.items.data[0];
+	const plan = plans.find((value) => value.prices.some((price) => price.id === item?.price.id));
+	if (
+		!plan ||
+		subscription.items.has_more ||
+		subscription.items.data.length !== 1 ||
+		item?.quantity !== 1
+	) {
+		throw new SubscriptionError("UNRECOGNIZED_SUBSCRIPTION", "Subscription requires review", 409);
+	}
+	recurringPrice(item.price, scope, false);
+	return {
+		id: subscription.id,
+		userId,
+		customerId,
+		planCode: plan.code,
+		priceId: item.price.id,
+		status: subscription.status,
+		periodEnd: item.current_period_end,
+		cancelAtPeriodEnd: subscription.cancel_at_period_end,
+		verifiedAt: now,
+		lastError: null,
+	};
+}
+
+export function invoicePeriods(
+	invoice: Stripe.Invoice,
+	lines: Stripe.InvoiceLineItem[],
+	subscription: MemberSubscription,
+	plans: SubscriptionPlan[],
+	scope: SubscriptionScope,
+): PaidSubscriptionPeriod[] {
+	const customerId = typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id;
+	const relation = invoice.parent?.subscription_details?.subscription;
+	const subscriptionId = typeof relation === "string" ? relation : relation?.id;
+	if (
+		invoice.status !== "paid" ||
+		invoice.livemode !== (scope.mode === "live") ||
+		customerId !== subscription.customerId ||
+		subscriptionId !== subscription.id
+	) {
+		throw new SubscriptionError(
+			"INVALID_INVOICE",
+			"Invoice does not belong to this subscription",
+			409,
+		);
+	}
+	return lines.flatMap((line) => {
+		const details = line.parent?.subscription_item_details;
+		const priceId = line.pricing?.price_details?.price;
+		const id = typeof priceId === "string" ? priceId : priceId?.id;
+		const plan = plans.find((value) => value.prices.some((price) => price.id === id));
+		if (
+			!details ||
+			details.subscription !== subscription.id ||
+			details.proration ||
+			!plan ||
+			line.quantity !== 1 ||
+			line.amount <= 0
+		)
+			return [];
+		if (
+			!Number.isSafeInteger(line.period.start) ||
+			!Number.isSafeInteger(line.period.end) ||
+			line.period.end <= line.period.start
+		)
+			throw new SubscriptionError("INVALID_INVOICE", "Invalid service period");
+		return [
+			{
+				id: invoice.id + ":" + line.id,
+				invoiceId: invoice.id,
+				subscriptionId: subscription.id,
+				planCode: plan.code,
+				startsAt: line.period.start,
+				endsAt: line.period.end,
+			},
+		];
+	});
+}
+
+export function memberProjection(
+	customer: boolean,
+	subscriptions: MemberSubscription[],
+	periods: PaidSubscriptionPeriod[],
+	plans: SubscriptionPlan[],
+	now: number,
+): MemberBilling {
+	const valid = periods.filter(
+		(period) => period.startsAt * 1000 <= now && period.endsAt * 1000 > now,
+	);
+	const entitlements: Record<string, boolean | number> = {};
+	for (const period of valid) {
+		const plan = plans.find((value) => value.code === period.planCode);
+		for (const [key, value] of Object.entries(plan?.entitlements ?? {})) {
+			const previous = entitlements[key];
+			if (previous !== undefined && typeof previous !== typeof value) continue;
+			entitlements[key] =
+				typeof value === "boolean"
+					? previous === true || value
+					: Math.max(typeof previous === "number" ? previous : 0, value);
+		}
+	}
+	return {
+		customer,
+		subscriptions,
+		paidThrough: valid.length ? Math.max(...valid.map((period) => period.endsAt)) : null,
+		entitlements,
+	};
+}

package/src/subscriptions/repository.ts

@@ -0,0 +1,443 @@
+import { randomUUID } from "node:crypto";
+
+import type { Database } from "dineway";
+import type { Kysely, Transaction } from "kysely";
+
+import { entitlementSchema } from "./schemas.js";
+import {
+	SubscriptionError,
+	type MemberSubscription,
+	type PaidSubscriptionPeriod,
+	type SaveSubscriptionPlan,
+	type SubscriptionPlan,
+	type SubscriptionPrice,
+	type SubscriptionScope,
+} from "./types.js";
+
+type Db = Kysely<Database>;
+type Trx = Transaction<Database>;
+type SubscriptionRow = Database["payment_member_subscriptions"];
+const scopedId = ["scope", "id"] as const;
+const accountPattern = /^acct_[A-Za-z0-9]+$/;
+const namespacePattern = /^[a-z][a-z0-9_-]{0,63}$/;
+const keyColumns = () => [...scopedId];
+
+export function subscriptionScopeKey(scope: SubscriptionScope): string {
+	if (
+		!accountPattern.test(scope.accountId) ||
+		!namespacePattern.test(scope.namespace) ||
+		!["test", "live"].includes(scope.mode)
+	) {
+		throw new SubscriptionError("INVALID_SCOPE", "Invalid subscription scope");
+	}
+	return [scope.accountId, scope.mode, scope.namespace].join(":");
+}
+
+export class SubscriptionRepository {
+	readonly scope: string;
+	constructor(
+		readonly db: Db,
+		scope: SubscriptionScope,
+		readonly now: () => number = Date.now,
+		private readonly lease?: { id: string; token: string },
+	) {
+		this.scope = subscriptionScopeKey(scope);
+		this.scopeDetails = scope;
+	}
+	private readonly scopeDetails: SubscriptionScope;
+
+	async plans(): Promise<SubscriptionPlan[]> {
+		const [plans, prices] = await Promise.all([
+			this.db
+				.selectFrom("payment_subscription_plans")
+				.selectAll()
+				.where("scope", "=", this.scope)
+				.orderBy("id")
+				.execute(),
+			this.db
+				.selectFrom("payment_subscription_prices")
+				.selectAll()
+				.where("scope", "=", this.scope)
+				.orderBy("id")
+				.execute(),
+		]);
+		return plans.map((plan) => ({
+			code: plan.id,
+			name: plan.name,
+			enabled: plan.enabled === 1,
+			version: plan.version,
+			entitlements: entitlementSchema.parse(JSON.parse(plan.entitlements)),
+			prices: prices
+				.filter((price) => price.plan_code === plan.id)
+				.map((price) => {
+					if (price.interval !== "month" && price.interval !== "year")
+						throw new SubscriptionError("INVALID_PRICE", "Invalid saved price", 503);
+					return {
+						id: price.id,
+						productId: price.product_id,
+						currency: price.currency,
+						amount: price.amount,
+						interval: price.interval,
+						enabled: price.enabled === 1,
+					};
+				}),
+		}));
+	}
+
+	async savePlan(input: SaveSubscriptionPlan, prices: SubscriptionPrice[]): Promise<void> {
+		await this.db.transaction().execute(async (trx) => {
+			const values = {
+				name: input.name,
+				enabled: Number(input.enabled),
+				entitlements: JSON.stringify(input.entitlements),
+				version: input.expectedVersion + 1,
+			};
+			if (input.expectedVersion === 0) {
+				const inserted = await trx
+					.insertInto("payment_subscription_plans")
+					.values({ scope: this.scope, id: input.code, ...values })
+					.onConflict((conflict) => conflict.columns(keyColumns()).doNothing())
+					.returning("id")
+					.executeTakeFirst();
+				if (!inserted)
+					throw new SubscriptionError("CONFLICT", "Plan changed; reload and try again", 409);
+			} else {
+				const updated = await trx
+					.updateTable("payment_subscription_plans")
+					.set(values)
+					.where("scope", "=", this.scope)
+					.where("id", "=", input.code)
+					.where("version", "=", input.expectedVersion)
+					.returning("id")
+					.executeTakeFirst();
+				if (!updated)
+					throw new SubscriptionError("CONFLICT", "Plan changed; reload and try again", 409);
+			}
+			await trx
+				.updateTable("payment_subscription_prices")
+				.set({ enabled: 0 })
+				.where("scope", "=", this.scope)
+				.where("plan_code", "=", input.code)
+				.execute();
+			for (const price of prices) {
+				const previous = await trx
+					.selectFrom("payment_subscription_prices")
+					.select("plan_code")
+					.where("scope", "=", this.scope)
+					.where("id", "=", price.id)
+					.executeTakeFirst();
+				if (previous && previous.plan_code !== input.code)
+					throw new SubscriptionError("PRICE_IN_USE", "A price belongs to another plan", 409);
+				await trx
+					.insertInto("payment_subscription_prices")
+					.values({
+						scope: this.scope,
+						id: price.id,
+						plan_code: input.code,
+						product_id: price.productId,
+						currency: price.currency,
+						amount: price.amount,
+						interval: price.interval,
+						enabled: Number(price.enabled),
+					})
+					.onConflict((conflict) =>
+						conflict.columns(keyColumns()).doUpdateSet({ enabled: Number(price.enabled) }),
+					)
+					.execute();
+			}
+		});
+	}
+
+	async customer(userId: string): Promise<string | null> {
+		const row = await this.db
+			.selectFrom("payment_subscription_customers")
+			.select("customer_id")
+			.where("scope", "=", this.scope)
+			.where("id", "=", userId)
+			.executeTakeFirst();
+		return row?.customer_id ?? null;
+	}
+
+	async customerOwner(customerId: string): Promise<string | null> {
+		const row = await this.db
+			.selectFrom("payment_subscription_customers")
+			.select("id")
+			.where("scope", "=", this.scope)
+			.where("customer_id", "=", customerId)
+			.executeTakeFirst();
+		return row?.id ?? null;
+	}
+
+	async saveCustomer(userId: string, customerId: string): Promise<void> {
+		await this.db.transaction().execute(async (trx) => {
+			await this.assertLease(trx);
+			await trx
+				.insertInto("payment_subscription_customers")
+				.values({ scope: this.scope, id: userId, customer_id: customerId })
+				.onConflict((conflict) => conflict.columns(keyColumns()).doNothing())
+				.execute();
+			const saved = await trx
+				.selectFrom("payment_subscription_customers")
+				.select("customer_id")
+				.where("scope", "=", this.scope)
+				.where("id", "=", userId)
+				.executeTakeFirstOrThrow();
+			if (saved.customer_id !== customerId)
+				throw new SubscriptionError("OWNER_CONFLICT", "Customer ownership conflict", 409);
+		});
+	}
+
+	async subscriptions(userId: string): Promise<MemberSubscription[]> {
+		const rows = await this.db
+			.selectFrom("payment_member_subscriptions")
+			.selectAll()
+			.where("scope", "=", this.scope)
+			.where("user_id", "=", userId)
+			.orderBy("id")
+			.execute();
+		return rows.map(projectSubscription);
+	}
+
+	async subscription(id: string): Promise<MemberSubscription | null> {
+		const row = await this.db
+			.selectFrom("payment_member_subscriptions")
+			.selectAll()
+			.where("scope", "=", this.scope)
+			.where("id", "=", id)
+			.executeTakeFirst();
+		return row ? projectSubscription(row) : null;
+	}
+
+	async listSubscriptions(
+		cursor?: string,
+		limit = 50,
+	): Promise<{ items: MemberSubscription[]; nextCursor?: string }> {
+		let query = this.db
+			.selectFrom("payment_member_subscriptions")
+			.selectAll()
+			.where("scope", "=", this.scope);
+		if (cursor) query = query.where("id", ">", cursor);
+		const rows = await query
+			.orderBy("id")
+			.limit(limit + 1)
+			.execute();
+		const items = rows.slice(0, limit).map(projectSubscription);
+		return { items, ...(rows.length > limit ? { nextCursor: items.at(-1)?.id } : {}) };
+	}
+
+	async periods(userId: string): Promise<PaidSubscriptionPeriod[]> {
+		const rows = await this.db
+			.selectFrom("payment_subscription_periods as periods")
+			.innerJoin("payment_member_subscriptions as subscriptions", (join) =>
+				join
+					.onRef("subscriptions.scope", "=", "periods.scope")
+					.onRef("subscriptions.id", "=", "periods.subscription_id"),
+			)
+			.selectAll("periods")
+			.where("periods.scope", "=", this.scope)
+			.where("subscriptions.user_id", "=", userId)
+			.orderBy("periods.ends_at", "desc")
+			.execute();
+		return rows.map((row) => ({
+			id: row.id,
+			invoiceId: row.invoice_id,
+			subscriptionId: row.subscription_id,
+			planCode: row.plan_code,
+			startsAt: row.starts_at,
+			endsAt: row.ends_at,
+		}));
+	}
+
+	async saveSubscription(
+		state: MemberSubscription,
+		periods: PaidSubscriptionPeriod[],
+		eventId?: string,
+	): Promise<void> {
+		await this.db.transaction().execute(async (trx) => {
+			await this.assertLease(trx);
+			const owner = await trx
+				.selectFrom("payment_subscription_customers")
+				.select("id")
+				.where("scope", "=", this.scope)
+				.where("customer_id", "=", state.customerId)
+				.executeTakeFirst();
+			const existing = await trx
+				.selectFrom("payment_member_subscriptions")
+				.select(["user_id", "customer_id"])
+				.where("scope", "=", this.scope)
+				.where("id", "=", state.id)
+				.executeTakeFirst();
+			if (
+				owner?.id !== state.userId ||
+				(existing &&
+					(existing.user_id !== state.userId || existing.customer_id !== state.customerId))
+			) {
+				throw new SubscriptionError("OWNER_CONFLICT", "Subscription ownership conflict", 409);
+			}
+			const values = {
+				user_id: state.userId,
+				customer_id: state.customerId,
+				plan_code: state.planCode,
+				price_id: state.priceId,
+				status: state.status,
+				period_end: state.periodEnd,
+				cancel_at_period_end: Number(state.cancelAtPeriodEnd),
+				verified_at: state.verifiedAt,
+				last_error: state.lastError,
+			};
+			await trx
+				.insertInto("payment_member_subscriptions")
+				.values({ scope: this.scope, id: state.id, ...values })
+				.onConflict((conflict) => conflict.columns(keyColumns()).doUpdateSet(values))
+				.execute();
+			for (const period of periods) {
+				await trx
+					.insertInto("payment_subscription_periods")
+					.values({
+						scope: this.scope,
+						id: period.id,
+						invoice_id: period.invoiceId,
+						subscription_id: state.id,
+						plan_code: period.planCode,
+						starts_at: period.startsAt,
+						ends_at: period.endsAt,
+					})
+					.onConflict((conflict) => conflict.columns(keyColumns()).doNothing())
+					.execute();
+			}
+			if (eventId)
+				await trx
+					.insertInto("payment_subscription_events")
+					.values({ scope: this.scope, id: eventId, received_at: this.now() })
+					.onConflict((conflict) => conflict.columns(keyColumns()).doNothing())
+					.execute();
+		});
+	}
+
+	async recordSyncFailure(id: string, verifiedAt: number): Promise<void> {
+		await this.db
+			.updateTable("payment_member_subscriptions")
+			.set({ last_error: "SYNC_UNAVAILABLE" })
+			.where("scope", "=", this.scope)
+			.where("id", "=", id)
+			.where("verified_at", "=", verifiedAt)
+			.execute();
+	}
+	async eventSeen(id: string): Promise<boolean> {
+		return Boolean(
+			await this.db
+				.selectFrom("payment_subscription_events")
+				.select("id")
+				.where("scope", "=", this.scope)
+				.where("id", "=", id)
+				.executeTakeFirst(),
+		);
+	}
+	async portalConfiguration(): Promise<string | null> {
+		const row = await this.db
+			.selectFrom("payment_subscription_portals")
+			.select("configuration_id")
+			.where("scope", "=", this.scope)
+			.where("id", "=", "default")
+			.executeTakeFirst();
+		return row?.configuration_id ?? null;
+	}
+	async savePortalConfiguration(configurationId: string): Promise<void> {
+		await this.db.transaction().execute(async (trx) => {
+			await this.assertLease(trx);
+			await trx
+				.insertInto("payment_subscription_portals")
+				.values({ scope: this.scope, id: "default", configuration_id: configurationId })
+				.onConflict((conflict) => conflict.columns(keyColumns()).doNothing())
+				.execute();
+		});
+	}
+	async attempt(userId: string) {
+		return this.db
+			.selectFrom("payment_subscription_attempts")
+			.selectAll()
+			.where("scope", "=", this.scope)
+			.where("id", "=", userId)
+			.executeTakeFirst();
+	}
+	async saveAttempt(
+		userId: string,
+		attempt: {
+			fingerprint: string;
+			request_id: string;
+			session_id: string | null;
+			created_at: number;
+		},
+	): Promise<void> {
+		await this.db.transaction().execute(async (trx) => {
+			await this.assertLease(trx);
+			await trx
+				.insertInto("payment_subscription_attempts")
+				.values({ scope: this.scope, id: userId, ...attempt })
+				.onConflict((conflict) => conflict.columns(keyColumns()).doUpdateSet(attempt))
+				.execute();
+		});
+	}
+
+	async withLock<T>(
+		id: string,
+		action: (repository: SubscriptionRepository) => Promise<T>,
+	): Promise<T> {
+		const token = randomUUID();
+		const now = this.now();
+		const claimed = await this.db
+			.insertInto("payment_subscription_locks")
+			.values({ scope: this.scope, id, token, expires_at: now + 180000 })
+			.onConflict((conflict) =>
+				conflict
+					.columns(keyColumns())
+					.doUpdateSet({ token, expires_at: now + 180000 })
+					.where("payment_subscription_locks.expires_at", "<", now),
+			)
+			.returning("token")
+			.executeTakeFirst();
+		if (!claimed)
+			throw new SubscriptionError("BILLING_BUSY", "Billing is being updated; try again", 409);
+		try {
+			return await action(
+				new SubscriptionRepository(this.db, this.scopeDetails, this.now, { id, token }),
+			);
+		} finally {
+			await this.db
+				.deleteFrom("payment_subscription_locks")
+				.where("scope", "=", this.scope)
+				.where("id", "=", id)
+				.where("token", "=", token)
+				.execute();
+		}
+	}
+
+	private async assertLease(trx: Trx): Promise<void> {
+		if (!this.lease)
+			throw new SubscriptionError("LOCK_REQUIRED", "A billing lock is required", 409);
+		const row = await trx
+			.selectFrom("payment_subscription_locks")
+			.select("token")
+			.where("scope", "=", this.scope)
+			.where("id", "=", this.lease.id)
+			.where("token", "=", this.lease.token)
+			.where("expires_at", ">", this.now())
+			.executeTakeFirst();
+		if (!row) throw new SubscriptionError("BILLING_BUSY", "Billing lease expired; try again", 409);
+	}
+}
+
+function projectSubscription(row: SubscriptionRow): MemberSubscription {
+	return {
+		id: row.id,
+		userId: row.user_id,
+		customerId: row.customer_id,
+		planCode: row.plan_code,
+		priceId: row.price_id,
+		status: row.status,
+		periodEnd: row.period_end,
+		cancelAtPeriodEnd: row.cancel_at_period_end === 1,
+		verifiedAt: row.verified_at,
+		lastError: row.last_error,
+	};
+}