@better-auth/stripe 1.4.9 → 1.4.10

package/src/hooks.ts

@@ -1,8 +1,13 @@
-import type { GenericEndpointContext } from "better-auth";
-import { logger } from "better-auth";
+import type { GenericEndpointContext } from "@better-auth/core";
+import type { User } from "@better-auth/core/db";
 import type Stripe from "stripe";
 import type { InputSubscription, StripeOptions, Subscription } from "./types";
-import { getPlanByPriceInfo } from "./utils";
+import {
+	getPlanByPriceInfo,
+	isActiveOrTrialing,
+	isPendingCancel,
+	isStripePendingCancel,
+} from "./utils";
 
 export async function onCheckoutSessionCompleted(
 	ctx: GenericEndpointContext,
@@ -54,7 +59,17 @@ export async function onCheckoutSessionCompleted(
 								subscription.items.data[0]!.current_period_end * 1000,
 							),
 							stripeSubscriptionId: checkoutSession.subscription as string,
-							seats,
+							cancelAtPeriodEnd: subscription.cancel_at_period_end,
+							cancelAt: subscription.cancel_at
+								? new Date(subscription.cancel_at * 1000)
+								: null,
+							canceledAt: subscription.canceled_at
+								? new Date(subscription.canceled_at * 1000)
+								: null,
+							endedAt: subscription.ended_at
+								? new Date(subscription.ended_at * 1000)
+								: null,
+							seats: seats,
 							...trial,
 						},
 						where: [
@@ -93,7 +108,123 @@ export async function onCheckoutSessionCompleted(
 			}
 		}
 	} catch (e: any) {
-		logger.error(`Stripe webhook failed. Error: ${e.message}`);
+		ctx.context.logger.error(`Stripe webhook failed. Error: ${e.message}`);
+	}
+}
+
+export async function onSubscriptionCreated(
+	ctx: GenericEndpointContext,
+	options: StripeOptions,
+	event: Stripe.Event,
+) {
+	try {
+		if (!options.subscription?.enabled) {
+			return;
+		}
+
+		const subscriptionCreated = event.data.object as Stripe.Subscription;
+		const stripeCustomerId = subscriptionCreated.customer?.toString();
+		if (!stripeCustomerId) {
+			ctx.context.logger.warn(
+				`Stripe webhook warning: customer.subscription.created event received without customer ID`,
+			);
+			return;
+		}
+
+		// Check if subscription already exists in database
+		const existingSubscription =
+			await ctx.context.adapter.findOne<Subscription>({
+				model: "subscription",
+				where: [
+					{
+						field: "stripeSubscriptionId",
+						value: subscriptionCreated.id,
+					},
+				],
+			});
+		if (existingSubscription) {
+			ctx.context.logger.info(
+				`Stripe webhook: Subscription ${subscriptionCreated.id} already exists in database, skipping creation`,
+			);
+			return;
+		}
+
+		// Find user by stripeCustomerId
+		const user = await ctx.context.adapter.findOne<User>({
+			model: "user",
+			where: [
+				{
+					field: "stripeCustomerId",
+					value: stripeCustomerId,
+				},
+			],
+		});
+		if (!user) {
+			ctx.context.logger.warn(
+				`Stripe webhook warning: No user found with stripeCustomerId: ${stripeCustomerId}`,
+			);
+			return;
+		}
+
+		const subscriptionItem = subscriptionCreated.items.data[0];
+		if (!subscriptionItem) {
+			ctx.context.logger.warn(
+				`Stripe webhook warning: Subscription ${subscriptionCreated.id} has no items`,
+			);
+			return;
+		}
+
+		const priceId = subscriptionItem.price.id;
+		const priceLookupKey = subscriptionItem.price.lookup_key || null;
+		const plan = await getPlanByPriceInfo(options, priceId, priceLookupKey);
+		if (!plan) {
+			ctx.context.logger.warn(
+				`Stripe webhook warning: No matching plan found for priceId: ${priceId}`,
+			);
+			return;
+		}
+
+		const seats = subscriptionItem.quantity;
+		const periodStart = new Date(subscriptionItem.current_period_start * 1000);
+		const periodEnd = new Date(subscriptionItem.current_period_end * 1000);
+
+		const trial =
+			subscriptionCreated.trial_start && subscriptionCreated.trial_end
+				? {
+						trialStart: new Date(subscriptionCreated.trial_start * 1000),
+						trialEnd: new Date(subscriptionCreated.trial_end * 1000),
+					}
+				: {};
+
+		// Create the subscription in the database
+		const newSubscription = await ctx.context.adapter.create<Subscription>({
+			model: "subscription",
+			data: {
+				referenceId: user.id,
+				stripeCustomerId: stripeCustomerId,
+				stripeSubscriptionId: subscriptionCreated.id,
+				status: subscriptionCreated.status,
+				plan: plan.name.toLowerCase(),
+				periodStart,
+				periodEnd,
+				seats,
+				...(plan.limits ? { limits: plan.limits } : {}),
+				...trial,
+			},
+		});
+
+		ctx.context.logger.info(
+			`Stripe webhook: Created subscription ${subscriptionCreated.id} for user ${user.id} from dashboard`,
+		);
+
+		await options.subscription?.onSubscriptionCreated?.({
+			event,
+			subscription: newSubscription,
+			stripeSubscription: subscriptionCreated,
+			plan,
+		});
+	} catch (error: any) {
+		ctx.context.logger.error(`Stripe webhook failed. Error: ${error}`);
 	}
 }
 
