@dineway-ai/plugin-payment 0.2.1

package/LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright 2026 Cloudflare Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@dineway-ai/plugin-payment",
+  "version": "0.2.1",
+  "description": "Provider-neutral payment infrastructure and Stripe integration for Dineway plugins",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./admin": "./src/admin.tsx",
+    "./configuration": "./src/configuration/index.ts",
+    "./routes": "./src/routes/index.ts",
+    "./stripe": "./src/stripe/index.ts",
+    "./types": "./src/types.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "dineway",
+    "plugin",
+    "payments",
+    "stripe"
+  ],
+  "author": "Dineway",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "dineway": "^0.2.1"
+  },
+  "dependencies": {
+    "@stripe/stripe-js": "9.9.0",
+    "astro": "^7.0.0",
+    "kysely": "^0.27.0",
+    "stripe": "22.3.0"
+  },
+  "devDependencies": {
+    "@types/react": "19.2.14",
+    "better-sqlite3": "^12.8.0",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsgo --noEmit"
+  }
+}

package/src/admin/api.ts

@@ -0,0 +1,12 @@
+import { apiFetch, parseApiResponse } from "dineway/plugin-utils";
+
+const API_BASE = "/_dineway/api/plugins/dineway-payment";
+
+export async function postPaymentRoute<T>(route: string, body: unknown = {}): Promise<T> {
+	const response = await apiFetch(`${API_BASE}/${route}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+	});
+	return parseApiResponse<T>(response, `Payment request failed (${route})`);
+}

package/src/admin/form.ts

@@ -0,0 +1,56 @@
+import type {
+	PaymentStripeConfiguration,
+	UpdatePaymentStripeConfigurationInput,
+} from "../configuration/service.js";
+import type { StripeMode } from "../types.js";
+
+export interface PaymentSettingsForm {
+	mode: StripeMode;
+	publishableKey: string;
+	secretKey: string;
+	webhookSecret: string;
+}
+
+export function paymentSettingsForm(
+	configuration: PaymentStripeConfiguration,
+): PaymentSettingsForm {
+	return {
+		mode: configuration.settings.mode,
+		publishableKey: configuration.settings.publishableKey ?? "",
+		secretKey: "",
+		webhookSecret: "",
+	};
+}
+
+export function buildPaymentSettingsUpdate(
+	form: PaymentSettingsForm,
+	configuration: PaymentStripeConfiguration,
+): UpdatePaymentStripeConfigurationInput {
+	const publishableKey = form.publishableKey.trim();
+	const secretKey = form.secretKey.trim();
+	const webhookSecret = form.webhookSecret.trim();
+	const keyMode = form.mode === "live" ? "live" : "test";
+	if (publishableKey && !publishableKey.startsWith(`pk_${keyMode}_`)) {
+		throw new Error(`Publishable key must match ${form.mode} mode`);
+	}
+	if (secretKey && !secretKey.startsWith(`sk_${keyMode}_`)) {
+		throw new Error(`Secret key must match ${form.mode} mode`);
+	}
+	if (webhookSecret && !webhookSecret.startsWith("whsec_")) {
+		throw new Error("Webhook signing secret must start with whsec_");
+	}
+	if (
+		configuration.secretKey &&
+		configuration.settings.mode !== form.mode &&
+		!secretKey
+	) {
+		throw new Error("Enter the matching secret key when changing Stripe mode");
+	}
+	return {
+		expectedVersion: configuration.settings.version,
+		mode: form.mode,
+		publishableKey: publishableKey || null,
+		...(secretKey ? { secretKey } : {}),
+		...(webhookSecret ? { webhookSecret } : {}),
+	};
+}

package/src/admin.tsx

@@ -0,0 +1,151 @@
+import * as React from "react";
+
+import type { PaymentStripeConfiguration } from "./configuration/service.js";
+import { postPaymentRoute } from "./admin/api.js";
+import {
+	buildPaymentSettingsUpdate,
+	paymentSettingsForm,
+	type PaymentSettingsForm,
+} from "./admin/form.js";
+
+type CredentialName = "secretKey" | "webhookSecret";
+
+export function PaymentSettingsPage() {
+	const [configuration, setConfiguration] =
+		React.useState<PaymentStripeConfiguration | null>(null);
+	const [form, setForm] = React.useState<PaymentSettingsForm | null>(null);
+	const [loading, setLoading] = React.useState(true);
+	const [pending, setPending] = React.useState(false);
+	const [error, setError] = React.useState<string | null>(null);
+	const [notice, setNotice] = React.useState<string | null>(null);
+
+	const applyConfiguration = React.useCallback((next: PaymentStripeConfiguration) => {
+		setConfiguration(next);
+		setForm(paymentSettingsForm(next));
+	}, []);
+
+	React.useEffect(() => {
+		let cancelled = false;
+		void postPaymentRoute<{ configuration: PaymentStripeConfiguration }>(
+			"stripe/configuration/get",
+		)
+			.then((response) => {
+				if (!cancelled) applyConfiguration(response.configuration);
+				return undefined;
+			})
+			.catch((cause) => {
+				if (!cancelled) setError(message(cause));
+			})
+			.finally(() => {
+				if (!cancelled) setLoading(false);
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, [applyConfiguration]);
+
+	async function save(event: React.FormEvent) {
+		event.preventDefault();
+		if (!configuration || !form) return;
+		await run(async () => {
+			const response = await postPaymentRoute<{ configuration: PaymentStripeConfiguration }>(
+				"stripe/configuration/update",
+				buildPaymentSettingsUpdate(form, configuration),
+			);
+			applyConfiguration(response.configuration);
+			setNotice("Stripe account saved. Test the connection before accepting payments.");
+		});
+	}
+
+	async function testConnection() {
+		await run(async () => {
+			const response = await postPaymentRoute<{ configuration: PaymentStripeConfiguration }>(
+				"stripe/configuration/test",
+			);
+			applyConfiguration(response.configuration);
+			setNotice("Stripe connection test completed.");
+		});
+	}
+
+	async function removeCredential(name: CredentialName) {
+		if (!configuration) return;
+		await run(async () => {
+			const response = await postPaymentRoute<{ configuration: PaymentStripeConfiguration }>(
+				"stripe/configuration/update",
+				{ expectedVersion: configuration.settings.version, [name]: null },
+			);
+			applyConfiguration(response.configuration);
+			setNotice(name === "secretKey" ? "Secret key removed." : "Webhook secret removed.");
+		});
+	}
+
+	async function run(action: () => Promise<void>) {
+		setPending(true);
+		setError(null);
+		setNotice(null);
+		try {
+			await action();
+		} catch (cause) {
+			setError(message(cause));
+		} finally {
+			setPending(false);
+		}
+	}
+
+	if (loading) return <p className="text-sm text-kumo-subtle">Loading payment settings…</p>;
+	if (!configuration || !form) {
+		return <p className="rounded-lg bg-kumo-danger/10 p-4 text-sm text-kumo-danger">{error ?? "Payment configuration is unavailable."}</p>;
+	}
+	const canTest = Boolean(
+		configuration.settings.publishableKey &&
+			configuration.secretKey &&
+			form.mode === configuration.settings.mode &&
+			form.publishableKey.trim() === configuration.settings.publishableKey &&
+			!form.secretKey.trim(),
+	);
+
+	return (
+		<div className="space-y-6">
+			<header className="flex flex-wrap items-start justify-between gap-3">
+				<div><h1 className="text-2xl font-semibold">Payments</h1><p className="mt-1 text-sm text-kumo-subtle">Shared Stripe account and encrypted credentials for every transactional plugin.</p></div>
+				<span className="rounded-full bg-kumo-tint px-3 py-1 text-xs font-semibold uppercase">{configuration.settings.configurationStatus}</span>
+			</header>
+			<Readiness configuration={configuration} />
+			{error ? <p className="rounded-lg bg-kumo-danger/10 p-3 text-sm text-kumo-danger" role="alert">{error}</p> : null}
+			{notice ? <p className="rounded-lg bg-kumo-success/10 p-3 text-sm text-kumo-success" role="status">{notice}</p> : null}
+			<form className="grid max-w-3xl gap-5 rounded-xl border border-kumo-line p-5" onSubmit={(event) => void save(event)}>
+				<fieldset className="grid gap-2" disabled={pending}><legend className="mb-2 text-sm font-medium">Stripe mode</legend><div className="flex gap-2">{(["test", "live"] as const).map((mode) => <button type="button" key={mode} className={`rounded-lg border px-4 py-2 text-sm ${form.mode === mode ? "border-kumo-contrast bg-kumo-contrast text-kumo-base" : "border-kumo-line"}`} onClick={() => setForm({ ...form, mode })}>{mode === "test" ? "Test" : "Live"}</button>)}</div></fieldset>
+				<Field label="Publishable key" value={form.publishableKey} onChange={(value) => setForm({ ...form, publishableKey: value })} placeholder={form.mode === "test" ? "pk_test_…" : "pk_live_…"} />
+				<Field label="Secret key" value={form.secretKey} onChange={(value) => setForm({ ...form, secretKey: value })} placeholder={configuration.secretKey ? "Leave blank to keep the current key" : form.mode === "test" ? "sk_test_…" : "sk_live_…"} type="password" />
+				<Credential label="Secret key" present={Boolean(configuration.secretKey)} fingerprint={configuration.secretKey?.fingerprint ?? null} onRemove={() => void removeCredential("secretKey")} disabled={pending} />
+				<Field label="Webhook signing secret" value={form.webhookSecret} onChange={(value) => setForm({ ...form, webhookSecret: value })} placeholder={configuration.webhookSecret ? "Leave blank to keep the current secret" : "whsec_…"} type="password" />
+				<Credential label="Webhook secret" present={Boolean(configuration.webhookSecret)} fingerprint={configuration.webhookSecret?.fingerprint ?? null} onRemove={() => void removeCredential("webhookSecret")} disabled={pending} />
+				<div className="flex flex-wrap gap-2"><button className="rounded-lg bg-kumo-contrast px-4 py-2 text-sm font-medium text-kumo-base" disabled={pending}>{pending ? "Saving…" : "Save account"}</button><button type="button" className="rounded-lg border border-kumo-line px-4 py-2 text-sm font-medium" disabled={!canTest || pending} onClick={() => void testConnection()}>{pending ? "Working…" : "Test connection"}</button></div>
+			</form>
+			<section className="max-w-3xl rounded-xl bg-kumo-tint/40 p-5 text-sm text-kumo-subtle"><h2 className="font-semibold text-kumo-default">Webhook endpoint</h2><p className="mt-2">Configure Stripe to send domain events to the webhook shown by each installed transactional plugin. Venue and Restaurant validate exact request bytes with this shared signing secret.</p></section>
+		</div>
+	);
+}
+
+function Readiness({ configuration }: { configuration: PaymentStripeConfiguration }) {
+	const settings = configuration.settings;
+	return <div className="grid gap-3 md:grid-cols-4"><Metric label="Account" value={settings.stripeAccountId ?? "Not verified"} /><Metric label="Charges" value={settings.chargesEnabled === null ? "Unknown" : settings.chargesEnabled ? "Enabled" : "Restricted"} /><Metric label="Tax" value={settings.taxStatus} /><Metric label="Connection" value={settings.connectStatus} /></div>;
+}
+
+function Metric({ label, value }: { label: string; value: string }) {
+	return <div className="rounded-xl border border-kumo-line p-4"><div className="text-xs font-medium uppercase text-kumo-subtle">{label}</div><div className="mt-1 truncate font-semibold">{value}</div></div>;
+}
+
+function Field(props: { label: string; value: string; onChange: (value: string) => void; placeholder: string; type?: string }) {
+	return <label className="grid gap-1 text-sm font-medium">{props.label}<input className="rounded-lg border border-kumo-line bg-transparent px-3 py-2 font-normal" type={props.type ?? "text"} value={props.value} onChange={(event) => props.onChange(event.target.value)} placeholder={props.placeholder} autoComplete="off" disabled={false} /></label>;
+}
+
+function Credential(props: { label: string; present: boolean; fingerprint: string | null; onRemove: () => void; disabled: boolean }) {
+	return <div className="flex flex-wrap items-center justify-between gap-3 rounded-lg bg-kumo-tint/50 px-3 py-2 text-sm"><span>{props.present ? `${props.label} stored · ${props.fingerprint ?? "encrypted"}` : `${props.label} not stored`}</span>{props.present ? <button type="button" className="text-kumo-danger underline" onClick={props.onRemove} disabled={props.disabled}>Remove</button> : null}</div>;
+}
+
+function message(value: unknown): string {
+	return value instanceof Error ? value.message : "Payment request failed";
+}
+
+export const pages = { "/payments": PaymentSettingsPage };

package/src/configuration/index.ts

@@ -0,0 +1,4 @@
+export * from "./repository.js";
+export * from "./service.js";
+export * from "./secrets.js";
+export * from "./types.js";

package/src/configuration/repository.ts

@@ -0,0 +1,103 @@
+import type { Database } from "dineway";
+import type { Kysely, Selectable, Transaction, Updateable } from "kysely";
+
+import type { PaymentStripeSettings, UpdatePaymentStripeSettings } from "./types.js";
+
+type PaymentDb = Kysely<Database> | Transaction<Database>;
+type SettingsRow = Selectable<Database["payment_stripe_settings"]>;
+
+export class PaymentStripeConfigurationRepository {
+	constructor(private readonly db: PaymentDb) {}
+
+	async ensureDefaults(): Promise<PaymentStripeSettings> {
+		await this.db
+			.insertInto("payment_stripe_settings")
+			.values({ id: "default", default_key: "default", publishable_key: null })
+			.onConflict((conflict) => conflict.column("default_key").doNothing())
+			.execute();
+		return this.requireSettings();
+	}
+
+	async requireSettings(): Promise<PaymentStripeSettings> {
+		const row = await this.db
+			.selectFrom("payment_stripe_settings")
+			.selectAll()
+			.where("default_key", "=", "default")
+			.executeTakeFirst();
+		if (!row) throw new Error("Payment Stripe configuration is not initialized");
+		return mapSettings(row);
+	}
+
+	async updateSettings(
+		expectedVersion: number,
+		input: UpdatePaymentStripeSettings,
+	): Promise<PaymentStripeSettings> {
+		const update: Updateable<Database["payment_stripe_settings"]> = {
+			...(input.mode === undefined ? {} : { mode: input.mode }),
+			...(input.publishableKey === undefined
+				? {}
+				: { publishable_key: input.publishableKey }),
+			...(input.configurationStatus === undefined
+				? {}
+				: { configuration_status: input.configurationStatus }),
+			...(input.stripeAccountId === undefined
+				? {}
+				: { stripe_account_id: input.stripeAccountId }),
+			...(input.chargesEnabled === undefined
+				? {}
+				: { charges_enabled: optionalBoolean(input.chargesEnabled) }),
+			...(input.detailsSubmitted === undefined
+				? {}
+				: { details_submitted: optionalBoolean(input.detailsSubmitted) }),
+			...(input.taxStatus === undefined ? {} : { tax_status: input.taxStatus }),
+			...(input.validationErrorCode === undefined
+				? {}
+				: { validation_error_code: input.validationErrorCode }),
+			...(input.lastValidatedAt === undefined
+				? {}
+				: { last_validated_at: input.lastValidatedAt }),
+			...(input.connectStatus === undefined
+				? {}
+				: { connect_status: input.connectStatus }),
+			version: expectedVersion + 1,
+			updated_at: new Date().toISOString(),
+		};
+		const result = await this.db
+			.updateTable("payment_stripe_settings")
+			.set(update)
+			.where("default_key", "=", "default")
+			.where("version", "=", expectedVersion)
+			.executeTakeFirst();
+		if (Number(result.numUpdatedRows) !== 1) {
+			throw new Error("Payment Stripe configuration changed; reload and try again");
+		}
+		return this.requireSettings();
+	}
+}
+
+function mapSettings(row: SettingsRow): PaymentStripeSettings {
+	return {
+		id: row.id,
+		mode: row.mode,
+		publishableKey: row.publishable_key,
+		configurationStatus: row.configuration_status,
+		stripeAccountId: row.stripe_account_id,
+		chargesEnabled: optionalDatabaseBoolean(row.charges_enabled),
+		detailsSubmitted: optionalDatabaseBoolean(row.details_submitted),
+		taxStatus: row.tax_status,
+		validationErrorCode: row.validation_error_code,
+		lastValidatedAt: row.last_validated_at,
+		connectStatus: row.connect_status,
+		version: row.version,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+	};
+}
+
+function optionalBoolean(value: boolean | null): number | null {
+	return value === null ? null : value ? 1 : 0;
+}
+
+function optionalDatabaseBoolean(value: number | null): boolean | null {
+	return value === null ? null : value === 1;
+}

package/src/configuration/secrets.ts

@@ -0,0 +1,43 @@
+import {
+	PluginSecretStore,
+	type Database,
+	type PluginSecretStatus,
+	type PluginSecretStoreOptions,
+} from "dineway";
+import type { Kysely, Transaction } from "kysely";
+
+import { PAYMENT_PLUGIN_ID } from "../constants.js";
+
+export const PAYMENT_STRIPE_SECRET_KEY = "stripe_secret_key";
+export const PAYMENT_STRIPE_WEBHOOK_SECRET = "stripe_webhook_secret";
+
+export type PaymentStripeSecretName =
+	| typeof PAYMENT_STRIPE_SECRET_KEY
+	| typeof PAYMENT_STRIPE_WEBHOOK_SECRET;
+
+export class PaymentStripeSecretStore {
+	private readonly store: PluginSecretStore;
+
+	constructor(
+		db: Kysely<Database> | Transaction<Database>,
+		options: PluginSecretStoreOptions = {},
+	) {
+		this.store = new PluginSecretStore(db, options);
+	}
+
+	set(name: PaymentStripeSecretName, value: string): Promise<PluginSecretStatus> {
+		return this.store.set(PAYMENT_PLUGIN_ID, name, value);
+	}
+
+	status(name: PaymentStripeSecretName): Promise<PluginSecretStatus | null> {
+		return this.store.status(PAYMENT_PLUGIN_ID, name);
+	}
+
+	delete(name: PaymentStripeSecretName): Promise<boolean> {
+		return this.store.delete(PAYMENT_PLUGIN_ID, name);
+	}
+
+	resolveForRuntime(name: PaymentStripeSecretName): Promise<string | null> {
+		return this.store.resolveForRuntime(PAYMENT_PLUGIN_ID, name);
+	}
+}

package/src/configuration/service.ts

@@ -0,0 +1,241 @@
+import type {
+	Database,
+	PluginSecretStatus,
+	PluginSecretStoreOptions,
+} from "dineway";
+import type { Kysely, Transaction } from "kysely";
+
+import type { StripeAccountProbe, StripeMode } from "../types.js";
+import { PaymentStripeConfigurationRepository } from "./repository.js";
+import {
+	PAYMENT_STRIPE_SECRET_KEY,
+	PAYMENT_STRIPE_WEBHOOK_SECRET,
+	PaymentStripeSecretStore,
+} from "./secrets.js";
+import type { PaymentStripeSettings } from "./types.js";
+
+export interface PaymentStripeConfiguration {
+	settings: PaymentStripeSettings;
+	secretKey: PluginSecretStatus | null;
+	webhookSecret: PluginSecretStatus | null;
+}
+
+export interface UpdatePaymentStripeConfigurationInput {
+	expectedVersion: number;
+	mode?: StripeMode;
+	publishableKey?: string | null;
+	secretKey?: string | null;
+	webhookSecret?: string | null;
+}
+
+export class PaymentConfigurationError extends Error {
+	constructor(
+		readonly code: "VALIDATION_ERROR" | "CONFLICT" | "INVALID_STATE",
+		message: string,
+	) {
+		super(message);
+		this.name = "PaymentConfigurationError";
+	}
+}
+
+export async function getPaymentStripeConfiguration(
+	db: Kysely<Database>,
+	secretOptions: PluginSecretStoreOptions = {},
+): Promise<PaymentStripeConfiguration> {
+	const repository = new PaymentStripeConfigurationRepository(db);
+	await repository.ensureDefaults();
+	return loadConfiguration(db, secretOptions);
+}
+
+export async function updatePaymentStripeConfiguration(
+	db: Kysely<Database>,
+	input: UpdatePaymentStripeConfigurationInput,
+	secretOptions: PluginSecretStoreOptions = {},
+): Promise<PaymentStripeConfiguration> {
+	validateUpdate(input);
+	return db.transaction().execute(async (trx) => {
+		const repository = new PaymentStripeConfigurationRepository(trx);
+		const before = await repository.ensureDefaults();
+		if (before.version !== input.expectedVersion) {
+			throw new PaymentConfigurationError(
+				"CONFLICT",
+				"Payment configuration changed; reload and try again",
+			);
+		}
+		const store = new PaymentStripeSecretStore(trx, secretOptions);
+		const mode = input.mode ?? before.mode;
+		const publishableKey = normalizeOptionalKey(input.publishableKey, before.publishableKey);
+		const existingSecret = await store.status(PAYMENT_STRIPE_SECRET_KEY);
+		const secretValue =
+			input.secretKey === undefined
+				? input.mode !== undefined && input.mode !== before.mode && existingSecret
+					? await store.resolveForRuntime(PAYMENT_STRIPE_SECRET_KEY)
+					: null
+				: normalizeOptionalSecret(input.secretKey);
+		validateModeKeys(mode, publishableKey, secretValue, input.secretKey !== undefined);
+		if (input.webhookSecret !== undefined && input.webhookSecret !== null) {
+			const webhookSecret = input.webhookSecret.trim();
+			if (!webhookSecret.startsWith("whsec_") || webhookSecret.length > 512) {
+				throw new PaymentConfigurationError(
+					"VALIDATION_ERROR",
+					"Webhook signing secret must start with whsec_",
+				);
+			}
+		}
+
+		await updateSecret(store, PAYMENT_STRIPE_SECRET_KEY, input.secretKey);
+		await updateSecret(store, PAYMENT_STRIPE_WEBHOOK_SECRET, input.webhookSecret);
+		const nextSecret = await store.status(PAYMENT_STRIPE_SECRET_KEY);
+		const credentialsChanged =
+			(input.mode !== undefined && input.mode !== before.mode) ||
+			(input.publishableKey !== undefined && publishableKey !== before.publishableKey) ||
+			input.secretKey !== undefined;
+		const credentialsComplete = Boolean(publishableKey && nextSecret);
+		await repository.updateSettings(before.version, {
+			mode,
+			publishableKey,
+			...(credentialsChanged || !credentialsComplete
+				? {
+						configurationStatus: credentialsComplete ? "unverified" : "unconfigured",
+						stripeAccountId: null,
+						chargesEnabled: null,
+						detailsSubmitted: null,
+						taxStatus: "unknown" as const,
+						validationErrorCode: null,
+						lastValidatedAt: null,
+						connectStatus: credentialsComplete ? ("restricted" as const) : ("not_configured" as const),
+					}
+				: {}),
+		});
+		return loadConfiguration(trx, secretOptions);
+	});
+}
+
+export async function testPaymentStripeConnection(
+	db: Kysely<Database>,
+	probe: StripeAccountProbe,
+	secretOptions: PluginSecretStoreOptions = {},
+): Promise<PaymentStripeConfiguration> {
+	const before = await new PaymentStripeConfigurationRepository(db).ensureDefaults();
+	if (!before.publishableKey) {
+		throw new PaymentConfigurationError(
+			"INVALID_STATE",
+			"Stripe publishable key is not configured",
+		);
+	}
+	const secretKey = await new PaymentStripeSecretStore(db, secretOptions).resolveForRuntime(
+		PAYMENT_STRIPE_SECRET_KEY,
+	);
+	if (!secretKey) {
+		throw new PaymentConfigurationError("INVALID_STATE", "Stripe secret key is not configured");
+	}
+	validateModeKeys(before.mode, before.publishableKey, secretKey, true);
+
+	let result;
+	try {
+		result = await probe.probe({ mode: before.mode, secretKey });
+	} catch {
+		result = { ok: false as const, errorCode: "connection_error" as const };
+	}
+	if (result.ok && result.livemode !== (before.mode === "live")) {
+		result = { ok: false as const, errorCode: "mode_mismatch" as const };
+	}
+
+	return db.transaction().execute(async (trx) => {
+		const repository = new PaymentStripeConfigurationRepository(trx);
+		await repository.updateSettings(before.version, result.ok
+			? {
+					configurationStatus: "valid",
+					stripeAccountId: result.accountId,
+					chargesEnabled: result.chargesEnabled,
+					detailsSubmitted: result.detailsSubmitted,
+					taxStatus: result.taxStatus,
+					validationErrorCode: null,
+					lastValidatedAt: new Date().toISOString(),
+					connectStatus:
+						result.chargesEnabled && result.detailsSubmitted ? "ready" : "restricted",
+				}
+			: {
+					configurationStatus: "invalid",
+					stripeAccountId: null,
+					chargesEnabled: null,
+					detailsSubmitted: null,
+					taxStatus: "unknown",
+					validationErrorCode: result.errorCode,
+					lastValidatedAt: new Date().toISOString(),
+					connectStatus: "restricted",
+				});
+		return loadConfiguration(trx, secretOptions);
+	});
+}
+
+async function loadConfiguration(
+	db: Kysely<Database> | Transaction<Database>,
+	secretOptions: PluginSecretStoreOptions,
+): Promise<PaymentStripeConfiguration> {
+	const repository = new PaymentStripeConfigurationRepository(db);
+	const store = new PaymentStripeSecretStore(db, secretOptions);
+	const [settings, secretKey, webhookSecret] = await Promise.all([
+		repository.requireSettings(),
+		store.status(PAYMENT_STRIPE_SECRET_KEY),
+		store.status(PAYMENT_STRIPE_WEBHOOK_SECRET),
+	]);
+	return { settings, secretKey, webhookSecret };
+}
+
+async function updateSecret(
+	store: PaymentStripeSecretStore,
+	name: typeof PAYMENT_STRIPE_SECRET_KEY | typeof PAYMENT_STRIPE_WEBHOOK_SECRET,
+	value: string | null | undefined,
+): Promise<void> {
+	if (value === undefined) return;
+	if (value === null) {
+		await store.delete(name);
+		return;
+	}
+	await store.set(name, value.trim());
+}
+
+function normalizeOptionalKey(value: string | null | undefined, current: string | null): string | null {
+	if (value === undefined) return current;
+	if (value === null) return null;
+	return value.trim() || null;
+}
+
+function normalizeOptionalSecret(value: string | null): string | null {
+	if (value === null) return null;
+	return value.trim() || null;
+}
+
+function validateUpdate(input: UpdatePaymentStripeConfigurationInput): void {
+	if (!Number.isSafeInteger(input.expectedVersion) || input.expectedVersion < 1) {
+		throw new PaymentConfigurationError("VALIDATION_ERROR", "Expected version is invalid");
+	}
+	if (input.publishableKey !== undefined && input.publishableKey !== null && input.publishableKey.length > 512) {
+		throw new PaymentConfigurationError("VALIDATION_ERROR", "Publishable key is too long");
+	}
+	if (input.secretKey !== undefined && input.secretKey !== null && input.secretKey.length > 512) {
+		throw new PaymentConfigurationError("VALIDATION_ERROR", "Secret key is too long");
+	}
+}
+
+function validateModeKeys(
+	mode: StripeMode,
+	publishableKey: string | null,
+	secretKey: string | null,
+	validateSecret: boolean,
+): void {
+	const keyMode = mode === "live" ? "live" : "test";
+	if (publishableKey && !publishableKey.startsWith(`pk_${keyMode}_`)) {
+		throw new PaymentConfigurationError(
+			"VALIDATION_ERROR",
+			`Publishable key must match ${mode} mode`,
+		);
+	}
+	if (validateSecret && secretKey && !secretKey.startsWith(`sk_${keyMode}_`)) {
+		throw new PaymentConfigurationError(
+			"VALIDATION_ERROR",
+			`Secret key must match ${mode} mode`,
+		);
+	}
+}