@dineway-ai/plugin-payment 0.2.3 → 0.2.5

package/src/subscriptions/routes.ts

@@ -0,0 +1,146 @@
+import { z } from "astro/zod";
+import { getDb, PluginRouteError, type PluginRoute, type RouteContext } from "dineway";
+
+import {
+	PaymentStripeSecretStore,
+	PAYMENT_STRIPE_SUBSCRIPTION_WEBHOOK_SECRET,
+} from "../configuration/secrets.js";
+import { getPaymentSubscriptionService, getSubscriptionConfiguration } from "./runtime.js";
+import {
+	checkoutSchema,
+	portalSchema,
+	memberListSchema,
+	saveSubscriptionPlanSchema,
+	subscriptionIdSchema,
+} from "./schemas.js";
+import type { PaymentSubscriptionService } from "./service.js";
+import { SubscriptionError, type SubscriptionOptions } from "./types.js";
+
+const empty = z.object({}).strict();
+const secretSchema = z
+	.object({ webhookSecret: z.string().trim().startsWith("whsec_").max(512) })
+	.strict();
+type PaymentPermission = "payments:read_own" | "payments:manage_own" | "payments:manage";
+export interface SubscriptionRouteOptions {
+	service?: () => Promise<PaymentSubscriptionService>;
+}
+export function createSubscriptionRoutes(
+	options: SubscriptionOptions,
+	overrides: SubscriptionRouteOptions = {},
+): Record<string, PluginRoute> {
+	const service = overrides.service ?? (() => getPaymentSubscriptionService(options));
+	const privateRoute = <T>(
+		schema: z.ZodType<T>,
+		permission: PaymentPermission,
+		action: (context: RouteContext<T>) => Promise<unknown>,
+	): PluginRoute => ({
+		methods: ["POST"],
+		input: schema as never,
+		authorization: { permission, anyOfTokenScopes: ["admin"] },
+		handler: (async (context: RouteContext<T>) =>
+			run(async () => {
+				const actor = context.actor;
+				if (!actor || actor.type !== "user" || actor.authMethod !== "session" || !actor.userId) {
+					throw new SubscriptionError("UNAUTHORIZED", "A member session is required", 401);
+				}
+				if (permission === "payments:manage" && actor.role < 50)
+					throw new SubscriptionError("FORBIDDEN", "Administrator access is required", 403);
+				if (
+					context.request.headers.get("X-Dineway-Request") !== "1" ||
+					context.request.headers.get("Origin") !== new URL(options.siteUrl).origin
+				) {
+					throw new SubscriptionError("CSRF_REJECTED", "Use a same-origin request", 403);
+				}
+				return action(context);
+			})) as never,
+	});
+	const memberId = (context: RouteContext) => {
+		if (!context.actor?.userId)
+			throw new SubscriptionError("UNAUTHORIZED", "A member session is required", 401);
+		return context.actor.userId;
+	};
+	return {
+		"subscriptions/plans": {
+			methods: ["GET"],
+			public: true,
+			input: empty.default({}),
+			handler: async () => run(async () => ({ items: await (await service()).listPlans() })),
+		},
+		"subscriptions/checkout": privateRoute(checkoutSchema, "payments:manage_own", async (context) =>
+			(await service()).createCheckout(memberId(context), context.input),
+		),
+		"subscriptions/portal": privateRoute(portalSchema, "payments:manage_own", async (context) =>
+			(await service()).createPortal(memberId(context), context.input),
+		),
+		"subscriptions/member": privateRoute(empty, "payments:read_own", async (context) =>
+			(await service()).getMemberBilling(memberId(context)),
+		),
+		"subscriptions/entitlements": privateRoute(empty, "payments:read_own", async (context) => ({
+			entitlements: await (await service()).getEntitlements(memberId(context)),
+		})),
+		"subscriptions/configuration/get": privateRoute(empty, "payments:manage", async () =>
+			getSubscriptionConfiguration(options),
+		),
+		"subscriptions/configuration/update": privateRoute(
+			secretSchema,
+			"payments:manage",
+			async (context) => {
+				await new PaymentStripeSecretStore(await getDb()).set(
+					PAYMENT_STRIPE_SUBSCRIPTION_WEBHOOK_SECRET,
+					context.input.webhookSecret,
+				);
+				return getSubscriptionConfiguration(options);
+			},
+		),
+		"subscriptions/plans/list": privateRoute(empty, "payments:manage", async () => ({
+			items: await (await service()).listPlans(true),
+		})),
+		"subscriptions/plans/save": privateRoute(
+			saveSubscriptionPlanSchema,
+			"payments:manage",
+			async (context) => ({ plan: await (await service()).savePlan(context.input) }),
+		),
+		"subscriptions/list": privateRoute(memberListSchema, "payments:manage", async (context) =>
+			(await service()).listSubscriptions(context.input.cursor, context.input.limit),
+		),
+		"subscriptions/get": privateRoute(subscriptionIdSchema, "payments:manage", async (context) =>
+			(await service()).subscriptionDetail(context.input.subscriptionId),
+		),
+		"subscriptions/sync": privateRoute(subscriptionIdSchema, "payments:manage", async (context) => {
+			const client = await service();
+			await client.subscriptionDetail(context.input.subscriptionId);
+			await client.refreshSubscription(context.input.subscriptionId);
+			return client.subscriptionDetail(context.input.subscriptionId);
+		}),
+		"subscriptions/webhook": {
+			methods: ["POST"],
+			public: true,
+			body: "raw",
+			maxBodyBytes: 262144,
+			handler: async (context) =>
+				run(async () => {
+					if (!context.rawBody)
+						throw new SubscriptionError("INVALID_SIGNATURE", "A signed body is required");
+					await (
+						await service()
+					).receiveWebhook(context.rawBody, context.request.headers.get("Stripe-Signature"));
+					return { received: true };
+				}, true),
+		},
+	};
+}
+async function run<T>(action: () => Promise<T>, webhook = false): Promise<T> {
+	try {
+		return await action();
+	} catch (error) {
+		if (error instanceof SubscriptionError)
+			throw new PluginRouteError(error.code, error.message, error.status);
+		if (error instanceof z.ZodError)
+			throw new PluginRouteError("VALIDATION_ERROR", "Invalid subscription input", 400);
+		throw new PluginRouteError(
+			webhook ? "WEBHOOK_RETRY_REQUIRED" : "BILLING_UNAVAILABLE",
+			webhook ? "Retry this webhook" : "Billing is temporarily unavailable",
+			503,
+		);
+	}
+}