@@ -126,12 +257,11 @@ export async function onSubscriptionUpdated(
 				where: [{ field: "stripeCustomerId", value: customerId }],
 			});
 			if (subs.length > 1) {
-				const activeSub = subs.find(
-					(sub: Subscription) =>
-						sub.status === "active" || sub.status === "trialing",
+				const activeSub = subs.find((sub: Subscription) =>
+					isActiveOrTrialing(sub),
 				);
 				if (!activeSub) {
-					logger.warn(
+					ctx.context.logger.warn(
 						`Stripe webhook error: Multiple subscriptions found for customerId: ${customerId} and no active subscription is found`,
 					);
 					return;
@@ -161,7 +291,16 @@ export async function onSubscriptionUpdated(
 					subscriptionUpdated.items.data[0]!.current_period_end * 1000,
 				),
 				cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
-				seats,
+				cancelAt: subscriptionUpdated.cancel_at
+					? new Date(subscriptionUpdated.cancel_at * 1000)
+					: null,
+				canceledAt: subscriptionUpdated.canceled_at
+					? new Date(subscriptionUpdated.canceled_at * 1000)
+					: null,
+				endedAt: subscriptionUpdated.ended_at
+					? new Date(subscriptionUpdated.ended_at * 1000)
+					: null,
+				seats: seats,
 				stripeSubscriptionId: subscriptionUpdated.id,
 			},
 			where: [
@@ -171,11 +310,11 @@ export async function onSubscriptionUpdated(
 				},
 			],
 		});
-		const subscriptionCanceled =
+		const isNewCancellation =
 			subscriptionUpdated.status === "active" &&
-			subscriptionUpdated.cancel_at_period_end &&
-			!subscription.cancelAtPeriodEnd; //if this is true, it means the subscription was canceled before the event was triggered
-		if (subscriptionCanceled) {
+			isStripePendingCancel(subscriptionUpdated) &&
+			!isPendingCancel(subscription);
+		if (isNewCancellation) {
 			await options.subscription.onSubscriptionCancel?.({
 				subscription,
 				cancellationDetails:
@@ -205,7 +344,7 @@ export async function onSubscriptionUpdated(
 			}
 		}
 	} catch (error: any) {
-		logger.error(`Stripe webhook failed. Error: ${error}`);
+		ctx.context.logger.error(`Stripe webhook failed. Error: ${error}`);
 	}
 }
 
@@ -241,6 +380,16 @@ export async function onSubscriptionDeleted(
 				update: {
 					status: "canceled",
 					updatedAt: new Date(),
+					cancelAtPeriodEnd: subscriptionDeleted.cancel_at_period_end,
+					cancelAt: subscriptionDeleted.cancel_at
+						? new Date(subscriptionDeleted.cancel_at * 1000)
+						: null,
+					canceledAt: subscriptionDeleted.canceled_at
+						? new Date(subscriptionDeleted.canceled_at * 1000)
+						: null,
+					endedAt: subscriptionDeleted.ended_at
+						? new Date(subscriptionDeleted.ended_at * 1000)
+						: null,
 				},
 			});
 			await options.subscription.onSubscriptionDeleted?.({
@@ -249,11 +398,11 @@ export async function onSubscriptionDeleted(
 				subscription,
 			});
 		} else {
-			logger.warn(
+			ctx.context.logger.warn(
 				`Stripe webhook error: Subscription not found for subscriptionId: ${subscriptionId}`,
 			);
 		}
 	} catch (error: any) {
-		logger.error(`Stripe webhook failed. Error: ${error}`);
+		ctx.context.logger.error(`Stripe webhook failed. Error: ${error}`);
 	}
 }

