@faire-auth/stripe 1.0.0

package/dist/index.mjs

@@ -0,0 +1,968 @@
+import { callbackURLSchema, createRoute, redirectUrlSchema, req, res } from "@faire-auth/core/factory";
+import { False, True } from "@faire-auth/core/static";
+import { logger } from "faire-auth";
+import { getSessionFromCtx, originCheck, sessionMiddleware } from "faire-auth/middleware";
+import { createEndpoint, createMiddleware } from "faire-auth/plugins";
+import Stripe from "stripe";
+import * as z from "zod";
+import { mergeSchema } from "faire-auth/db";
+
+//#region src/utils.ts
+async function getPlans(subscriptionOptions) {
+	if (subscriptionOptions?.enabled) return typeof subscriptionOptions.plans === "function" ? await subscriptionOptions.plans() : subscriptionOptions.plans;
+	throw new Error("Subscriptions are not enabled in the Stripe options.");
+}
+async function getPlanByPriceInfo(options, priceId, priceLookupKey) {
+	return await getPlans(options.subscription).then((res$1) => res$1?.find((plan) => plan.priceId === priceId || plan.annualDiscountPriceId === priceId || priceLookupKey && (plan.lookupKey === priceLookupKey || plan.annualDiscountLookupKey === priceLookupKey)));
+}
+async function getPlanByName(options, name) {
+	return await getPlans(options.subscription).then((res$1) => res$1?.find((plan) => plan.name.toLowerCase() === name.toLowerCase()));
+}
+
+//#endregion
+//#region src/hooks.ts
+async function onCheckoutSessionCompleted(ctx, options, event) {
+	try {
+		const client = options.stripeClient;
+		const checkoutSession = event.data.object;
+		if (checkoutSession.mode === "setup" || !options.subscription?.enabled) return;
+		const subscription = await client.subscriptions.retrieve(checkoutSession.subscription);
+		const priceId = subscription.items.data[0]?.price.id;
+		const plan = await getPlanByPriceInfo(options, priceId, subscription.items.data[0]?.price.lookup_key || null);
+		if (plan) {
+			const referenceId = checkoutSession?.client_reference_id || checkoutSession?.metadata?.referenceId;
+			const subscriptionId = checkoutSession?.metadata?.subscriptionId;
+			const seats = subscription.items.data[0].quantity;
+			if (referenceId && subscriptionId) {
+				const trial = subscription.trial_start && subscription.trial_end ? {
+					trialStart: /* @__PURE__ */ new Date(subscription.trial_start * 1e3),
+					trialEnd: /* @__PURE__ */ new Date(subscription.trial_end * 1e3)
+				} : {};
+				let dbSubscription = await ctx.get("context").adapter.update({
+					model: "subscription",
+					update: {
+						plan: plan.name.toLowerCase(),
+						status: subscription.status,
+						updatedAt: /* @__PURE__ */ new Date(),
+						periodStart: /* @__PURE__ */ new Date(subscription.items.data[0].current_period_start * 1e3),
+						periodEnd: /* @__PURE__ */ new Date(subscription.items.data[0].current_period_end * 1e3),
+						stripeSubscriptionId: checkoutSession.subscription,
+						seats,
+						...trial
+					},
+					where: [{
+						field: "id",
+						value: subscriptionId
+					}]
+				});
+				if (trial.trialStart && plan.freeTrial?.onTrialStart) await plan.freeTrial.onTrialStart(dbSubscription);
+				if (!dbSubscription) dbSubscription = await ctx.get("context").adapter.findOne({
+					model: "subscription",
+					where: [{
+						field: "id",
+						value: subscriptionId
+					}]
+				});
+				await options.subscription?.onSubscriptionComplete?.({
+					event,
+					subscription: dbSubscription,
+					stripeSubscription: subscription,
+					plan
+				}, ctx);
+				return;
+			}
+		}
+	} catch (e) {
+		logger.error(`Stripe webhook failed. Error: ${e.message}`);
+	}
+}
+async function onSubscriptionUpdated(ctx, options, event) {
+	try {
+		if (!options.subscription?.enabled) return;
+		const subscriptionUpdated = event.data.object;
+		const priceId = subscriptionUpdated.items.data[0].price.id;
+		const plan = await getPlanByPriceInfo(options, priceId, subscriptionUpdated.items.data[0].price.lookup_key || null);
+		const subscriptionId = subscriptionUpdated.metadata?.subscriptionId;
+		const customerId = subscriptionUpdated.customer?.toString();
+		let subscription = await ctx.get("context").adapter.findOne({
+			model: "subscription",
+			where: subscriptionId ? [{
+				field: "id",
+				value: subscriptionId
+			}] : [{
+				field: "stripeSubscriptionId",
+				value: subscriptionUpdated.id
+			}]
+		});
+		if (!subscription) {
+			const subs = await ctx.get("context").adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "stripeCustomerId",
+					value: customerId
+				}]
+			});
+			if (subs.length > 1) {
+				const activeSub = subs.find((sub) => sub.status === "active" || sub.status === "trialing");
+				if (!activeSub) {
+					logger.warn(`Stripe webhook error: Multiple subscriptions found for customerId: ${customerId} and no active subscription is found`);
+					return;
+				}
+				subscription = activeSub;
+			} else subscription = subs[0];
+		}
+		const seats = subscriptionUpdated.items.data[0].quantity;
+		await ctx.get("context").adapter.update({
+			model: "subscription",
+			update: {
+				...plan ? {
+					plan: plan.name.toLowerCase(),
+					limits: plan.limits
+				} : {},
+				updatedAt: /* @__PURE__ */ new Date(),
+				status: subscriptionUpdated.status,
+				periodStart: /* @__PURE__ */ new Date(subscriptionUpdated.items.data[0].current_period_start * 1e3),
+				periodEnd: /* @__PURE__ */ new Date(subscriptionUpdated.items.data[0].current_period_end * 1e3),
+				cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
+				seats,
+				stripeSubscriptionId: subscriptionUpdated.id
+			},
+			where: [{
+				field: "id",
+				value: subscription.id
+			}]
+		});
+		if (subscriptionUpdated.status === "active" && subscriptionUpdated.cancel_at_period_end && !subscription.cancelAtPeriodEnd) await options.subscription.onSubscriptionCancel?.({
+			subscription,
+			...subscriptionUpdated.cancellation_details !== void 0 && { cancellationDetails: subscriptionUpdated.cancellation_details },
+			stripeSubscription: subscriptionUpdated,
+			event
+		});
+		await options.subscription.onSubscriptionUpdate?.({
+			event,
+			subscription
+		});
+		if (plan) {
+			if (subscriptionUpdated.status === "active" && subscription.status === "trialing" && plan.freeTrial?.onTrialEnd) await plan.freeTrial.onTrialEnd({ subscription }, ctx);
+			if (subscriptionUpdated.status === "incomplete_expired" && subscription.status === "trialing" && plan.freeTrial?.onTrialExpired) await plan.freeTrial.onTrialExpired(subscription, ctx);
+		}
+	} catch (error) {
+		logger.error(`Stripe webhook failed. Error: ${error}`);
+	}
+}
+async function onSubscriptionDeleted(ctx, options, event) {
+	if (!options.subscription?.enabled) return;
+	try {
+		const subscriptionDeleted = event.data.object;
+		const subscriptionId = subscriptionDeleted.id;
+		const subscription = await ctx.get("context").adapter.findOne({
+			model: "subscription",
+			where: [{
+				field: "stripeSubscriptionId",
+				value: subscriptionId
+			}]
+		});
+		if (subscription) {
+			await ctx.get("context").adapter.update({
+				model: "subscription",
+				where: [{
+					field: "id",
+					value: subscription.id
+				}],
+				update: {
+					status: "canceled",
+					updatedAt: /* @__PURE__ */ new Date()
+				}
+			});
+			await options.subscription.onSubscriptionDeleted?.({
+				event,
+				stripeSubscription: subscriptionDeleted,
+				subscription
+			});
+		} else logger.warn(`Stripe webhook error: Subscription not found for subscriptionId: ${subscriptionId}`);
+	} catch (error) {
+		logger.error(`Stripe webhook failed. Error: ${error}`);
+	}
+}
+
+//#endregion
+//#region src/schema.ts
+const subscriptions = { subscription: { fields: {
+	plan: {
+		type: "string",
+		required: true
+	},
+	referenceId: {
+		type: "string",
+		required: true
+	},
+	stripeCustomerId: {
+		type: "string",
+		required: false
+	},
+	stripeSubscriptionId: {
+		type: "string",
+		required: false
+	},
+	status: {
+		type: "string",
+		defaultValue: "incomplete"
+	},
+	periodStart: {
+		type: "date",
+		required: false
+	},
+	periodEnd: {
+		type: "date",
+		required: false
+	},
+	trialStart: {
+		type: "date",
+		required: false
+	},
+	trialEnd: {
+		type: "date",
+		required: false
+	},
+	cancelAtPeriodEnd: {
+		type: "boolean",
+		required: false,
+		defaultValue: false
+	},
+	seats: {
+		type: "number",
+		required: false
+	}
+} } };
+const user = { user: { fields: { stripeCustomerId: {
+	type: "string",
+	required: false
+} } } };
+const getSchema = (options) => {
+	let baseSchema = {};
+	if (options.subscription?.enabled) baseSchema = {
+		...subscriptions,
+		...user
+	};
+	else baseSchema = { ...user };
+	if (options.schema && !options.subscription?.enabled && "subscription" in options.schema) {
+		const { subscription,...restSchema } = options.schema;
+		return mergeSchema(baseSchema, restSchema);
+	}
+	return mergeSchema(baseSchema, options.schema);
+};
+
+//#endregion
+//#region src/index.ts
+const STRIPE_ERROR_CODES = {
+	SUBSCRIPTION_NOT_FOUND: "Subscription not found",
+	SUBSCRIPTION_PLAN_NOT_FOUND: "Subscription plan not found",
+	ALREADY_SUBSCRIBED_PLAN: "You're already subscribed to this plan",
+	UNABLE_TO_CREATE_CUSTOMER: "Unable to create customer",
+	FAILED_TO_FETCH_PLANS: "Failed to fetch plans",
+	EMAIL_VERIFICATION_REQUIRED: "Email verification is required before you can subscribe to a plan",
+	SUBSCRIPTION_NOT_ACTIVE: "Subscription is not active",
+	SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION: "Subscription is not scheduled for cancellation"
+};
+const getUrl = (options, url) => {
+	if (url.startsWith("http")) return url;
+	return `${options.baseURL}${url.startsWith("/") ? url : `/${url}`}`;
+};
+async function resolvePriceIdFromLookupKey(stripeClient, lookupKey) {
+	if (!lookupKey) return void 0;
+	return (await stripeClient.prices.list({
+		lookup_keys: [lookupKey],
+		active: true,
+		limit: 1
+	})).data[0]?.id;
+}
+const stripe = (options) => {
+	const client = options.stripeClient;
+	const referenceMiddleware = (action) => createMiddleware()(async (ctx, next) => {
+		const session = ctx.get("session");
+		if (!session) return ctx.json({ success: False }, 401);
+		if (!options.subscription?.enabled) {
+			logger.error(`Subscription actions are not enabled in your stripe plugin config.`);
+			return ctx.json({ success: False }, 400);
+		}
+		let body = {};
+		let bodyHasId = false;
+		try {
+			body = await ctx.req.raw.clone().json();
+		} catch {}
+		if (body.referenceId) bodyHasId = true;
+		else body.referenceId = ctx.req.query("referenceId") ?? session.user.id;
+		if (bodyHasId && !options.subscription?.authorizeReference) {
+			logger.error(`Passing referenceId into a subscription action isn't allowed if subscription.authorizeReference isn't defined in your stripe plugin config.`);
+			return ctx.json({
+				success: False,
+				message: "Reference id is not allowed. Read server logs for more details."
+			}, 400);
+		}
+		if (!(bodyHasId ? await options.subscription?.authorizeReference?.({
+			user: session.user,
+			session: session.session,
+			referenceId: body.referenceId,
+			action
+		}, ctx) : true)) return ctx.json({ success: False }, 401);
+		return await next();
+	});
+	const subscriptionEndpoints = {
+		upgradeSubscription: createEndpoint(createRoute({
+			operationId: "upgradeSubscription",
+			method: "post",
+			path: "/subscription/upgrade",
+			middleware: [
+				sessionMiddleware(),
+				originCheck(async (ctx) => {
+					const { successURL, cancelURL } = await ctx.req.raw.clone().json();
+					return [successURL, cancelURL];
+				}),
+				referenceMiddleware("upgrade-subscription")
+			],
+			request: req().bdy(z.object({
+				plan: z.string().meta({ description: "The name of the plan to upgrade to. Eg: \"pro\"" }),
+				annual: z.boolean().meta({ description: "Whether to upgrade to an annual plan. Eg: true" }).optional(),
+				referenceId: z.string().meta({ description: "Reference id of the subscription to upgrade. Eg: \"123\"" }).optional(),
+				subscriptionId: z.string().meta({ description: "The id of the subscription to upgrade. Eg: \"sub_123\"" }).optional(),
+				metadata: z.record(z.string(), z.any()).optional(),
+				seats: z.number().meta({ description: "Number of seats to upgrade to (if applicable). Eg: 1" }).optional(),
+				successUrl: z.string().meta({ description: "Callback URL to redirect back after successful subscription. Eg: \"https://example.com/success\"" }).default("/"),
+				cancelUrl: z.string().meta({ description: "If set, checkout shows a back button and customers will be directed here if they cancel payment. Eg: \"https://example.com/pricing\"" }).default("/"),
+				returnUrl: z.string().meta({ description: "URL to take customers to when they click on the billing portal’s link to return to your website. Eg: \"https://example.com/dashboard\"" }).optional(),
+				disableRedirect: z.boolean().meta({ description: "Disable redirect after successful subscription. Eg: true" }).default(false)
+			})).bld(),
+			responses: res(z.intersection(redirectUrlSchema, z.record(z.string(), z.any()))).err(400).err(401).err(500).bld()
+		}), (authOptions) => async (ctx) => {
+			if (!options.subscription?.enabled) {
+				logger.error(`Subscription actions are not enabled in your stripe plugin config.`);
+				return ctx.json({ success: False }, 400);
+			}
+			const { user: user$1, session } = ctx.get("session");
+			if (!user$1.emailVerified && options.subscription?.enabled && options.subscription.requireEmailVerification) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.EMAIL_VERIFICATION_REQUIRED
+			}, 400);
+			const { referenceId = user$1.id, plan: requestPlan, subscriptionId, metadata, seats, returnUrl, cancelUrl, disableRedirect, successUrl, annual } = ctx.req.valid("json");
+			const plan = await getPlanByName(options, requestPlan);
+			if (!plan) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_PLAN_NOT_FOUND
+			}, 400);
+			const subscriptionToUpdate = subscriptionId ? await ctx.get("context").adapter.findOne({
+				model: "subscription",
+				where: [{
+					field: "id",
+					value: subscriptionId,
+					connector: "OR"
+				}, {
+					field: "stripeSubscriptionId",
+					value: subscriptionId,
+					connector: "OR"
+				}]
+			}) : referenceId ? await ctx.get("context").adapter.findOne({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId
+				}]
+			}) : null;
+			if (subscriptionId && !subscriptionToUpdate) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+			}, 400);
+			let customerId = subscriptionToUpdate?.stripeCustomerId || user$1.stripeCustomerId;
+			if (!customerId) try {
+				let stripeCustomer = (await client.customers.list({
+					email: user$1.email,
+					limit: 1
+				})).data[0];
+				if (!stripeCustomer) stripeCustomer = await client.customers.create({
+					email: user$1.email,
+					...user$1.name && { name: user$1.name },
+					metadata: {
+						...metadata,
+						userId: user$1.id
+					}
+				});
+				await ctx.get("context").adapter.update({
+					model: "user",
+					update: { stripeCustomerId: stripeCustomer.id },
+					where: [{
+						field: "id",
+						value: user$1.id
+					}]
+				});
+				customerId = stripeCustomer.id;
+			} catch (e) {
+				ctx.get("context").logger.error(e);
+				return ctx.json({
+					success: False,
+					message: STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER
+				}, 400);
+			}
+			const activeSubscription = (await client.subscriptions.list({ customer: customerId }).then((res$1) => res$1.data.filter((sub) => sub.status === "active" || sub.status === "trialing"))).find((sub) => subscriptionToUpdate?.stripeSubscriptionId || subscriptionId ? sub.id === subscriptionToUpdate?.stripeSubscriptionId || sub.id === subscriptionId : false);
+			const subscriptions$1 = subscriptionToUpdate ? [subscriptionToUpdate] : await ctx.get("context").adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId || user$1.id
+				}]
+			});
+			const activeOrTrialingSubscription = subscriptions$1.find((sub) => sub.status === "active" || sub.status === "trialing");
+			const incompleteSubscription = subscriptions$1.find((sub) => sub.status === "incomplete");
+			if (activeOrTrialingSubscription && activeOrTrialingSubscription.status === "active" && activeOrTrialingSubscription.plan === requestPlan && activeOrTrialingSubscription.seats === (seats || 1)) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.ALREADY_SUBSCRIBED_PLAN
+			}, 400);
+			if (activeSubscription && customerId) {
+				const res$1 = await client.billingPortal.sessions.create({
+					customer: customerId,
+					return_url: getUrl(authOptions, returnUrl || "/"),
+					flow_data: {
+						type: "subscription_update_confirm",
+						after_completion: {
+							type: "redirect",
+							redirect: { return_url: getUrl(authOptions, returnUrl || "/") }
+						},
+						subscription_update_confirm: {
+							subscription: activeSubscription.id,
+							items: [{
+								id: activeSubscription.items.data[0]?.id,
+								quantity: seats || 1,
+								price: annual ? plan.annualDiscountPriceId : plan.priceId
+							}]
+						}
+					}
+				}).catch(async (e) => ctx.json({
+					success: False,
+					message: e.message,
+					code: e.code
+				}, 400));
+				if (res$1 instanceof Response) return res$1;
+				return ctx.json({
+					url: res$1.url,
+					redirect: True
+				}, 200);
+			}
+			let subscription = activeOrTrialingSubscription || incompleteSubscription;
+			if (incompleteSubscription && !activeOrTrialingSubscription) subscription = await ctx.get("context").adapter.update({
+				model: "subscription",
+				update: {
+					plan: plan.name.toLowerCase(),
+					seats: seats || 1,
+					updatedAt: /* @__PURE__ */ new Date()
+				},
+				where: [{
+					field: "id",
+					value: incompleteSubscription.id
+				}]
+			}) || incompleteSubscription;
+			if (!subscription) subscription = await ctx.get("context").adapter.create({
+				model: "subscription",
+				data: {
+					plan: plan.name.toLowerCase(),
+					stripeCustomerId: customerId,
+					status: "incomplete",
+					referenceId,
+					seats: seats || 1
+				}
+			});
+			if (!subscription) {
+				ctx.get("context").logger.error("Subscription ID not found");
+				return ctx.json({ success: False }, 500);
+			}
+			const params = await options.subscription?.getCheckoutSessionParams?.({
+				user: user$1,
+				session,
+				plan,
+				subscription
+			}, ctx);
+			const freeTrial = !subscriptions$1.some((s) => {
+				return !!(s.trialStart || s.trialEnd) || s.status === "trialing";
+			}) && plan.freeTrial ? { trial_period_days: plan.freeTrial.days } : void 0;
+			let priceIdToUse = void 0;
+			if (annual) {
+				priceIdToUse = plan.annualDiscountPriceId;
+				if (!priceIdToUse && plan.annualDiscountLookupKey) priceIdToUse = await resolvePriceIdFromLookupKey(client, plan.annualDiscountLookupKey);
+			} else {
+				priceIdToUse = plan.priceId;
+				if (!priceIdToUse && plan.lookupKey) priceIdToUse = await resolvePriceIdFromLookupKey(client, plan.lookupKey);
+			}
+			const checkoutSession = await client.checkout.sessions.create({
+				...customerId ? {
+					customer: customerId,
+					customer_update: {
+						name: "auto",
+						address: "auto"
+					}
+				} : { customer_email: user$1.email },
+				success_url: getUrl(authOptions, `${ctx.get("context").baseURL}/subscription/success?callbackURL=${encodeURIComponent(successUrl)}&subscriptionId=${encodeURIComponent(subscription.id)}`),
+				cancel_url: getUrl(authOptions, cancelUrl),
+				line_items: [{
+					price: priceIdToUse,
+					quantity: seats || 1
+				}],
+				subscription_data: { ...freeTrial },
+				mode: "subscription",
+				client_reference_id: referenceId,
+				...params?.params,
+				metadata: {
+					userId: user$1.id,
+					subscriptionId: subscription.id,
+					referenceId,
+					...params?.params?.metadata
+				}
+			}, params?.options).catch(async (e) => ctx.json({
+				success: False,
+				message: e.message,
+				code: e.code
+			}, 400));
+			if (checkoutSession instanceof Response) return checkoutSession;
+			return ctx.json({
+				...checkoutSession,
+				redirect: !disableRedirect
+			}, 200);
+		}),
+		cancelSubscriptionCallback: createEndpoint(createRoute({
+			operationId: "cancelSubscriptionCallback",
+			method: "get",
+			path: "/subscription/cancel/callback",
+			middleware: [originCheck((ctx) => ctx.req.query("callbackURL"))],
+			request: req().qry(z.object({
+				callbackURL: callbackURLSchema(true),
+				subscriptionId: z.string().optional()
+			})).bld(),
+			responses: res().rdr().bld()
+		}), (authOptions) => async (ctx) => {
+			if (!options.subscription?.enabled) {
+				logger.error(`Subscription actions are not enabled in your stripe plugin config.`);
+				return ctx.json({ success: False }, 400);
+			}
+			const { callbackURL, subscriptionId } = ctx.req.valid("query");
+			if (!callbackURL || !subscriptionId) return ctx.redirect(getUrl(authOptions, callbackURL || "/"), 302);
+			const session = await getSessionFromCtx(ctx);
+			if (session instanceof Response) return ctx.redirect(getUrl(authOptions, callbackURL || "/"), 302);
+			if (session.user?.stripeCustomerId) try {
+				const subscription = await ctx.get("context").adapter.findOne({
+					model: "subscription",
+					where: [{
+						field: "id",
+						value: subscriptionId
+					}]
+				});
+				if (!subscription || subscription.cancelAtPeriodEnd || subscription.status === "canceled") return ctx.redirect(getUrl(authOptions, callbackURL), 302);
+				const currentSubscription = (await client.subscriptions.list({
+					customer: session.user.stripeCustomerId,
+					status: "active"
+				})).data.find((sub) => sub.id === subscription.stripeSubscriptionId);
+				if (currentSubscription?.cancel_at_period_end === true) {
+					await ctx.get("context").adapter.update({
+						model: "subscription",
+						update: {
+							status: currentSubscription?.status,
+							cancelAtPeriodEnd: true
+						},
+						where: [{
+							field: "id",
+							value: subscription.id
+						}]
+					});
+					await options.subscription?.onSubscriptionCancel?.({
+						subscription,
+						cancellationDetails: currentSubscription.cancellation_details,
+						stripeSubscription: currentSubscription,
+						event: void 0
+					});
+				}
+			} catch (error) {
+				ctx.get("context").logger.error("Error checking subscription status from Stripe", error);
+			}
+			return ctx.redirect(getUrl(authOptions, callbackURL), 302);
+		}),
+		cancelSubscription: createEndpoint(createRoute({
+			operationId: "cancelSubscription",
+			method: "post",
+			path: "/subscription/cancel",
+			middleware: [
+				sessionMiddleware(),
+				originCheck((ctx) => ctx.req.raw.clone().json().then((v) => v.returnUrl)),
+				referenceMiddleware("cancel-subscription")
+			],
+			request: req().bdy(z.object({
+				referenceId: z.string().meta({ description: "Reference id of the subscription to cancel. Eg: '123'" }).optional(),
+				subscriptionId: z.string().meta({ description: "The id of the subscription to cancel. Eg: 'sub_123'" }).optional(),
+				returnUrl: z.string().meta({ description: "URL to take customers to when they click on the billing portal’s link to return to your website. Eg: \"https://example.com/dashboard\"" })
+			})).bld(),
+			responses: res(z.object({
+				url: z.string(),
+				redirect: z.literal(true)
+			})).err(400).err(401).bld()
+		}), (authOptions) => async (ctx) => {
+			const session = ctx.get("session");
+			const { referenceId = session.user.id, subscriptionId, returnUrl } = ctx.req.valid("json");
+			const subscription = subscriptionId ? await ctx.get("context").adapter.findOne({
+				model: "subscription",
+				where: [{
+					field: "id",
+					value: subscriptionId
+				}]
+			}) : await ctx.get("context").adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId
+				}]
+			}).then((subs) => subs.find((sub) => sub.status === "active" || sub.status === "trialing"));
+			if (!subscription || !subscription.stripeCustomerId) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+			}, 400);
+			const activeSubscriptions = await client.subscriptions.list({ customer: subscription.stripeCustomerId }).then((res$2) => res$2.data.filter((sub) => sub.status === "active" || sub.status === "trialing"));
+			if (!activeSubscriptions.length) {
+				/**
+				* If the subscription is not found, we need to delete the subscription
+				* from the database. This is a rare case and should not happen.
+				*/
+				await ctx.get("context").adapter.deleteMany({
+					model: "subscription",
+					where: [{
+						field: "referenceId",
+						value: referenceId
+					}]
+				});
+				return ctx.json({
+					success: False,
+					message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+				}, 400);
+			}
+			const activeSubscription = activeSubscriptions.find((sub) => sub.id === subscription.stripeSubscriptionId);
+			if (!activeSubscription) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+			}, 400);
+			const res$1 = await client.billingPortal.sessions.create({
+				customer: subscription.stripeCustomerId,
+				return_url: getUrl(authOptions, `${ctx.get("context").baseURL}/subscription/cancel/callback?callbackURL=${encodeURIComponent(returnUrl || "/")}&subscriptionId=${encodeURIComponent(subscription.id)}`),
+				flow_data: {
+					type: "subscription_cancel",
+					subscription_cancel: { subscription: activeSubscription.id }
+				}
+			}).catch(async (e) => {
+				if (e.message.includes("already set to be cancel")) {
+					/**
+					* incase we missed the event from stripe, we set it manually
+					* this is a rare case and should not happen
+					*/
+					if (!subscription.cancelAtPeriodEnd) await ctx.get("context").adapter.update({
+						model: "subscription",
+						update: { cancelAtPeriodEnd: true },
+						where: [{
+							field: "referenceId",
+							value: referenceId
+						}]
+					});
+				}
+				return ctx.json({
+					success: False,
+					message: e.message,
+					code: e.code
+				}, 400);
+			});
+			if (res$1 instanceof Response) return res$1;
+			return ctx.json({
+				url: res$1.url,
+				redirect: True
+			}, 200);
+		}),
+		restoreSubscription: createEndpoint(createRoute({
+			operationId: "restoreSubscription",
+			method: "post",
+			path: "/subscription/restore",
+			middleware: [sessionMiddleware(), referenceMiddleware("restore-subscription")],
+			request: req().bdy(z.object({
+				referenceId: z.string().meta({ description: "Reference id of the subscription to restore. Eg: '123'" }).optional(),
+				subscriptionId: z.string().meta({ description: "The id of the subscription to restore. Eg: 'sub_123'" }).optional()
+			})).bld(),
+			responses: res(z.looseObject({})).err(400).err(401).bld()
+		}), (authOptions) => async (ctx) => {
+			const session = ctx.get("session");
+			const { referenceId = session.user.id, subscriptionId } = ctx.req.valid("json");
+			const subscription = subscriptionId ? await ctx.get("context").adapter.findOne({
+				model: "subscription",
+				where: [{
+					field: "id",
+					value: subscriptionId
+				}]
+			}) : await ctx.get("context").adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId
+				}]
+			}).then((subs) => subs.find((sub) => sub.status === "active" || sub.status === "trialing"));
+			if (!subscription || !subscription.stripeCustomerId) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+			}, 400);
+			if (subscription.status != "active" && subscription.status != "trialing") return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_ACTIVE
+			}, 400);
+			if (!subscription.cancelAtPeriodEnd) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION
+			}, 400);
+			const activeSubscription = await client.subscriptions.list({ customer: subscription.stripeCustomerId }).then((res$1) => res$1.data.filter((sub) => sub.status === "active" || sub.status === "trialing")[0]);
+			if (!activeSubscription) return ctx.json({
+				success: False,
+				message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+			}, 400);
+			try {
+				const newSub = await client.subscriptions.update(activeSubscription.id, { cancel_at_period_end: false });
+				await ctx.get("context").adapter.update({
+					model: "subscription",
+					update: {
+						cancelAtPeriodEnd: false,
+						updatedAt: /* @__PURE__ */ new Date()
+					},
+					where: [{
+						field: "id",
+						value: subscription.id
+					}]
+				});
+				return ctx.json(newSub, 200);
+			} catch (error) {
+				ctx.get("context").logger.error("Error restoring subscription", error);
+				return ctx.json({
+					success: False,
+					message: STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER
+				}, 400);
+			}
+		}),
+		listActiveSubscriptions: createEndpoint(createRoute({
+			operationId: "listActiveSubscriptions",
+			method: "get",
+			path: "/subscription/list",
+			middleware: [sessionMiddleware(), referenceMiddleware("list-subscription")],
+			request: req().qry(z.object({ referenceId: z.string().meta({ description: "Reference id of the subscription to list. Eg: '123'" }).optional() })).bld(),
+			responses: res(z.array(z.looseObject({}))).err(400).err(401).bld()
+		}), (_authOptions) => async (ctx) => {
+			if (!options.subscription?.enabled) {
+				logger.error(`Subscription actions are not enabled in your stripe plugin config.`);
+				return ctx.json({ success: False }, 400);
+			}
+			const session = ctx.get("session");
+			const { referenceId = session.user.id } = ctx.req.valid("query");
+			const subscriptions$1 = await ctx.get("context").adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId
+				}]
+			});
+			if (!subscriptions$1.length) return ctx.json([], 200);
+			const plans = await getPlans(options.subscription);
+			if (!plans) return ctx.json([], 200);
+			const subs = subscriptions$1.map((sub) => {
+				const plan = plans.find((p) => p.name.toLowerCase() === sub.plan.toLowerCase());
+				return {
+					...sub,
+					limits: plan?.limits,
+					priceId: plan?.priceId
+				};
+			}).filter((sub) => sub.status === "active" || sub.status === "trialing");
+			return ctx.json(subs, 200);
+		}),
+		subscriptionSuccess: createEndpoint(createRoute({
+			operationId: "subscriptionSuccess",
+			method: "get",
+			path: "/subscription/success",
+			middleware: [originCheck((ctx) => ctx.req.query("callbackURL"))],
+			request: req().qry(z.object({
+				callbackURL: callbackURLSchema(true),
+				subscriptionId: z.string().optional()
+			})).bld(),
+			responses: res().rdr().bld()
+		}), (authOptions) => async (ctx) => {
+			const { callbackURL, subscriptionId } = ctx.req.valid("query");
+			if (!callbackURL || !subscriptionId) return ctx.redirect(getUrl(authOptions, callbackURL || "/"), 302);
+			const session = await getSessionFromCtx(ctx);
+			if (session instanceof Response) return ctx.redirect(getUrl(authOptions, callbackURL || "/"), 302);
+			const subscription = await ctx.get("context").adapter.findOne({
+				model: "subscription",
+				where: [{
+					field: "id",
+					value: subscriptionId
+				}]
+			});
+			if (subscription?.status === "active" || subscription?.status === "trialing") return ctx.redirect(getUrl(authOptions, callbackURL), 302);
+			const customerId = subscription?.stripeCustomerId || session.user.stripeCustomerId;
+			if (customerId) try {
+				const stripeSubscription = await client.subscriptions.list({
+					customer: customerId,
+					status: "active"
+				}).then((res$1) => res$1.data[0]);
+				if (stripeSubscription) {
+					const firstItem = stripeSubscription.items.data[0];
+					if (firstItem) {
+						const plan = await getPlanByPriceInfo(options, firstItem.price.id, firstItem.price.lookup_key);
+						if (plan && subscription) await ctx.get("context").adapter.update({
+							model: "subscription",
+							update: {
+								status: stripeSubscription.status,
+								seats: firstItem.quantity || 1,
+								plan: plan.name.toLowerCase(),
+								periodEnd: /* @__PURE__ */ new Date(firstItem.current_period_end * 1e3),
+								periodStart: /* @__PURE__ */ new Date(firstItem.current_period_start * 1e3),
+								stripeSubscriptionId: stripeSubscription.id,
+								...stripeSubscription.trial_start && stripeSubscription.trial_end ? {
+									trialStart: /* @__PURE__ */ new Date(stripeSubscription.trial_start * 1e3),
+									trialEnd: /* @__PURE__ */ new Date(stripeSubscription.trial_end * 1e3)
+								} : {}
+							},
+							where: [{
+								field: "id",
+								value: subscription.id
+							}]
+						});
+					}
+				}
+			} catch (error) {
+				ctx.get("context").logger.error("Error fetching subscription from Stripe", error);
+			}
+			return ctx.redirect(getUrl(authOptions, callbackURL), 302);
+		}),
+		createBillingPortal: createEndpoint(createRoute({
+			operationId: "createBillingPortal",
+			method: "post",
+			path: "/subscription/billing-portal",
+			middleware: [
+				sessionMiddleware(),
+				originCheck((ctx) => ctx.req.raw.clone().json().then((v) => v.returnUrl)),
+				referenceMiddleware("billing-portal")
+			],
+			request: req().bdy(z.object({
+				locale: z.custom((localization) => {
+					return typeof localization === "string";
+				}).optional(),
+				referenceId: z.string().optional(),
+				returnUrl: z.string().default("/")
+			})).bld(),
+			responses: res(z.object({
+				url: z.string(),
+				redirect: z.literal(true)
+			})).err(400).err(401).bld()
+		}), (authOptions) => async (ctx) => {
+			const session = ctx.get("session");
+			const { referenceId = session.user.id, locale, returnUrl } = ctx.req.valid("json");
+			let customerId = session.user.stripeCustomerId;
+			if (!customerId) customerId = (await ctx.get("context").adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId
+				}]
+			}).then((subs) => subs.find((sub) => sub.status === "active" || sub.status === "trialing")))?.stripeCustomerId;
+			if (!customerId) return ctx.json({
+				success: False,
+				message: "No Stripe customer found for this user"
+			}, 400);
+			try {
+				const { url } = await client.billingPortal.sessions.create({
+					customer: customerId,
+					return_url: getUrl(authOptions, returnUrl),
+					...locale && { locale }
+				});
+				return ctx.json({
+					url,
+					redirect: True
+				}, 200);
+			} catch (error) {
+				ctx.get("context").logger.error("Error creating billing portal session", error);
+				return ctx.json({
+					success: False,
+					message: error.message
+				}, 400);
+			}
+		})
+	};
+	return {
+		id: "stripe",
+		routes: {
+			stripeWebhook: createEndpoint(createRoute({
+				operationId: "stripeWebhook",
+				method: "post",
+				path: "/stripe/webhook",
+				client: false,
+				responses: res(z.object({ success: z.literal(true) })).err(400).err(500).bld()
+			}), (_authOptions) => async (ctx) => {
+				if (!ctx.req.raw?.body) return ctx.json({ success: False }, 500);
+				const buf = await ctx.req.text();
+				const sig = ctx.req.header("stripe-signature");
+				const webhookSecret = options.stripeWebhookSecret;
+				let event;
+				try {
+					if (!sig || !webhookSecret) return ctx.json({
+						success: False,
+						message: "Stripe webhook secret not found"
+					}, 400);
+					event = await client.webhooks.constructEventAsync(buf, sig, webhookSecret);
+				} catch (err) {
+					ctx.get("context").logger.error(`${err.message}`);
+					return ctx.json({
+						success: False,
+						message: `Webhook Error: ${err.message}`
+					}, 400);
+				}
+				try {
+					switch (event.type) {
+						case "checkout.session.completed":
+							await onCheckoutSessionCompleted(ctx, options, event);
+							await options.onEvent?.(event);
+							break;
+						case "customer.subscription.updated":
+							await onSubscriptionUpdated(ctx, options, event);
+							await options.onEvent?.(event);
+							break;
+						case "customer.subscription.deleted":
+							await onSubscriptionDeleted(ctx, options, event);
+							await options.onEvent?.(event);
+							break;
+						default:
+							await options.onEvent?.(event);
+							break;
+					}
+				} catch (e) {
+					ctx.get("context").logger.error(`Stripe webhook failed. Error: ${e.message}`);
+					return ctx.json({
+						success: False,
+						message: "Webhook error: See server logs for more information."
+					}, 400);
+				}
+				return ctx.json({ success: True }, 200);
+			}),
+			...options.subscription?.enabled ? subscriptionEndpoints : {}
+		},
+		init(ctx) {
+			return { options: { databaseHooks: { user: { create: { async after(user$1, ctx$1) {
+				if (ctx$1 && options.createCustomerOnSignUp) {
+					const stripeCustomer = await client.customers.create({
+						email: user$1.email,
+						...user$1.name && { name: user$1.name },
+						metadata: { userId: user$1.id }
+					});
+					if (!await ctx$1.get("context").internalAdapter.updateUser(user$1.id, { stripeCustomerId: stripeCustomer.id })) logger.error("#FAIRE_AUTH: Failed to create customer");
+					else if (options.onCustomerCreate) await options.onCustomerCreate({
+						stripeCustomer,
+						user: user$1
+					}, ctx$1);
+				}
+			} } } } } };
+		},
+		schema: getSchema(options)
+	};
+};
+
+//#endregion
+export { stripe };