package/src/subscriptions/runtime.ts

@@ -0,0 +1,65 @@
+import { getDb, type PluginSecretStoreOptions } from "dineway";
+
+import {
+	PaymentStripeSecretStore,
+	PAYMENT_STRIPE_SECRET_KEY,
+	PAYMENT_STRIPE_SUBSCRIPTION_WEBHOOK_SECRET,
+} from "../configuration/secrets.js";
+import { getPaymentStripeConfiguration } from "../configuration/service.js";
+import { PaymentSubscriptionService } from "./service.js";
+import { SubscriptionError, type SubscriptionOptions } from "./types.js";
+
+export async function getPaymentSubscriptionService(
+	options: SubscriptionOptions,
+	secretOptions?: PluginSecretStoreOptions,
+): Promise<PaymentSubscriptionService> {
+	const db = await getDb();
+	const config = await getPaymentStripeConfiguration(db, secretOptions);
+	const store = new PaymentStripeSecretStore(db, secretOptions);
+	const secretKey = await store.resolveForRuntime(PAYMENT_STRIPE_SECRET_KEY);
+	const webhookSecret = await store.resolveForRuntime(PAYMENT_STRIPE_SUBSCRIPTION_WEBHOOK_SECRET);
+	if (
+		config.settings.configurationStatus !== "valid" ||
+		!config.settings.stripeAccountId ||
+		!secretKey ||
+		!webhookSecret
+	) {
+		throw new SubscriptionError(
+			"BILLING_UNAVAILABLE",
+			"Configure and verify Stripe and the subscription webhook first",
+			503,
+		);
+	}
+	return new PaymentSubscriptionService({
+		db,
+		scope: {
+			accountId: config.settings.stripeAccountId,
+			mode: config.settings.mode,
+			namespace: options.namespace,
+		},
+		siteUrl: options.siteUrl,
+		secretKey,
+		webhookSecret,
+	});
+}
+
+export async function getSubscriptionConfiguration(options: SubscriptionOptions) {
+	const db = await getDb();
+	const configuration = await getPaymentStripeConfiguration(db);
+	const webhookSecret = await new PaymentStripeSecretStore(db).status(
+		PAYMENT_STRIPE_SUBSCRIPTION_WEBHOOK_SECRET,
+	);
+	return {
+		namespace: options.namespace,
+		mode: configuration.settings.mode,
+		accountId: configuration.settings.stripeAccountId,
+		ready:
+			configuration.settings.configurationStatus === "valid" &&
+			Boolean(configuration.secretKey && webhookSecret),
+		webhookSecret,
+		webhookUrl: new URL(
+			"/_dineway/api/plugins/dineway-payment/subscriptions/webhook",
+			options.siteUrl,
+		).href,
+	};
+}

