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

package/src/index.ts

@@ -1,7 +1,9 @@
-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 {
 	cancelSubscription,
 	cancelSubscriptionCallback,
@@ -18,20 +20,18 @@ 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" {
+	// biome-ignore lint/correctness/noUnusedVariables: Auth and Context need to be same as declared in the module
+	interface BetterAuthPluginRegistry<Auth, Context> {
+		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["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,
@@ -120,6 +223,7 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 												name: user.name,
 												metadata: {
 													userId: user.id,
+													customerType: "user",
 												},
 											},
 											extraCreateParams,
@@ -150,41 +254,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}`,
 											);

package/src/middleware.ts

@@ -1,58 +1,104 @@
 import { createAuthMiddleware } from "@better-auth/core/api";
-import { logger } from "better-auth";
-import { APIError } from "better-auth/api";
-import type { SubscriptionOptions } from "./types";
+import { APIError } from "@better-auth/core/error";
+import { sessionMiddleware } from "better-auth/api";
+import { STRIPE_ERROR_CODES } from "./error-codes";
+import type {
+	AuthorizeReferenceAction,
+	CustomerType,
+	StripeCtxSession,
+	SubscriptionOptions,
+} from "./types";
+
+export const stripeSessionMiddleware = createAuthMiddleware(
+	{
+		use: [sessionMiddleware],
+	},
+	async (ctx) => {
+		const session = ctx.context.session as StripeCtxSession;
+		return {
+			session,
+		};
+	},
+);
 
 export const referenceMiddleware = (
 	subscriptionOptions: SubscriptionOptions,
-	action:
-		| "upgrade-subscription"
-		| "list-subscription"
-		| "cancel-subscription"
-		| "restore-subscription"
-		| "billing-portal",
+	action: AuthorizeReferenceAction,
 ) =>
 	createAuthMiddleware(async (ctx) => {
-		const session = ctx.context.session;
-		if (!session) {
-			throw new APIError("UNAUTHORIZED");
+		const ctxSession = ctx.context.session as StripeCtxSession;
+		if (!ctxSession) {
+			throw APIError.from("UNAUTHORIZED", STRIPE_ERROR_CODES.UNAUTHORIZED);
+		}
+
+		const customerType: CustomerType =
+			ctx.body?.customerType || ctx.query?.customerType;
+		const explicitReferenceId = ctx.body?.referenceId || ctx.query?.referenceId;
+
+		if (customerType === "organization") {
+			// Organization subscriptions always require authorizeReference
+			if (!subscriptionOptions.authorizeReference) {
+				ctx.context.logger.error(
+					`Organization subscriptions require authorizeReference to be defined in your stripe plugin config.`,
+				);
+				throw APIError.from(
+					"BAD_REQUEST",
+					STRIPE_ERROR_CODES.ORGANIZATION_SUBSCRIPTION_NOT_ENABLED,
+				);
+			}
+
+			const referenceId =
+				explicitReferenceId || ctxSession.session.activeOrganizationId;
+			if (!referenceId) {
+				throw APIError.from(
+					"BAD_REQUEST",
+					STRIPE_ERROR_CODES.ORGANIZATION_REFERENCE_ID_REQUIRED,
+				);
+			}
+			const isAuthorized = await subscriptionOptions.authorizeReference(
+				{
+					user: ctxSession.user,
+					session: ctxSession.session,
+					referenceId,
+					action,
+				},
+				ctx,
+			);
+			if (!isAuthorized) {
+				throw APIError.from("UNAUTHORIZED", STRIPE_ERROR_CODES.UNAUTHORIZED);
+			}
+			return;
 		}
-		const referenceId =
-			ctx.body?.referenceId || ctx.query?.referenceId || session.user.id;
-
-		if (
-			referenceId !== session.user.id &&
-			!subscriptionOptions.authorizeReference
-		) {
-			logger.error(
+
+		// User subscriptions - pass if no explicit referenceId
+		if (!explicitReferenceId) {
+			return;
+		}
+
+		// Pass if referenceId is user id
+		if (explicitReferenceId === ctxSession.user.id) {
+			return;
+		}
+
+		if (!subscriptionOptions.authorizeReference) {
+			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", {
-				message:
-					"Reference id is not allowed. Read server logs for more details.",
-			});
+			throw APIError.from(
+				"BAD_REQUEST",
+				STRIPE_ERROR_CODES.REFERENCE_ID_NOT_ALLOWED,
+			);
 		}
-		/**
-		 * if referenceId is the same as the active session user's id
-		 */
-		const sameReference =
-			ctx.query?.referenceId === session.user.id ||
-			ctx.body?.referenceId === session.user.id;
-		const isAuthorized =
-			ctx.body?.referenceId || ctx.query?.referenceId
-				? (await subscriptionOptions.authorizeReference?.(
-						{
-							user: session.user,
-							session: session.session,
-							referenceId,
-							action,
-						},
-						ctx,
-					)) || sameReference
-				: true;
+		const isAuthorized = await subscriptionOptions.authorizeReference(
+			{
+				user: ctxSession.user,
+				session: ctxSession.session,
+				referenceId: explicitReferenceId,
+				action,
+			},
+			ctx,
+		);
 		if (!isAuthorized) {
-			throw new APIError("UNAUTHORIZED", {
-				message: "Unauthorized",
-			});
+			throw APIError.from("UNAUTHORIZED", STRIPE_ERROR_CODES.UNAUTHORIZED);
 		}
 	});