@dineway-ai/plugin-payment 0.2.6 → 0.2.8

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();
+}

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,9 +4,17 @@ 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 { getPaymentSubscriptionService } from "./subscriptions/runtime.js";
+import { SUBSCRIPTION_WEBHOOK_EVENTS } from "./subscriptions/service.js";
 import type { SubscriptionOptions } from "./subscriptions/types.js";
+import {
+	createPaymentWebhookRoute,
+	PAYMENT_WEBHOOK_EXTENSION,
+	type PaymentWebhookConsumer,
+} from "./webhooks/index.js";
 
 const PAYMENT_ADMIN_ENTRY = "@dineway-ai/plugin-payment/admin";
 const PAYMENT_ADMIN_PAGES = [
@@ -61,9 +69,24 @@ export function createPlugin(options: PaymentPluginOptions = {}): ResolvedPlugin
 					: []),
 			],
 		},
+		migrations: paymentMigrations,
+		nativeExtensions: options.subscriptions
+			? {
+					[PAYMENT_WEBHOOK_EXTENSION]: {
+						id: "subscriptions",
+						eventTypes: SUBSCRIPTION_WEBHOOK_EVENTS,
+						consume: async ({ event, rawBody }) => {
+							await (
+								await getPaymentSubscriptionService(options.subscriptions!)
+							).receiveVerifiedWebhook(event, rawBody);
+						},
+					} satisfies PaymentWebhookConsumer,
+				}
+			: {},
 		hooks,
 		routes: {
 			...createPaymentRoutes(),
+			"stripe/webhook": createPaymentWebhookRoute(),
 			...(options.subscriptions ? createSubscriptionRoutes(options.subscriptions) : {}),
 		},
 	});
@@ -74,3 +97,5 @@ export { PAYMENT_PLUGIN_ID } from "./constants.js";
 export * from "./stripe/index.js";
 export * from "./routes/index.js";
 export * from "./types.js";
+
+export * from "./webhooks/index.js";

package/src/stripe/webhook-verifier.ts

@@ -97,6 +97,7 @@ function projectEvent(event: Stripe.Event, rawBody: Uint8Array): StripeWebhookEv
 
 	return {
 		eventId: event.id,
+		...(event.account ? { accountId: requiredSafeString(event.account, 255) } : {}),
 		eventType: event.type,
 		eventCreated: event.created,
 		livemode: event.livemode,