@dineway-ai/plugin-payment 0.2.1

package/src/configuration/types.ts

@@ -0,0 +1,38 @@
+import type { StripeMode, StripeTaxStatus } from "../types.js";
+
+export type PaymentStripeConfigurationStatus =
+	| "unconfigured"
+	| "unverified"
+	| "valid"
+	| "invalid";
+export type PaymentStripeConnectStatus = "not_configured" | "restricted" | "ready";
+
+export interface PaymentStripeSettings {
+	id: string;
+	mode: StripeMode;
+	publishableKey: string | null;
+	configurationStatus: PaymentStripeConfigurationStatus;
+	stripeAccountId: string | null;
+	chargesEnabled: boolean | null;
+	detailsSubmitted: boolean | null;
+	taxStatus: StripeTaxStatus;
+	validationErrorCode: string | null;
+	lastValidatedAt: string | null;
+	connectStatus: PaymentStripeConnectStatus;
+	version: number;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface UpdatePaymentStripeSettings {
+	mode?: StripeMode;
+	publishableKey?: string | null;
+	configurationStatus?: PaymentStripeConfigurationStatus;
+	stripeAccountId?: string | null;
+	chargesEnabled?: boolean | null;
+	detailsSubmitted?: boolean | null;
+	taxStatus?: StripeTaxStatus;
+	validationErrorCode?: string | null;
+	lastValidatedAt?: string | null;
+	connectStatus?: PaymentStripeConnectStatus;
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const PAYMENT_PLUGIN_ID = "dineway-payment";

package/src/index.ts

@@ -0,0 +1,55 @@
+import { definePlugin, getDb } from "dineway";
+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 { createPaymentRoutes } from "./routes/index.js";
+
+const PAYMENT_ADMIN_ENTRY = "@dineway-ai/plugin-payment/admin";
+const PAYMENT_ADMIN_PAGES = [{ path: "/payments", label: "Payments", icon: "credit-card" }] as const;
+
+export interface PaymentPluginOptions {
+	appName?: string;
+}
+
+export function paymentPlugin(
+	options: PaymentPluginOptions = {},
+): PluginDescriptor<PaymentPluginOptions> {
+	return {
+		id: PAYMENT_PLUGIN_ID,
+		version: packageVersion,
+		format: "native",
+		entrypoint: "@dineway-ai/plugin-payment",
+		adminEntry: PAYMENT_ADMIN_ENTRY,
+		adminPages: [...PAYMENT_ADMIN_PAGES],
+		options,
+		capabilities: ["network:request:unrestricted"],
+		allowedHosts: ["api.stripe.com"],
+	};
+}
+
+export function createPlugin(_options: PaymentPluginOptions = {}): ResolvedPlugin {
+	const ensurePaymentFoundation = async () => {
+		await new PaymentStripeConfigurationRepository(await getDb()).ensureDefaults();
+	};
+	const hooks: PluginHooks = {
+		"plugin:install": ensurePaymentFoundation,
+		"plugin:activate": ensurePaymentFoundation,
+	};
+	return definePlugin({
+		id: PAYMENT_PLUGIN_ID,
+		version: packageVersion,
+		capabilities: ["network:request:unrestricted"],
+		allowedHosts: ["api.stripe.com"],
+		admin: { entry: PAYMENT_ADMIN_ENTRY, pages: [...PAYMENT_ADMIN_PAGES] },
+		hooks,
+		routes: createPaymentRoutes(),
+	});
+}
+
+export * from "./configuration/index.js";
+export { PAYMENT_PLUGIN_ID } from "./constants.js";
+export * from "./stripe/index.js";
+export * from "./routes/index.js";
+export * from "./types.js";

package/src/routes/index.ts

@@ -0,0 +1,85 @@
+import type { z } from "astro/zod";
+import {
+	getDb,
+	PluginRouteError,
+	type PluginRoute,
+	type PluginSecretStoreOptions,
+	type RouteContext,
+} from "dineway";
+
+import {
+	getPaymentStripeConfiguration,
+	PaymentConfigurationError,
+	testPaymentStripeConnection,
+	updatePaymentStripeConfiguration,
+} from "../configuration/service.js";
+import { StripeNodeAccountProbe } from "../stripe/account-probe.js";
+import type { StripeAccountProbe } from "../types.js";
+import {
+	getPaymentStripeConfigurationSchema,
+	testPaymentStripeConnectionSchema,
+	updatePaymentStripeConfigurationSchema,
+} from "./schemas.js";
+
+const AUTHORIZATION = {
+	permission: "content:edit_any" as const,
+	anyOfTokenScopes: ["admin"],
+};
+
+export interface PaymentRouteOptions {
+	accountProbe?: StripeAccountProbe;
+	secretOptions?: PluginSecretStoreOptions;
+}
+
+export function createPaymentRoutes(options: PaymentRouteOptions = {}): Record<string, PluginRoute> {
+	const probe = options.accountProbe ?? new StripeNodeAccountProbe();
+	return {
+		"stripe/configuration/get": route(getPaymentStripeConfigurationSchema, async () => ({
+			configuration: await getPaymentStripeConfiguration(await getDb(), options.secretOptions),
+		})),
+		"stripe/configuration/update": route(
+			updatePaymentStripeConfigurationSchema,
+			async (context) => ({
+				configuration: await updatePaymentStripeConfiguration(
+					await getDb(),
+					context.input,
+					options.secretOptions,
+				),
+			}),
+		),
+		"stripe/configuration/test": route(testPaymentStripeConnectionSchema, async () => ({
+			configuration: await testPaymentStripeConnection(
+				await getDb(),
+				probe,
+				options.secretOptions,
+			),
+		})),
+	};
+}
+
+function route<T>(
+	input: z.ZodType<T>,
+	handler: (context: RouteContext<T>) => Promise<unknown>,
+): PluginRoute {
+	return {
+		methods: ["POST"],
+		input: input as never,
+		authorization: AUTHORIZATION,
+		handler: (async (context: RouteContext<T>) => runRoute(() => handler(context))) as never,
+	};
+}
+
+async function runRoute<T>(work: () => Promise<T>): Promise<T> {
+	try {
+		return await work();
+	} catch (error) {
+		if (!(error instanceof PaymentConfigurationError)) throw error;
+		throw new PluginRouteError(
+			error.code,
+			error.message,
+			error.code === "CONFLICT" || error.code === "INVALID_STATE" ? 409 : 400,
+		);
+	}
+}
+
+export * from "./schemas.js";

package/src/routes/schemas.ts

@@ -0,0 +1,15 @@
+import { z } from "astro/zod";
+
+export const getPaymentStripeConfigurationSchema = z.object({}).strict();
+
+export const updatePaymentStripeConfigurationSchema = z
+	.object({
+		expectedVersion: z.number().int().positive(),
+		mode: z.enum(["test", "live"]).optional(),
+		publishableKey: z.string().max(512).nullable().optional(),
+		secretKey: z.string().max(512).nullable().optional(),
+		webhookSecret: z.string().max(512).nullable().optional(),
+	})
+	.strict();
+
+export const testPaymentStripeConnectionSchema = z.object({}).strict();

package/src/stripe/account-probe.ts

@@ -0,0 +1,71 @@
+import Stripe from "stripe";
+
+import { stripeProviderFailure } from "./errors.js";
+import type {
+	StripeAccountProbe,
+	StripeAccountProbeInput,
+	StripeAccountProbeResult,
+} from "../types.js";
+
+export interface StripeAccountProbeClient {
+	retrieveCurrentAccount(): Promise<{
+		id: string;
+		chargesEnabled: boolean;
+		detailsSubmitted: boolean;
+	}>;
+	retrieveTaxSettings(): Promise<{
+		livemode: boolean;
+		status: "active" | "pending";
+	}>;
+}
+
+export type StripeAccountProbeClientFactory = (secretKey: string) => StripeAccountProbeClient;
+
+export class StripeNodeAccountProbe implements StripeAccountProbe {
+	constructor(
+		private readonly createClient: StripeAccountProbeClientFactory = createStripeAccountProbeClient,
+	) {}
+
+	async probe(input: StripeAccountProbeInput): Promise<StripeAccountProbeResult> {
+		try {
+			const client = this.createClient(input.secretKey);
+			const [account, taxSettings] = await Promise.all([
+				client.retrieveCurrentAccount(),
+				client.retrieveTaxSettings(),
+			]);
+			return {
+				ok: true,
+				accountId: account.id,
+				livemode: taxSettings.livemode,
+				chargesEnabled: account.chargesEnabled,
+				detailsSubmitted: account.detailsSubmitted,
+				taxStatus: taxSettings.status,
+			};
+		} catch (error) {
+			return { ok: false, errorCode: stripeProviderFailure(error).errorCode };
+		}
+	}
+}
+
+function createStripeAccountProbeClient(secretKey: string): StripeAccountProbeClient {
+	const stripe = new Stripe(secretKey, {
+		appInfo: { name: "Dineway Payments" },
+		maxNetworkRetries: 1,
+		timeout: 15_000,
+		typescript: true,
+	});
+	return {
+		async retrieveCurrentAccount() {
+			const account = await stripe.accounts.retrieveCurrent();
+			return {
+				id: account.id,
+				chargesEnabled: account.charges_enabled,
+				detailsSubmitted: account.details_submitted,
+			};
+		},
+		async retrieveTaxSettings() {
+			const settings = await stripe.tax.settings.retrieve();
+			return { livemode: settings.livemode, status: settings.status };
+		},
+	};
+}