package/src/middleware.ts

@@ -1,5 +1,4 @@
 import { createAuthMiddleware } from "@better-auth/core/api";
-import { logger } from "better-auth";
 import { APIError } from "better-auth/api";
 import type { SubscriptionOptions } from "./types";
 
@@ -24,7 +23,7 @@ export const referenceMiddleware = (
 			referenceId !== session.user.id &&
 			!subscriptionOptions.authorizeReference
 		) {
-			logger.error(
+			ctx.context.logger.error(
 				`Passing referenceId into a subscription action isn't allowed if subscription.authorizeReference isn't defined in your stripe plugin config.`,
 			);
 			throw new APIError("BAD_REQUEST", {

package/src/routes.ts

@@ -13,6 +13,7 @@ import type { Stripe as StripeType } from "stripe";
 import * as z from "zod/v4";
 import {
 	onCheckoutSessionCompleted,
+	onSubscriptionCreated,
 	onSubscriptionDeleted,
 	onSubscriptionUpdated,
 } from "./hooks";
@@ -23,7 +24,14 @@ import type {
 	Subscription,
 	SubscriptionOptions,
 } from "./types";
-import { getPlanByName, getPlanByPriceInfo, getPlans } from "./utils";
+import {
+	getPlanByName,
+	getPlanByPriceInfo,
+	getPlans,
+	isActiveOrTrialing,
+	isPendingCancel,
+	isStripePendingCancel,
+} from "./utils";
 
 const STRIPE_ERROR_CODES = defineErrorCodes({
 	SUBSCRIPTION_NOT_FOUND: "Subscription not found",
@@ -272,19 +280,15 @@ export const upgradeSubscription = (options: StripeOptions) => {
 						],
 					});
 
-			const activeOrTrialingSubscription = subscriptions.find(
-				(sub) => sub.status === "active" || sub.status === "trialing",
+			const activeOrTrialingSubscription = subscriptions.find((sub) =>
+				isActiveOrTrialing(sub),
 			);
 
 			const activeSubscriptions = await client.subscriptions
 				.list({
 					customer: customerId,
 				})
-				.then((res) =>
-					res.data.filter(
-						(sub) => sub.status === "active" || sub.status === "trialing",
-					),
-				);
+				.then((res) => res.data.filter((sub) => isActiveOrTrialing(sub)));
 
 			const activeSubscription = activeSubscriptions.find((sub) => {
 				// If we have a specific subscription to update, match by ID
@@ -408,7 +412,7 @@ export const upgradeSubscription = (options: StripeOptions) => {
 					});
 				return ctx.json({
 					url,
-					redirect: true,
+					redirect: !ctx.body.disableRedirect,
 				});
 			}
 
@@ -465,7 +469,13 @@ export const upgradeSubscription = (options: StripeOptions) => {
 				ctx,
 			);
 
-			const hasEverTrialed = subscriptions.some((s) => {
+			const allSubscriptions = await ctx.context.adapter.findMany<Subscription>(
+				{
+					model: "subscription",
+					where: [{ field: "referenceId", value: referenceId }],
+				},
+			);
+			const hasEverTrialed = allSubscriptions.some((s) => {
 				// Check if user has ever had a trial for any plan (not just the same plan)
 				// This prevents users from getting multiple trials by switching plans
 				const hadTrial =
@@ -599,8 +609,8 @@ export const cancelSubscriptionCallback = (options: StripeOptions) => {
 					});
 					if (
 						!subscription ||
-						subscription.cancelAtPeriodEnd ||
-						subscription.status === "canceled"
+						subscription.status === "canceled" ||
+						isPendingCancel(subscription)
 					) {
 						throw ctx.redirect(getUrl(ctx, callbackURL));
 					}
@@ -612,12 +622,24 @@ export const cancelSubscriptionCallback = (options: StripeOptions) => {
 					const currentSubscription = stripeSubscription.data.find(
 						(sub) => sub.id === subscription.stripeSubscriptionId,
 					);
-					if (currentSubscription?.cancel_at_period_end === true) {
+
+					const isNewCancellation =
+						currentSubscription &&
+						isStripePendingCancel(currentSubscription) &&
+						!isPendingCancel(subscription);
+					if (isNewCancellation) {
 						await ctx.context.adapter.update({
 							model: "subscription",
 							update: {
 								status: currentSubscription?.status,
-								cancelAtPeriodEnd: true,
+								cancelAtPeriodEnd:
+									currentSubscription?.cancel_at_period_end || false,
+								cancelAt: currentSubscription?.cancel_at
+									? new Date(currentSubscription.cancel_at * 1000)
+									: null,
+								canceledAt: currentSubscription?.canceled_at
+									? new Date(currentSubscription.canceled_at * 1000)
+									: null,
 							},
 							where: [
 								{
@@ -663,6 +685,16 @@ const cancelSubscriptionBodySchema = z.object({
 		description:
 			'URL to take customers to when they click on the billing portal\'s link to return to your website. Eg: "/account"',
 	}),
+	/**
+	 * Disable Redirect
+	 */
+	disableRedirect: z
+		.boolean()
+		.meta({
+			description:
+				"Disable redirect after successful subscription cancellation. Eg: true",
+		})
+		.default(false),
 });
 
 /**
@@ -716,13 +748,7 @@ export const cancelSubscription = (options: StripeOptions) => {
 							model: "subscription",
 							where: [{ field: "referenceId", value: referenceId }],
 						})
-						.then((subs) =>
-							subs.find(
-								(sub) => sub.status === "active" || sub.status === "trialing",
-							),
-						);
-
-			// Ensure the specified subscription belongs to the (validated) referenceId.
+						.then((subs) => subs.find((sub) => isActiveOrTrialing(sub)));
 			if (
 				ctx.body.subscriptionId &&
 				subscription &&
@@ -740,11 +766,7 @@ export const cancelSubscription = (options: StripeOptions) => {
 				.list({
 					customer: subscription.stripeCustomerId,
 				})
-				.then((res) =>
-					res.data.filter(
-						(sub) => sub.status === "active" || sub.status === "trialing",
-					),
-				);
+				.then((res) => res.data.filter((sub) => isActiveOrTrialing(sub)));
 			if (!activeSubscriptions.length) {
 				/**
 				 * If the subscription is not found, we need to delete the subscription
@@ -790,21 +812,30 @@ export const cancelSubscription = (options: StripeOptions) => {
 					},
 				})
 				.catch(async (e) => {
-					if (e.message.includes("already set to be cancel")) {
+					if (e.message?.includes("already set to be canceled")) {
 						/**
-						 * in-case we missed the event from stripe, we set it manually
+						 * in-case we missed the event from stripe, we sync the actual state
 						 * this is a rare case and should not happen
 						 */
-						if (!subscription.cancelAtPeriodEnd) {
-							await ctx.context.adapter.updateMany({
+						if (!isPendingCancel(subscription)) {
+							const stripeSub = await client.subscriptions.retrieve(
+								activeSubscription.id,
+							);
+							await ctx.context.adapter.update({
 								model: "subscription",
 								update: {
-									cancelAtPeriodEnd: true,
+									cancelAtPeriodEnd: stripeSub.cancel_at_period_end,
+									cancelAt: stripeSub.cancel_at
+										? new Date(stripeSub.cancel_at * 1000)
+										: null,
+									canceledAt: stripeSub.canceled_at
+										? new Date(stripeSub.canceled_at * 1000)
+										: null,
 								},
 								where: [
 									{
-										field: "referenceId",
-										value: referenceId,
+										field: "id",
+										value: subscription.id,
 									},
 								],
 							});
@@ -815,10 +846,10 @@ export const cancelSubscription = (options: StripeOptions) => {
 						code: e.code,
 					});
 				});
-			return {
+			return ctx.json({
 				url,
-				redirect: true,
-			};
+				redirect: !ctx.body.disableRedirect,
+			});
 		},
 	);
 };
@@ -880,11 +911,7 @@ export const restoreSubscription = (options: StripeOptions) => {
 								},
 							],
 						})
-						.then((subs) =>
-							subs.find(
-								(sub) => sub.status === "active" || sub.status === "trialing",
-							),
-						);
+						.then((subs) => subs.find((sub) => isActiveOrTrialing(sub)));
 			if (
 				ctx.body.subscriptionId &&
 				subscription &&
@@ -905,7 +932,7 @@ export const restoreSubscription = (options: StripeOptions) => {
 					message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_ACTIVE,
 				});
 			}
-			if (!subscription.cancelAtPeriodEnd) {
+			if (!isPendingCancel(subscription)) {
 				throw ctx.error("BAD_REQUEST", {
 					message:
 						STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION,
@@ -916,47 +943,48 @@ export const restoreSubscription = (options: StripeOptions) => {
 				.list({
 					customer: subscription.stripeCustomerId,
 				})
-				.then(
-					(res) =>
-						res.data.filter(
-							(sub) => sub.status === "active" || sub.status === "trialing",
-						)[0],
-				);
+				.then((res) => res.data.filter((sub) => isActiveOrTrialing(sub))[0]);
 			if (!activeSubscription) {
 				throw ctx.error("BAD_REQUEST", {
 					message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND,
 				});
 			}
 
-			try {
-				const newSub = await client.subscriptions.update(
-					activeSubscription.id,
-					{
-						cancel_at_period_end: false,
-					},
-				);
+			// Clear scheduled cancellation based on Stripe subscription state
+			// Note: Stripe doesn't accept both `cancel_at` and `cancel_at_period_end` simultaneously
+			const updateParams: Stripe.SubscriptionUpdateParams = {};
+			if (activeSubscription.cancel_at) {
+				updateParams.cancel_at = "";
+			} else if (activeSubscription.cancel_at_period_end) {
+				updateParams.cancel_at_period_end = false;
+			}
 
-				await ctx.context.adapter.update({
-					model: "subscription",
-					update: {
-						cancelAtPeriodEnd: false,
-						updatedAt: new Date(),
-					},
-					where: [
-						{
-							field: "id",
-							value: subscription.id,
-						},
-					],
+			const newSub = await client.subscriptions
+				.update(activeSubscription.id, updateParams)
+				.catch((e) => {
+					throw ctx.error("BAD_REQUEST", {
+						message: e.message,
+						code: e.code,
+					});
 				});
 
-				return ctx.json(newSub);
-			} catch (error) {
-				ctx.context.logger.error("Error restoring subscription", error);
-				throw new APIError("BAD_REQUEST", {
-					message: STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER,
-				});
-			}
+			await ctx.context.adapter.update({
+				model: "subscription",
+				update: {
+					cancelAtPeriodEnd: false,
+					cancelAt: null,
+					canceledAt: null,
+					updatedAt: new Date(),
+				},
+				where: [
+					{
+						field: "id",
+						value: subscription.id,
+					},
+				],
+			});
+
+			return ctx.json(newSub);
 		},
 	);
 };
@@ -1031,9 +1059,7 @@ export const listActiveSubscriptions = (options: StripeOptions) => {
 						priceId: plan?.priceId,
 					};
 				})
-				.filter((sub) => {
-					return sub.status === "active" || sub.status === "trialing";
-				});
+				.filter((sub) => isActiveOrTrialing(sub));
 			return ctx.json(subs);
 		},
 	);
@@ -1119,6 +1145,13 @@ export const subscriptionSuccess = (options: StripeOptions) => {
 											1000,
 									),
 									stripeSubscriptionId: stripeSubscription.id,
+									cancelAtPeriodEnd: stripeSubscription.cancel_at_period_end,
+									cancelAt: stripeSubscription.cancel_at
+										? new Date(stripeSubscription.cancel_at * 1000)
+										: null,
+									canceledAt: stripeSubscription.canceled_at
+										? new Date(stripeSubscription.canceled_at * 1000)
+										: null,
 									...(stripeSubscription.trial_start &&
 									stripeSubscription.trial_end
 										? {
@@ -1158,6 +1191,16 @@ const createBillingPortalBodySchema = z.object({
 		.optional(),
 	referenceId: z.string().optional(),
 	returnUrl: z.string().default("/"),
+	/**
+	 * Disable Redirect
+	 */
+	disableRedirect: z
+		.boolean()
+		.meta({
+			description:
+				"Disable redirect after creating billing portal session. Eg: true",
+		})
+		.default(false),
 });
 
 export const createBillingPortal = (options: StripeOptions) => {
@@ -1196,11 +1239,7 @@ export const createBillingPortal = (options: StripeOptions) => {
 							},
 						],
 					})
-					.then((subs) =>
-						subs.find(
-							(sub) => sub.status === "active" || sub.status === "trialing",
-						),
-					);
+					.then((subs) => subs.find((sub) => isActiveOrTrialing(sub)));
 
 				customerId = subscription?.stripeCustomerId;
 			}
@@ -1220,7 +1259,7 @@ export const createBillingPortal = (options: StripeOptions) => {
 
 				return ctx.json({
 					url,
-					redirect: true,
+					redirect: !ctx.body.disableRedirect,
 				});
 			} catch (error: any) {
 				ctx.context.logger.error(
@@ -1294,6 +1333,10 @@ export const stripeWebhook = (options: StripeOptions) => {
 						await onCheckoutSessionCompleted(ctx, options, event);
 						await options.onEvent?.(event);
 						break;
+					case "customer.subscription.created":
+						await onSubscriptionCreated(ctx, options, event);
+						await options.onEvent?.(event);
+						break;
 					case "customer.subscription.updated":
 						await onSubscriptionUpdated(ctx, options, event);
 						await options.onEvent?.(event);

package/src/schema.ts

@@ -46,6 +46,18 @@ export const subscriptions = {
 				required: false,
 				defaultValue: false,
 			},
+			cancelAt: {
+				type: "date",
+				required: false,
+			},
+			canceledAt: {
+				type: "date",
+				required: false,
+			},
+			endedAt: {
+				type: "date",
+				required: false,
+			},
 			seats: {
 				type: "number",
 				required: false,