package/src/subscriptions/schemas.ts

@@ -0,0 +1,101 @@
+import { z } from "astro/zod";
+const unsafePath = /[\\\r\n]/;
+export const subscriptionLocale = z.enum([
+	"auto",
+	"bg",
+	"cs",
+	"da",
+	"de",
+	"el",
+	"en",
+	"en-GB",
+	"es",
+	"es-419",
+	"et",
+	"fi",
+	"fil",
+	"fr",
+	"fr-CA",
+	"hr",
+	"hu",
+	"id",
+	"it",
+	"ja",
+	"ko",
+	"lt",
+	"lv",
+	"ms",
+	"mt",
+	"nb",
+	"nl",
+	"pl",
+	"pt",
+	"pt-BR",
+	"ro",
+	"ru",
+	"sk",
+	"sl",
+	"sv",
+	"th",
+	"tr",
+	"vi",
+	"zh",
+	"zh-HK",
+	"zh-TW",
+]);
+
+export const subscriptionCode = z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
+export const entitlementSchema = z
+	.record(
+		z
+			.string()
+			.regex(/^[a-z][a-z0-9_.-]{0,95}$/)
+			.refine(
+				(key) => key !== "constructor" && key !== "prototype",
+				"Use a non-reserved entitlement key",
+			),
+		z.union([z.boolean(), z.number().finite().nonnegative()]),
+	)
+	.refine((value) => Object.keys(value).length <= 100, "At most 100 entitlements are supported");
+export const saveSubscriptionPlanSchema = z
+	.object({
+		code: subscriptionCode,
+		name: z.string().trim().min(1).max(160),
+		enabled: z.boolean(),
+		expectedVersion: z.number().int().nonnegative(),
+		entitlements: entitlementSchema,
+		monthlyPriceId: z
+			.string()
+			.regex(/^price_[A-Za-z0-9]+$/)
+			.nullable(),
+		yearlyPriceId: z
+			.string()
+			.regex(/^price_[A-Za-z0-9]+$/)
+			.nullable(),
+	})
+	.strict();
+export const subscriptionReturnPath = z
+	.string()
+	.max(1024)
+	.refine(
+		(value) => value.startsWith("/") && !value.startsWith("//") && !unsafePath.test(value),
+		"Use a relative return path",
+	);
+export const checkoutSchema = z
+	.object({
+		planCode: subscriptionCode,
+		interval: z.enum(["month", "year"]),
+		locale: subscriptionLocale.optional(),
+		returnPath: subscriptionReturnPath,
+	})
+	.strict();
+export const portalSchema = checkoutSchema.pick({ locale: true, returnPath: true });
+export const memberListSchema = z
+	.object({
+		cursor: z.string().max(255).optional(),
+		limit: z.number().int().min(1).max(100).default(50),
+	})
+	.strict();
+export const subscriptionIdSchema = z
+	.object({ subscriptionId: z.string().regex(/^sub_[A-Za-z0-9]+$/) })
+	.strict();