@dineway-ai/plugin-payment 0.2.6 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dineway-ai/plugin-payment",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Provider-neutral payment infrastructure and Stripe integration for Dineway plugins",
   "type": "module",
   "publishConfig": {
@@ -11,6 +11,7 @@
     ".": "./src/index.ts",
     "./admin": "./src/admin.tsx",
     "./configuration": "./src/configuration/index.ts",
+    "./database": "./src/database/index.ts",
     "./routes": "./src/routes/index.ts",
     "./stripe": "./src/stripe/index.ts",
     "./types": "./src/types.ts",
@@ -29,7 +30,7 @@
   "license": "MIT",
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
-    "dineway": "^0.2.29"
+    "dineway": "^0.2.30"
   },
   "dependencies": {
     "@stripe/stripe-js": "9.9.0",

package/src/admin/subscriptions.tsx

@@ -5,6 +5,9 @@ import type { getSubscriptionConfiguration } from "../subscriptions/runtime.js";
 import type {
 	MemberBilling,
 	MemberSubscription,
+	BillingSubject,
+	SubscriptionPurchase,
+	SubscriptionSnapshot,
 	SaveSubscriptionPlan,
 	SubscriptionPlan,
 } from "../subscriptions/types.js";
@@ -12,6 +15,8 @@ import { postPaymentRoute } from "./api.js";
 import { SubscriptionPricePicker } from "./subscription-price-picker.js";
 
 type Configuration = Awaited<ReturnType<typeof getSubscriptionConfiguration>>;
+type AdminSubscription = MemberSubscription & { subject: BillingSubject | null };
+type AdminPurchase = SubscriptionPurchase & { subject: BillingSubject | null };
 type Feature = { key: string; kind: "boolean" | "number"; value: string };
 const emptyPlan: SaveSubscriptionPlan = {
 	code: "",
@@ -28,17 +33,18 @@ const buttonClass = "rounded-lg border border-kumo-line px-3 py-2 text-sm disabl
 export function PaymentSubscriptionsPage() {
 	const [configuration, setConfiguration] = React.useState<Configuration | null>(null);
 	const [plans, setPlans] = React.useState<SubscriptionPlan[]>([]);
-	const [members, setMembers] = React.useState<MemberSubscription[]>([]);
+	const [members, setMembers] = React.useState<AdminSubscription[]>([]);
+	const [purchases, setPurchases] = React.useState<AdminPurchase[]>([]);
+	const [purchaseCursor, setPurchaseCursor] = React.useState<string>();
 	const [cursor, setCursor] = React.useState<string>();
 	const [form, setForm] = React.useState<SaveSubscriptionPlan>({ ...emptyPlan });
 	const [editorRevision, setEditorRevision] = React.useState(0);
 	const [boundPrices, setBoundPrices] = React.useState<SubscriptionPlan["prices"]>([]);
 	const [features, setFeatures] = React.useState<Feature[]>([]);
 	const [webhookSecret, setWebhookSecret] = React.useState("");
-	const [detail, setDetail] = React.useState<{
-		subscription: MemberSubscription;
-		member: MemberBilling;
-	} | null>(null);
+	const [detail, setDetail] = React.useState<
+		(SubscriptionSnapshot & { member: MemberBilling }) | null
+	>(null);
 	const [busy, setBusy] = React.useState(false);
 	const [error, setError] = React.useState<string | null>(null);
 	const [notice, setNotice] = React.useState<string | null>(null);
@@ -46,15 +52,18 @@ export function PaymentSubscriptionsPage() {
 		const config = await postPaymentRoute<Configuration>("subscriptions/configuration/get");
 		setConfiguration(config);
 		if (config.ready) {
-			const [catalog, subscriptions] = await Promise.all([
+			const [catalog, subscriptions, purchasePage] = await Promise.all([
 				postPaymentRoute<{ items: SubscriptionPlan[] }>("subscriptions/plans/list"),
-				postPaymentRoute<{ items: MemberSubscription[]; nextCursor?: string }>(
-					"subscriptions/list",
+				postPaymentRoute<{ items: AdminSubscription[]; nextCursor?: string }>("subscriptions/list"),
+				postPaymentRoute<{ items: AdminPurchase[]; nextCursor?: string }>(
+					"subscriptions/purchases/list",
 				),
 			]);
 			setPlans(catalog.items);
 			setMembers(subscriptions.items);
 			setCursor(subscriptions.nextCursor);
+			setPurchases(purchasePage.items);
+			setPurchaseCursor(purchasePage.nextCursor);
 		}
 	}, []);
 	React.useEffect(() => {
@@ -391,7 +400,100 @@ export function PaymentSubscriptionsPage() {
 								</form>
 							</section>
 							<section className="space-y-4">
-								<h2 className="text-lg font-semibold">Member subscriptions</h2>
+								<h2 className="text-lg font-semibold">Purchases</h2>
+								<button
+									className={buttonClass}
+									disabled={busy}
+									onClick={() =>
+										void run(async () => {
+											const result = await postPaymentRoute<{ processed: number; failed: number }>(
+												"subscriptions/reconcile",
+											);
+											await refresh();
+											setNotice(
+												`Processed ${result.processed}; ${result.failed} require retry or review.`,
+											);
+										})
+									}
+								>
+									Retry pending synchronization
+								</button>
+								<div className="overflow-x-auto">
+									<table className="w-full text-left text-sm">
+										<thead>
+											<tr>
+												<th className="p-2">Billing subject</th>
+												<th className="p-2">Purchase</th>
+												<th className="p-2">Terms</th>
+												<th className="p-2">Status</th>
+											</tr>
+										</thead>
+										<tbody>
+											{purchases.map((purchase) => (
+												<tr key={purchase.reference} className="border-t border-kumo-line">
+													<td className="p-2">
+														{purchase.subject
+															? `${purchase.subject.realm}: ${purchase.subject.id}`
+															: purchase.userId}
+													</td>
+													<td className="p-2">
+														{purchase.reference}
+														<br />
+														{purchase.contract.pricing.kind}
+													</td>
+													<td className="p-2">
+														{formatSubscriptionPrice(
+															purchase.contract.amount,
+															purchase.contract.currency,
+														)}{" "}
+														every {purchase.contract.intervalCount} {purchase.contract.interval}
+														<br />
+														First invoice credit:{" "}
+														{formatSubscriptionPrice(
+															purchase.contract.firstPeriodCredit ?? 0,
+															purchase.contract.currency,
+														)}
+													</td>
+													<td className="p-2">
+														{purchase.closed
+															? "Closed"
+															: purchase.subscriptionId
+																? "Subscription recorded"
+																: "Awaiting confirmation"}
+														<br />
+														{purchase.cancelMode && `Cancellation: ${purchase.cancelMode}`}
+														<br />
+														{purchase.lastError}
+													</td>
+												</tr>
+											))}
+										</tbody>
+									</table>
+								</div>
+								{!purchases.length && (
+									<p className="text-sm text-kumo-subtle">No purchases recorded.</p>
+								)}
+								{purchaseCursor && (
+									<button
+										className={buttonClass}
+										disabled={busy}
+										onClick={() =>
+											void run(async () => {
+												const page = await postPaymentRoute<{
+													items: AdminPurchase[];
+													nextCursor?: string;
+												}>("subscriptions/purchases/list", { cursor: purchaseCursor });
+												setPurchases([...purchases, ...page.items]);
+												setPurchaseCursor(page.nextCursor);
+											})
+										}
+									>
+										Load more purchases
+									</button>
+								)}
+							</section>
+							<section className="space-y-4">
+								<h2 className="text-lg font-semibold">Subscriptions and funding</h2>
 								<p className="text-sm text-kumo-subtle">
 									Failed renewals keep access until the end of the paid period. Cancellation takes
 									effect at period end.
@@ -410,8 +512,18 @@ export function PaymentSubscriptionsPage() {
 										<tbody>
 											{members.map((member) => (
 												<tr key={member.id} className="border-t border-kumo-line">
-													<td className="p-2">{member.userId}</td>
-													<td className="p-2">{member.planCode}</td>
+													<td className="p-2">
+														{member.subject
+															? `${member.subject.realm}: ${member.subject.id}`
+															: member.userId}
+													</td>
+													<td className="p-2">
+														{member.planCode || "Dynamic purchase"}
+														<br />
+														<span className="text-xs text-kumo-subtle">
+															{member.purchaseReference}
+														</span>
+													</td>
 													<td className="p-2">{member.status}</td>
 													<td className="p-2">
 														{new Date(member.verifiedAt).toLocaleString()}
@@ -441,7 +553,7 @@ export function PaymentSubscriptionsPage() {
 										onClick={() =>
 											void run(async () => {
 												const page = await postPaymentRoute<{
-													items: MemberSubscription[];
+													items: AdminSubscription[];
 													nextCursor?: string;
 												}>("subscriptions/list", { cursor });
 												setMembers([...members, ...page.items]);
@@ -457,11 +569,31 @@ export function PaymentSubscriptionsPage() {
 										<h3 className="font-semibold">{detail.subscription.id}</h3>
 										<dl className="grid gap-2 text-sm">
 											<dt>Member</dt>
-											<dd>{detail.subscription.userId}</dd>
+											<dd>
+												{detail.subject
+													? `${detail.subject.realm}: ${detail.subject.id} · ${detail.subject.email}`
+													: detail.subscription.userId}
+											</dd>
+											<dt>Purchase reference</dt>
+											<dd>{detail.purchase?.reference ?? "Catalogue subscription"}</dd>
 											<dt>Paid access until</dt>
 											<dd>
-												{detail.member.paidThrough
-													? new Date(detail.member.paidThrough * 1000).toLocaleString()
+												{detail.periods.some(
+													(period) =>
+														period.eligible &&
+														period.startsAt * 1000 <= Date.now() &&
+														period.endsAt * 1000 > Date.now(),
+												)
+													? new Date(
+															Math.max(
+																...detail.periods
+																	.filter(
+																		(period) =>
+																			period.eligible && period.startsAt * 1000 <= Date.now(),
+																	)
+																	.map((period) => period.endsAt),
+															) * 1000,
+														).toLocaleString()
 													: "No current paid period"}
 											</dd>
 											<dt>Cancellation</dt>
@@ -469,7 +601,9 @@ export function PaymentSubscriptionsPage() {
 												{detail.subscription.cancelAtPeriodEnd
 													? "At period end: " +
 														new Date(detail.subscription.periodEnd * 1000).toLocaleString()
-													: "Not scheduled"}
+													: detail.subscription.status === "canceled"
+														? "Canceled"
+														: "Not scheduled"}
 											</dd>
 											<dt>Last synchronization</dt>
 											<dd>

package/src/configuration/repository.ts

@@ -1,13 +1,17 @@
 import type { Database } from "dineway";
 import type { Kysely, Selectable, Transaction, Updateable } from "kysely";
 
+import type { PaymentDatabase, PaymentTables } from "../database/types.js";
 import type { PaymentStripeSettings, UpdatePaymentStripeSettings } from "./types.js";
 
 type PaymentDb = Kysely<Database> | Transaction<Database>;
-type SettingsRow = Selectable<Database["payment_stripe_settings"]>;
+type SettingsRow = Selectable<PaymentDatabase["payment_stripe_settings"]>;
 
 export class PaymentStripeConfigurationRepository {
-	constructor(private readonly db: PaymentDb) {}
+	private readonly db: Kysely<PaymentDatabase> | Transaction<PaymentDatabase>;
+	constructor(db: PaymentDb) {
+		this.db = db.withTables<PaymentTables>();
+	}
 
 	async ensureDefaults(): Promise<PaymentStripeSettings> {
 		await this.db
@@ -32,7 +36,7 @@ export class PaymentStripeConfigurationRepository {
 		expectedVersion: number,
 		input: UpdatePaymentStripeSettings,
 	): Promise<PaymentStripeSettings> {
-		const update: Updateable<Database["payment_stripe_settings"]> = {
+		const update: Updateable<PaymentDatabase["payment_stripe_settings"]> = {
 			...(input.mode === undefined ? {} : { mode: input.mode }),
 			...(input.publishableKey === undefined ? {} : { publishable_key: input.publishableKey }),
 			...(input.configurationStatus === undefined

package/src/database/index.ts

@@ -0,0 +1,12 @@
+import type { PluginMigration } from "dineway";
+
+import * as configuration from "./migrations/001_stripe_configuration.js";
+import * as subscriptions from "./migrations/002_subscriptions.js";
+import * as purchases from "./migrations/003_purchases.js";
+
+export const paymentMigrations = {
+	"001_stripe_configuration": configuration,
+	"002_subscriptions": subscriptions,
+	"003_purchases": purchases,
+} satisfies Record<string, PluginMigration>;
+export type { PaymentDatabase, PaymentTables } from "./types.js";

package/src/database/migrations/001_stripe_configuration.ts

@@ -0,0 +1,100 @@
+import { currentTimestamp } from "dineway";
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { schemaExists } from "./adoption.js";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (
+		await schemaExists(db, {
+			payment_stripe_settings: [
+				"id",
+				"default_key",
+				"mode",
+				"publishable_key",
+				"configuration_status",
+				"stripe_account_id",
+				"charges_enabled",
+				"details_submitted",
+				"tax_status",
+				"validation_error_code",
+				"last_validated_at",
+				"connect_status",
+				"version",
+				"created_at",
+				"updated_at",
+			],
+		})
+	)
+		return;
+	await db.schema
+		.createTable("payment_stripe_settings")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("default_key", "text", (col) => col.notNull().unique().defaultTo("default"))
+		.addColumn("mode", "text", (col) =>
+			col
+				.notNull()
+				.check(sql`mode in ('test', 'live')`)
+				.defaultTo("test"),
+		)
+		.addColumn("publishable_key", "text")
+		.addColumn("configuration_status", "text", (col) =>
+			col
+				.notNull()
+				.check(sql`configuration_status in ('unconfigured', 'unverified', 'valid', 'invalid')`)
+				.defaultTo("unconfigured"),
+		)
+		.addColumn("stripe_account_id", "text")
+		.addColumn("charges_enabled", "integer", (col) =>
+			col.check(sql`charges_enabled is null or charges_enabled in (0, 1)`),
+		)
+		.addColumn("details_submitted", "integer", (col) =>
+			col.check(sql`details_submitted is null or details_submitted in (0, 1)`),
+		)
+		.addColumn("tax_status", "text", (col) =>
+			col
+				.notNull()
+				.check(sql`tax_status in ('unknown', 'active', 'pending', 'unavailable')`)
+				.defaultTo("unknown"),
+		)
+		.addColumn("validation_error_code", "text")
+		.addColumn("last_validated_at", "text")
+		.addColumn("connect_status", "text", (col) =>
+			col
+				.notNull()
+				.check(sql`connect_status in ('not_configured', 'restricted', 'ready')`)
+				.defaultTo("not_configured"),
+		)
+		.addColumn("version", "integer", (col) => col.notNull().defaultTo(1))
+		.addColumn("created_at", "text", (col) => col.notNull().defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.notNull().defaultTo(currentTimestamp(db)))
+		.addCheckConstraint("ck_payment_stripe_settings_default_key", sql`default_key = 'default'`)
+		.execute();
+
+	const tables = await db.introspection.getTables();
+	if (tables.some((table) => table.name === "restaurant_stripe_settings"))
+		await sql`
+		INSERT INTO payment_stripe_settings (
+			id, default_key, mode, publishable_key, configuration_status,
+			stripe_account_id, charges_enabled, details_submitted, tax_status,
+			validation_error_code, last_validated_at, connect_status, version,
+			created_at, updated_at
+		)
+		SELECT
+			id, default_key, mode, publishable_key, configuration_status,
+			stripe_account_id, charges_enabled, details_submitted, tax_status,
+			validation_error_code, last_validated_at, connect_status, version,
+			created_at, updated_at
+		FROM restaurant_stripe_settings
+	`.execute(db);
+
+	await db.schema
+		.createIndex("idx_payment_stripe_settings_updated_at")
+		.on("payment_stripe_settings")
+		.column("updated_at")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("payment_stripe_settings").execute();
+}

package/src/database/migrations/002_subscriptions.ts

@@ -0,0 +1,168 @@
+import type { Kysely } from "kysely";
+
+import { schemaExists } from "./adoption.js";
+
+const tables = [
+	"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",
+] as const;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (
+		await schemaExists(db, {
+			payment_subscription_plans: ["scope", "id", "name", "enabled", "entitlements", "version"],
+			payment_subscription_prices: [
+				"scope",
+				"id",
+				"plan_code",
+				"product_id",
+				"currency",
+				"amount",
+				"interval",
+				"enabled",
+			],
+			payment_subscription_customers: ["scope", "id", "customer_id"],
+			payment_member_subscriptions: [
+				"scope",
+				"id",
+				"user_id",
+				"customer_id",
+				"plan_code",
+				"price_id",
+				"status",
+				"period_end",
+				"cancel_at_period_end",
+				"verified_at",
+				"last_error",
+			],
+			payment_subscription_periods: [
+				"scope",
+				"id",
+				"subscription_id",
+				"invoice_id",
+				"plan_code",
+				"starts_at",
+				"ends_at",
+			],
+			payment_subscription_events: ["scope", "id", "received_at"],
+			payment_subscription_attempts: [
+				"scope",
+				"id",
+				"fingerprint",
+				"request_id",
+				"session_id",
+				"created_at",
+			],
+			payment_subscription_locks: ["scope", "id", "token", "expires_at"],
+			payment_subscription_portals: ["scope", "id", "configuration_id"],
+		})
+	)
+		return;
+	const base = (table: (typeof tables)[number]) =>
+		db.schema
+			.createTable(table)
+			.addColumn("scope", "text", (col) => col.notNull())
+			.addColumn("id", "text", (col) => col.notNull())
+			.addPrimaryKeyConstraint("pk_" + table, ["scope", "id"]);
+	await base("payment_subscription_plans")
+		.addColumn("name", "text", (col) => col.notNull())
+		.addColumn("enabled", "integer", (col) => col.notNull().defaultTo(0))
+		.addColumn("entitlements", "text", (col) => col.notNull())
+		.addColumn("version", "integer", (col) => col.notNull().defaultTo(1))
+		.execute();
+	await base("payment_subscription_prices")
+		.addColumn("plan_code", "text", (col) => col.notNull())
+		.addColumn("product_id", "text", (col) => col.notNull())
+		.addColumn("currency", "text", (col) => col.notNull())
+		.addColumn("amount", "integer", (col) => col.notNull())
+		.addColumn("interval", "text", (col) => col.notNull())
+		.addColumn("enabled", "integer", (col) => col.notNull().defaultTo(1))
+		.addForeignKeyConstraint(
+			"fk_payment_price_plan",
+			["scope", "plan_code"],
+			"payment_subscription_plans",
+			["scope", "id"],
+		)
+		.execute();
+	await base("payment_subscription_customers")
+		.addColumn("customer_id", "text", (col) => col.notNull())
+		.addUniqueConstraint("uq_payment_subscription_customer", ["scope", "customer_id"])
+		.execute();
+	await base("payment_member_subscriptions")
+		.addColumn("user_id", "text", (col) => col.notNull())
+		.addColumn("customer_id", "text", (col) => col.notNull())
+		.addColumn("plan_code", "text", (col) => col.notNull())
+		.addColumn("price_id", "text", (col) => col.notNull())
+		.addColumn("status", "text", (col) => col.notNull())
+		.addColumn("period_end", "integer", (col) => col.notNull())
+		.addColumn("cancel_at_period_end", "integer", (col) => col.notNull())
+		.addColumn("verified_at", "integer", (col) => col.notNull())
+		.addColumn("last_error", "text")
+		.addForeignKeyConstraint(
+			"fk_payment_subscription_user",
+			["scope", "user_id"],
+			"payment_subscription_customers",
+			["scope", "id"],
+		)
+		.addForeignKeyConstraint(
+			"fk_payment_subscription_price",
+			["scope", "price_id"],
+			"payment_subscription_prices",
+			["scope", "id"],
+		)
+		.execute();
+	await base("payment_subscription_periods")
+		.addColumn("subscription_id", "text", (col) => col.notNull())
+		.addColumn("invoice_id", "text", (col) => col.notNull())
+		.addColumn("plan_code", "text", (col) => col.notNull())
+		.addColumn("starts_at", "integer", (col) => col.notNull())
+		.addColumn("ends_at", "integer", (col) => col.notNull())
+		.addForeignKeyConstraint(
+			"fk_payment_period_subscription",
+			["scope", "subscription_id"],
+			"payment_member_subscriptions",
+			["scope", "id"],
+		)
+		.execute();
+	await base("payment_subscription_events")
+		.addColumn("received_at", "integer", (col) => col.notNull())
+		.execute();
+	await base("payment_subscription_attempts")
+		.addColumn("fingerprint", "text", (col) => col.notNull())
+		.addColumn("request_id", "text", (col) => col.notNull())
+		.addColumn("session_id", "text")
+		.addColumn("created_at", "integer", (col) => col.notNull())
+		.execute();
+	await base("payment_subscription_locks")
+		.addColumn("token", "text", (col) => col.notNull())
+		.addColumn("expires_at", "integer", (col) => col.notNull())
+		.execute();
+	for (const [table, column] of [
+		// Composite indexes keep reads within the configured account and application.
+		["payment_subscription_prices", "plan_code"],
+		["payment_member_subscriptions", "user_id"],
+		["payment_member_subscriptions", "price_id"],
+		["payment_subscription_periods", "subscription_id"],
+		["payment_subscription_periods", "invoice_id"],
+	] as const) {
+		await db.schema
+			.createIndex("idx_" + table + "_" + column)
+			.on(table)
+			.columns(["scope", column])
+			.execute();
+	}
+	await base("payment_subscription_portals")
+		.addColumn("configuration_id", "text", (col) => col.notNull())
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	for (const table of tables.toReversed()) await db.schema.dropTable(table).execute();
+}