@better-auth/stripe 1.5.0-beta.1 → 1.5.0-beta.10

package/src/hooks.ts

@@ -1,8 +1,41 @@
-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 { Organization } from "better-auth/plugins/organization";
 import type Stripe from "stripe";
-import type { InputSubscription, StripeOptions, Subscription } from "./types";
-import { getPlanByPriceInfo } from "./utils";
+import { subscriptionMetadata } from "./metadata";
+import type { CustomerType, StripeOptions, Subscription } from "./types";
+import {
+	getPlanByPriceInfo,
+	isActiveOrTrialing,
+	isPendingCancel,
+	isStripePendingCancel,
+} from "./utils";
+
+/**
+ * Find organization or user by stripeCustomerId.
+ * @internal
+ */
+async function findReferenceByStripeCustomerId(
+	ctx: GenericEndpointContext,
+	options: StripeOptions,
+	stripeCustomerId: string,
+): Promise<{ customerType: CustomerType; referenceId: string } | null> {
+	if (options.organization?.enabled) {
+		const org = await ctx.context.adapter.findOne<Organization>({
+			model: "organization",
+			where: [{ field: "stripeCustomerId", value: stripeCustomerId }],
+		});
+		if (org) return { customerType: "organization", referenceId: org.id };
+	}
+
+	const user = await ctx.context.adapter.findOne<User>({
+		model: "user",
+		where: [{ field: "stripeCustomerId", value: stripeCustomerId }],
+	});
+	if (user) return { customerType: "user", referenceId: user.id };
+
+	return null;
+}
 
 export async function onCheckoutSessionCompleted(
 	ctx: GenericEndpointContext,
@@ -18,19 +51,27 @@ export async function onCheckoutSessionCompleted(
 		const subscription = await client.subscriptions.retrieve(
 			checkoutSession.subscription as string,
 		);
-		const priceId = subscription.items.data[0]?.price.id;
-		const priceLookupKey = subscription.items.data[0]?.price.lookup_key || null;
+		const subscriptionItem = subscription.items.data[0];
+		if (!subscriptionItem) {
+			ctx.context.logger.warn(
+				`Stripe webhook warning: Subscription ${subscription.id} has no items`,
+			);
+			return;
+		}
+
+		const priceId = subscriptionItem.price.id;
+		const priceLookupKey = subscriptionItem.price.lookup_key;
 		const plan = await getPlanByPriceInfo(
 			options,
 			priceId as string,
 			priceLookupKey,
 		);
 		if (plan) {
+			const checkoutMeta = subscriptionMetadata.get(checkoutSession?.metadata);
 			const referenceId =
-				checkoutSession?.client_reference_id ||
-				checkoutSession?.metadata?.referenceId;
-			const subscriptionId = checkoutSession?.metadata?.subscriptionId;
-			const seats = subscription.items.data[0]!.quantity;
+				checkoutSession?.client_reference_id || checkoutMeta.referenceId;
+			const { subscriptionId } = checkoutMeta;
+			const seats = subscriptionItem.quantity;
 			if (referenceId && subscriptionId) {
 				const trial =
 					subscription.trial_start && subscription.trial_end
@@ -40,30 +81,35 @@ export async function onCheckoutSessionCompleted(
 							}
 						: {};
 
-				let dbSubscription =
-					await ctx.context.adapter.update<InputSubscription>({
-						model: "subscription",
-						update: {
-							plan: plan.name.toLowerCase(),
-							status: subscription.status,
-							updatedAt: new Date(),
-							periodStart: new Date(
-								subscription.items.data[0]!.current_period_start * 1000,
-							),
-							periodEnd: new Date(
-								subscription.items.data[0]!.current_period_end * 1000,
-							),
-							stripeSubscriptionId: checkoutSession.subscription as string,
-							seats,
-							...trial,
+				let dbSubscription = await ctx.context.adapter.update<Subscription>({
+					model: "subscription",
+					update: {
+						plan: plan.name.toLowerCase(),
+						status: subscription.status,
+						updatedAt: new Date(),
+						periodStart: new Date(subscriptionItem.current_period_start * 1000),
+						periodEnd: new Date(subscriptionItem.current_period_end * 1000),
+						stripeSubscriptionId: checkoutSession.subscription as string,
+						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: [
+						{
+							field: "id",
+							value: subscriptionId,
 						},
-						where: [
-							{
-								field: "id",
-								value: subscriptionId,
-							},
-						],
-					});
+					],
+				});
 
 				if (trial.trialStart && plan.freeTrial?.onTrialStart) {
 					await plan.freeTrial.onTrialStart(dbSubscription as Subscription);
@@ -93,7 +139,120 @@ 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 { subscriptionId } = subscriptionMetadata.get(
+			subscriptionCreated.metadata,
+		);
+		const existingSubscription =
+			await ctx.context.adapter.findOne<Subscription>({
+				model: "subscription",
+				where: subscriptionId
+					? [{ field: "id", value: subscriptionId }]
+					: [{ field: "stripeSubscriptionId", value: subscriptionCreated.id }], // Probably won't match since it's not set yet
+			});
+		if (existingSubscription) {
+			ctx.context.logger.info(
+				`Stripe webhook: Subscription already exists in database (id: ${existingSubscription.id}), skipping creation`,
+			);
+			return;
+		}
+
+		// Find reference
+		const reference = await findReferenceByStripeCustomerId(
+			ctx,
+			options,
+			stripeCustomerId,
+		);
+		if (!reference) {
+			ctx.context.logger.warn(
+				`Stripe webhook warning: No user or organization found with stripeCustomerId: ${stripeCustomerId}`,
+			);
+			return;
+		}
+		const { referenceId, customerType } = reference;
+
+		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,
+				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 ${customerType} ${referenceId} from dashboard`,
+		);
+
+		await options.subscription.onSubscriptionCreated?.({
+			event,
+			subscription: newSubscription,
+			stripeSubscription: subscriptionCreated,
+			plan,
+		});
+	} catch (error: any) {
+		ctx.context.logger.error(`Stripe webhook failed. Error: ${error}`);
 	}
 }
 
@@ -107,12 +266,21 @@ export async function onSubscriptionUpdated(
 			return;
 		}
 		const subscriptionUpdated = event.data.object as Stripe.Subscription;
-		const priceId = subscriptionUpdated.items.data[0]!.price.id;
-		const priceLookupKey =
-			subscriptionUpdated.items.data[0]!.price.lookup_key || null;
+		const subscriptionItem = subscriptionUpdated.items.data[0];
+		if (!subscriptionItem) {
+			ctx.context.logger.warn(
+				`Stripe webhook warning: Subscription ${subscriptionUpdated.id} has no items`,
+			);
+			return;
+		}
+
+		const priceId = subscriptionItem.price.id;
+		const priceLookupKey = subscriptionItem.price.lookup_key;
 		const plan = await getPlanByPriceInfo(options, priceId, priceLookupKey);
 
-		const subscriptionId = subscriptionUpdated.metadata?.subscriptionId;
+		const { subscriptionId } = subscriptionMetadata.get(
+			subscriptionUpdated.metadata,
+		);
 		const customerId = subscriptionUpdated.customer?.toString();
 		let subscription = await ctx.context.adapter.findOne<Subscription>({
 			model: "subscription",
@@ -126,12 +294,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;
@@ -142,7 +309,6 @@ export async function onSubscriptionUpdated(
 			}
 		}
 
-		const seats = subscriptionUpdated.items.data[0]!.quantity;
 		const updatedSubscription = await ctx.context.adapter.update<Subscription>({
 			model: "subscription",
 			update: {
@@ -154,14 +320,19 @@ export async function onSubscriptionUpdated(
 					: {}),
 				updatedAt: new Date(),
 				status: subscriptionUpdated.status,
-				periodStart: new Date(
-					subscriptionUpdated.items.data[0]!.current_period_start * 1000,
-				),
-				periodEnd: new Date(
-					subscriptionUpdated.items.data[0]!.current_period_end * 1000,
-				),
+				periodStart: new Date(subscriptionItem.current_period_start * 1000),
+				periodEnd: new Date(subscriptionItem.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: subscriptionItem.quantity,
 				stripeSubscriptionId: subscriptionUpdated.id,
 			},
 			where: [
@@ -171,11 +342,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 +376,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 +412,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 +430,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/index.ts

@@ -1,7 +1,10 @@
-import { defineErrorCodes } from "@better-auth/core/utils";
-import type { BetterAuthPlugin } from "better-auth";
+import type { BetterAuthPlugin, User } from "better-auth";
+import { APIError } from "better-auth";
+import type { Organization } from "better-auth/plugins/organization";
 import { defu } from "defu";
 import type Stripe from "stripe";
+import { STRIPE_ERROR_CODES } from "./error-codes";
+import { customerMetadata } from "./metadata";
 import {
 	cancelSubscription,
 	cancelSubscriptionCallback,
@@ -18,20 +21,17 @@ import type {
 	StripePlan,
 	Subscription,
 	SubscriptionOptions,
+	WithStripeCustomerId,
 } from "./types";
+import { escapeStripeSearchValue } from "./utils";
 
-const STRIPE_ERROR_CODES = defineErrorCodes({
-	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",
-});
+declare module "@better-auth/core" {
+	interface BetterAuthPluginRegistry<AuthOptions, Options> {
+		stripe: {
+			creator: typeof stripe;
+		};
+	}
+}
 
 export const stripe = <O extends StripeOptions>(options: O) => {
 	const client = options.stripeClient;
@@ -59,31 +59,134 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 				: {}),
 		},
 		init(ctx) {
+			if (options.organization?.enabled) {
+				const orgPlugin = ctx.getPlugin("organization");
+				if (!orgPlugin) {
+					ctx.logger.error(`Organization plugin not found`);
+					return;
+				}
+
+				const existingHooks = orgPlugin.options.organizationHooks ?? {};
+
+				/**
+				 * Sync organization name to Stripe customer
+				 */
+				const afterUpdateStripeOrg = async (data: {
+					organization: (Organization & WithStripeCustomerId) | null;
+					user: User;
+				}) => {
+					const { organization } = data;
+					if (!organization?.stripeCustomerId) return;
+
+					try {
+						const stripeCustomer = await client.customers.retrieve(
+							organization.stripeCustomerId,
+						);
+
+						if (stripeCustomer.deleted) {
+							ctx.logger.warn(
+								`Stripe customer ${organization.stripeCustomerId} was deleted`,
+							);
+							return;
+						}
+
+						// Update Stripe customer if name changed
+						if (organization.name !== stripeCustomer.name) {
+							await client.customers.update(organization.stripeCustomerId, {
+								name: organization.name,
+							});
+							ctx.logger.info(
+								`Synced organization name to Stripe: "${stripeCustomer.name}" → "${organization.name}"`,
+							);
+						}
+					} catch (e: any) {
+						ctx.logger.error(
+							`Failed to sync organization to Stripe: ${e.message}`,
+						);
+					}
+				};
+
+				/**
+				 * Block deletion if organization has active subscriptions
+				 */
+				const beforeDeleteStripeOrg = async (data: {
+					organization: Organization & WithStripeCustomerId;
+					user: User;
+				}) => {
+					const { organization } = data;
+					if (!organization.stripeCustomerId) return;
+
+					try {
+						// Check if organization has any active subscriptions
+						const subscriptions = await client.subscriptions.list({
+							customer: organization.stripeCustomerId,
+							status: "all",
+							limit: 100, // 1 ~ 100
+						});
+						for (const sub of subscriptions.data) {
+							if (
+								sub.status !== "canceled" &&
+								sub.status !== "incomplete" &&
+								sub.status !== "incomplete_expired"
+							) {
+								throw APIError.from(
+									"BAD_REQUEST",
+									STRIPE_ERROR_CODES.ORGANIZATION_HAS_ACTIVE_SUBSCRIPTION,
+								);
+							}
+						}
+					} catch (error: any) {
+						if (error instanceof APIError) {
+							throw error;
+						}
+						ctx.logger.error(
+							`Failed to check organization subscriptions: ${error.message}`,
+						);
+						throw error;
+					}
+				};
+
+				orgPlugin.options.organizationHooks = {
+					...existingHooks,
+					afterUpdateOrganization: existingHooks.afterUpdateOrganization
+						? async (data) => {
+								await existingHooks.afterUpdateOrganization!(data);
+								await afterUpdateStripeOrg(data);
+							}
+						: afterUpdateStripeOrg,
+					beforeDeleteOrganization: existingHooks.beforeDeleteOrganization
+						? async (data) => {
+								await existingHooks.beforeDeleteOrganization!(data);
+								await beforeDeleteStripeOrg(data);
+							}
+						: beforeDeleteStripeOrg,
+				};
+			}
+
 			return {
 				options: {
 					databaseHooks: {
 						user: {
 							create: {
-								async after(user, ctx) {
-									if (!ctx || !options.createCustomerOnSignUp) return;
+								async after(user: User & WithStripeCustomerId, ctx) {
+									if (
+										!ctx ||
+										!options.createCustomerOnSignUp ||
+										user.stripeCustomerId // Skip if user already has a Stripe customer ID
+									) {
+										return;
+									}
 
 									try {
-										const userWithStripe = user as typeof user & {
-											stripeCustomerId?: string;
-										};
-
-										// Skip if user already has a Stripe customer ID
-										if (userWithStripe.stripeCustomerId) return;
-
-										// Check if customer already exists in Stripe by email
-										const existingCustomers = await client.customers.list({
-											email: user.email,
+										// Check if user customer already exists in Stripe by email
+										const existingCustomers = await client.customers.search({
+											query: `email:"${escapeStripeSearchValue(user.email)}" AND -metadata["${customerMetadata.keys.customerType}"]:"organization"`,
 											limit: 1,
 										});
 
 										let stripeCustomer = existingCustomers.data[0];
 
-										// If customer exists, link it to prevent duplicate creation
+										// If user customer exists, link it to prevent duplicate creation
 										if (stripeCustomer) {
 											await ctx.context.internalAdapter.updateUser(user.id, {
 												stripeCustomerId: stripeCustomer.id,
@@ -114,13 +217,17 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 											);
 										}
 
-										const params: Stripe.CustomerCreateParams = defu(
+										const params = defu(
 											{
 												email: user.email,
 												name: user.name,
-												metadata: {
-													userId: user.id,
-												},
+												metadata: customerMetadata.set(
+													{
+														userId: user.id,
+														customerType: "user",
+													},
+													extraCreateParams?.metadata,
+												),
 											},
 											extraCreateParams,
 										);
@@ -150,41 +257,34 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 								},
 							},
 							update: {
-								async after(user, ctx) {
-									if (!ctx) return;
+								async after(user: User & WithStripeCustomerId, ctx) {
+									if (
+										!ctx ||
+										!user.stripeCustomerId // Only proceed if user has a Stripe customer ID
+									)
+										return;
 
 									try {
-										// Cast user to include stripeCustomerId (added by the stripe plugin schema)
-										const userWithStripe = user as typeof user & {
-											stripeCustomerId?: string;
-										};
-
-										// Only proceed if user has a Stripe customer ID
-										if (!userWithStripe.stripeCustomerId) return;
-
 										// Get the user from the database to check if email actually changed
 										// The 'user' parameter here is the freshly updated user
 										// We need to check if the Stripe customer's email matches
 										const stripeCustomer = await client.customers.retrieve(
-											userWithStripe.stripeCustomerId,
+											user.stripeCustomerId,
 										);
 
 										// Check if customer was deleted
 										if (stripeCustomer.deleted) {
 											ctx.context.logger.warn(
-												`Stripe customer ${userWithStripe.stripeCustomerId} was deleted, cannot update email`,
+												`Stripe customer ${user.stripeCustomerId} was deleted, cannot update email`,
 											);
 											return;
 										}
 
 										// If Stripe customer email doesn't match the user's current email, update it
 										if (stripeCustomer.email !== user.email) {
-											await client.customers.update(
-												userWithStripe.stripeCustomerId,
-												{
-													email: user.email,
-												},
-											);
+											await client.customers.update(user.stripeCustomerId, {
+												email: user.email,
+											});
 											ctx.context.logger.info(
 												`Updated Stripe customer email from ${stripeCustomer.email} to ${user.email}`,
 											);