@better-auth/stripe 1.5.0-beta.2 → 1.5.0-beta.4

package/dist/index.mjs

@@ -1,10 +1,9 @@
-import { t as STRIPE_ERROR_CODES$1 } from "./error-codes-qqooUh6R.mjs";
-import { defineErrorCodes } from "@better-auth/core/utils";
+import { t as STRIPE_ERROR_CODES } from "./error-codes-Bkj5yJMT.mjs";
+import { APIError, HIDE_METADATA } from "better-auth";
 import { defu } from "defu";
 import { createAuthEndpoint, createAuthMiddleware } from "@better-auth/core/api";
-import { APIError } from "@better-auth/core/error";
-import { HIDE_METADATA } from "better-auth";
-import { APIError as APIError$1, getSessionFromCtx, originCheck, sessionMiddleware } from "better-auth/api";
+import { APIError as APIError$1 } from "@better-auth/core/error";
+import { getSessionFromCtx, originCheck, sessionMiddleware } from "better-auth/api";
 import * as z from "zod/v4";
 import { mergeSchema } from "better-auth/db";
 
@@ -37,21 +36,68 @@ function isPendingCancel(sub) {
 function isStripePendingCancel(stripeSub) {
 	return !!(stripeSub.cancel_at_period_end || stripeSub.cancel_at);
 }
+/**
+* Escapes a value for use in Stripe search queries.
+* Stripe search query uses double quotes for string values,
+* and double quotes within the value need to be escaped with backslash.
+*
+* @see https://docs.stripe.com/search#search-query-language
+*/
+function escapeStripeSearchValue(value) {
+	return value.replace(/"/g, "\\\"");
+}
 
 //#endregion
 //#region src/hooks.ts
+/**
+* Find organization or user by stripeCustomerId.
+* @internal
+*/
+async function findReferenceByStripeCustomerId(ctx, options, stripeCustomerId) {
+	if (options.organization?.enabled) {
+		const org = await ctx.context.adapter.findOne({
+			model: "organization",
+			where: [{
+				field: "stripeCustomerId",
+				value: stripeCustomerId
+			}]
+		});
+		if (org) return {
+			customerType: "organization",
+			referenceId: org.id
+		};
+	}
+	const user$1 = await ctx.context.adapter.findOne({
+		model: "user",
+		where: [{
+			field: "stripeCustomerId",
+			value: stripeCustomerId
+		}]
+	});
+	if (user$1) return {
+		customerType: "user",
+		referenceId: user$1.id
+	};
+	return null;
+}
 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);
+		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, priceLookupKey);
 		if (plan) {
 			const referenceId = checkoutSession?.client_reference_id || checkoutSession?.metadata?.referenceId;
 			const subscriptionId = checkoutSession?.metadata?.subscriptionId;
-			const seats = subscription.items.data[0].quantity;
+			const seats = subscriptionItem.quantity;
 			if (referenceId && subscriptionId) {
 				const trial = subscription.trial_start && subscription.trial_end ? {
 					trialStart: /* @__PURE__ */ new Date(subscription.trial_start * 1e3),
@@ -63,8 +109,8 @@ async function onCheckoutSessionCompleted(ctx, options, event) {
 						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),
+						periodStart: /* @__PURE__ */ new Date(subscriptionItem.current_period_start * 1e3),
+						periodEnd: /* @__PURE__ */ new Date(subscriptionItem.current_period_end * 1e3),
 						stripeSubscriptionId: checkoutSession.subscription,
 						cancelAtPeriodEnd: subscription.cancel_at_period_end,
 						cancelAt: subscription.cancel_at ? /* @__PURE__ */ new Date(subscription.cancel_at * 1e3) : null,
@@ -108,27 +154,27 @@ async function onSubscriptionCreated(ctx, options, event) {
 			ctx.context.logger.warn(`Stripe webhook warning: customer.subscription.created event received without customer ID`);
 			return;
 		}
-		if (await ctx.context.adapter.findOne({
+		const subscriptionId = subscriptionCreated.metadata?.subscriptionId;
+		const existingSubscription = await ctx.context.adapter.findOne({
 			model: "subscription",
-			where: [{
+			where: subscriptionId ? [{
+				field: "id",
+				value: subscriptionId
+			}] : [{
 				field: "stripeSubscriptionId",
 				value: subscriptionCreated.id
 			}]
-		})) {
-			ctx.context.logger.info(`Stripe webhook: Subscription ${subscriptionCreated.id} already exists in database, skipping creation`);
+		});
+		if (existingSubscription) {
+			ctx.context.logger.info(`Stripe webhook: Subscription already exists in database (id: ${existingSubscription.id}), skipping creation`);
 			return;
 		}
-		const user$1 = await ctx.context.adapter.findOne({
-			model: "user",
-			where: [{
-				field: "stripeCustomerId",
-				value: stripeCustomerId
-			}]
-		});
-		if (!user$1) {
-			ctx.context.logger.warn(`Stripe webhook warning: No user found with stripeCustomerId: ${stripeCustomerId}`);
+		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`);
@@ -150,7 +196,7 @@ async function onSubscriptionCreated(ctx, options, event) {
 		const newSubscription = await ctx.context.adapter.create({
 			model: "subscription",
 			data: {
-				referenceId: user$1.id,
+				referenceId,
 				stripeCustomerId,
 				stripeSubscriptionId: subscriptionCreated.id,
 				status: subscriptionCreated.status,
@@ -162,8 +208,8 @@ async function onSubscriptionCreated(ctx, options, event) {
 				...trial
 			}
 		});
-		ctx.context.logger.info(`Stripe webhook: Created subscription ${subscriptionCreated.id} for user ${user$1.id} from dashboard`);
-		await options.subscription?.onSubscriptionCreated?.({
+		ctx.context.logger.info(`Stripe webhook: Created subscription ${subscriptionCreated.id} for ${customerType} ${referenceId} from dashboard`);
+		await options.subscription.onSubscriptionCreated?.({
 			event,
 			subscription: newSubscription,
 			stripeSubscription: subscriptionCreated,
@@ -177,8 +223,14 @@ 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 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 customerId = subscriptionUpdated.customer?.toString();
 		let subscription = await ctx.context.adapter.findOne({
@@ -208,7 +260,6 @@ async function onSubscriptionUpdated(ctx, options, event) {
 				subscription = activeSub;
 			} else subscription = subs[0];
 		}
-		const seats = subscriptionUpdated.items.data[0].quantity;
 		const updatedSubscription = await ctx.context.adapter.update({
 			model: "subscription",
 			update: {
@@ -218,13 +269,13 @@ async function onSubscriptionUpdated(ctx, options, event) {
 				} : {},
 				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),
+				periodStart: /* @__PURE__ */ new Date(subscriptionItem.current_period_start * 1e3),
+				periodEnd: /* @__PURE__ */ new Date(subscriptionItem.current_period_end * 1e3),
 				cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
 				cancelAt: subscriptionUpdated.cancel_at ? /* @__PURE__ */ new Date(subscriptionUpdated.cancel_at * 1e3) : null,
 				canceledAt: subscriptionUpdated.canceled_at ? /* @__PURE__ */ new Date(subscriptionUpdated.canceled_at * 1e3) : null,
 				endedAt: subscriptionUpdated.ended_at ? /* @__PURE__ */ new Date(subscriptionUpdated.ended_at * 1e3) : null,
-				seats,
+				seats: subscriptionItem.quantity,
 				stripeSubscriptionId: subscriptionUpdated.id
 			},
 			where: [{
@@ -291,33 +342,86 @@ async function onSubscriptionDeleted(ctx, options, event) {
 
 //#endregion
 //#region src/middleware.ts
+const stripeSessionMiddleware = createAuthMiddleware({ use: [sessionMiddleware] }, async (ctx) => {
+	return { session: ctx.context.session };
+});
 const referenceMiddleware = (subscriptionOptions, action) => createAuthMiddleware(async (ctx) => {
-	const session = ctx.context.session;
-	if (!session) throw new APIError$1("UNAUTHORIZED");
-	const referenceId = ctx.body?.referenceId || ctx.query?.referenceId || session.user.id;
-	if (referenceId !== session.user.id && !subscriptionOptions.authorizeReference) {
+	const ctxSession = ctx.context.session;
+	if (!ctxSession) throw APIError$1.from("UNAUTHORIZED", STRIPE_ERROR_CODES.UNAUTHORIZED);
+	const customerType = ctx.body?.customerType || ctx.query?.customerType;
+	const explicitReferenceId = ctx.body?.referenceId || ctx.query?.referenceId;
+	if (customerType === "organization") {
+		if (!subscriptionOptions.authorizeReference) {
+			ctx.context.logger.error(`Organization subscriptions require authorizeReference to be defined in your stripe plugin config.`);
+			throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.ORGANIZATION_SUBSCRIPTION_NOT_ENABLED);
+		}
+		const referenceId = explicitReferenceId || ctxSession.session.activeOrganizationId;
+		if (!referenceId) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.ORGANIZATION_REFERENCE_ID_REQUIRED);
+		if (!await subscriptionOptions.authorizeReference({
+			user: ctxSession.user,
+			session: ctxSession.session,
+			referenceId,
+			action
+		}, ctx)) throw APIError$1.from("UNAUTHORIZED", STRIPE_ERROR_CODES.UNAUTHORIZED);
+		return;
+	}
+	if (!explicitReferenceId) return;
+	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$1("BAD_REQUEST", { message: "Reference id is not allowed. Read server logs for more details." });
+		throw APIError$1.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;
-	if (!(ctx.body?.referenceId || ctx.query?.referenceId ? await subscriptionOptions.authorizeReference?.({
-		user: session.user,
-		session: session.session,
-		referenceId,
+	if (!await subscriptionOptions.authorizeReference({
+		user: ctxSession.user,
+		session: ctxSession.session,
+		referenceId: explicitReferenceId,
 		action
-	}, ctx) || sameReference : true)) throw new APIError$1("UNAUTHORIZED", { message: "Unauthorized" });
+	}, ctx)) throw APIError$1.from("UNAUTHORIZED", STRIPE_ERROR_CODES.UNAUTHORIZED);
 });
 
 //#endregion
 //#region src/routes.ts
+/**
+* Converts a relative URL to an absolute URL using baseURL.
+* @internal
+*/
+function getUrl(ctx, url) {
+	if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(url)) return url;
+	return `${ctx.context.options.baseURL}${url.startsWith("/") ? url : `/${url}`}`;
+}
+/**
+* Resolves a Stripe price ID from a lookup key.
+* @internal
+*/
+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;
+}
+/**
+* Determines the reference ID based on customer type.
+* - `user` (default): uses userId
+* - `organization`: uses activeOrganizationId from session
+* @internal
+*/
+function getReferenceId(ctxSession, customerType, options) {
+	const { user: user$1, session } = ctxSession;
+	if ((customerType || "user") === "organization") {
+		if (!options.organization?.enabled) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.ORGANIZATION_SUBSCRIPTION_NOT_ENABLED);
+		if (!session.activeOrganizationId) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.ORGANIZATION_NOT_FOUND);
+		return session.activeOrganizationId;
+	}
+	return user$1.id;
+}
 const upgradeSubscriptionBodySchema = 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(),
+	referenceId: z.string().meta({ description: "Reference ID for the subscription. Eg: \"org_123\"" }).optional(),
 	subscriptionId: z.string().meta({ description: "The Stripe subscription ID to upgrade. Eg: \"sub_1ABC2DEF3GHI4JKL\"" }).optional(),
+	customerType: z.enum(["user", "organization"]).meta({ description: "Customer type for the subscription. Eg: \"user\" or \"organization\"" }).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("/"),
@@ -348,18 +452,19 @@ const upgradeSubscription = (options) => {
 		body: upgradeSubscriptionBodySchema,
 		metadata: { openapi: { operationId: "upgradeSubscription" } },
 		use: [
-			sessionMiddleware,
+			stripeSessionMiddleware,
+			referenceMiddleware(subscriptionOptions, "upgrade-subscription"),
 			originCheck((c) => {
 				return [c.body.successUrl, c.body.cancelUrl];
-			}),
-			referenceMiddleware(subscriptionOptions, "upgrade-subscription")
+			})
 		]
 	}, async (ctx) => {
 		const { user: user$1, session } = ctx.context.session;
-		if (!user$1.emailVerified && subscriptionOptions.requireEmailVerification) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.EMAIL_VERIFICATION_REQUIRED);
-		const referenceId = ctx.body.referenceId || user$1.id;
+		const customerType = ctx.body.customerType || "user";
+		const referenceId = ctx.body.referenceId || getReferenceId(ctx.context.session, customerType, options);
+		if (!user$1.emailVerified && subscriptionOptions.requireEmailVerification) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.EMAIL_VERIFICATION_REQUIRED);
 		const plan = await getPlanByName(options, ctx.body.plan);
-		if (!plan) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_PLAN_NOT_FOUND);
+		if (!plan) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_PLAN_NOT_FOUND);
 		let subscriptionToUpdate = ctx.body.subscriptionId ? await ctx.context.adapter.findOne({
 			model: "subscription",
 			where: [{
@@ -374,39 +479,94 @@ const upgradeSubscription = (options) => {
 			}]
 		}) : null;
 		if (ctx.body.subscriptionId && subscriptionToUpdate && subscriptionToUpdate.referenceId !== referenceId) subscriptionToUpdate = null;
-		if (ctx.body.subscriptionId && !subscriptionToUpdate) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_FOUND);
-		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,
-				name: user$1.name,
-				metadata: {
-					...ctx.body.metadata,
-					userId: user$1.id
+		if (ctx.body.subscriptionId && !subscriptionToUpdate) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND);
+		let customerId;
+		if (customerType === "organization") {
+			customerId = subscriptionToUpdate?.stripeCustomerId;
+			if (!customerId) {
+				const org = await ctx.context.adapter.findOne({
+					model: "organization",
+					where: [{
+						field: "id",
+						value: referenceId
+					}]
+				});
+				if (!org) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.ORGANIZATION_NOT_FOUND);
+				customerId = org.stripeCustomerId;
+				if (!customerId) try {
+					let stripeCustomer = (await client.customers.search({
+						query: `metadata["organizationId"]:"${org.id}"`,
+						limit: 1
+					})).data[0];
+					if (!stripeCustomer) {
+						let extraCreateParams = {};
+						if (options.organization?.getCustomerCreateParams) extraCreateParams = await options.organization.getCustomerCreateParams(org, ctx);
+						const customerParams = defu({
+							name: org.name,
+							metadata: {
+								...ctx.body.metadata,
+								organizationId: org.id,
+								customerType: "organization"
+							}
+						}, extraCreateParams);
+						stripeCustomer = await client.customers.create(customerParams);
+						await options.organization?.onCustomerCreate?.({
+							stripeCustomer,
+							organization: {
+								...org,
+								stripeCustomerId: stripeCustomer.id
+							}
+						}, ctx);
+					}
+					await ctx.context.adapter.update({
+						model: "organization",
+						update: { stripeCustomerId: stripeCustomer.id },
+						where: [{
+							field: "id",
+							value: org.id
+						}]
+					});
+					customerId = stripeCustomer.id;
+				} catch (e) {
+					ctx.context.logger.error(e);
+					throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER);
 				}
-			});
-			await ctx.context.adapter.update({
-				model: "user",
-				update: { stripeCustomerId: stripeCustomer.id },
-				where: [{
-					field: "id",
-					value: user$1.id
-				}]
-			});
-			customerId = stripeCustomer.id;
-		} catch (e) {
-			ctx.context.logger.error(e);
-			throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.UNABLE_TO_CREATE_CUSTOMER);
+			}
+		} else {
+			customerId = subscriptionToUpdate?.stripeCustomerId || user$1.stripeCustomerId;
+			if (!customerId) try {
+				let stripeCustomer = (await client.customers.search({
+					query: `email:"${escapeStripeSearchValue(user$1.email)}" AND -metadata["customerType"]:"organization"`,
+					limit: 1
+				})).data[0];
+				if (!stripeCustomer) stripeCustomer = await client.customers.create({
+					email: user$1.email,
+					name: user$1.name,
+					metadata: {
+						...ctx.body.metadata,
+						userId: user$1.id,
+						customerType: "user"
+					}
+				});
+				await ctx.context.adapter.update({
+					model: "user",
+					update: { stripeCustomerId: stripeCustomer.id },
+					where: [{
+						field: "id",
+						value: user$1.id
+					}]
+				});
+				customerId = stripeCustomer.id;
+			} catch (e) {
+				ctx.context.logger.error(e);
+				throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER);
+			}
 		}
 		const subscriptions$1 = subscriptionToUpdate ? [subscriptionToUpdate] : await ctx.context.adapter.findMany({
 			model: "subscription",
 			where: [{
 				field: "referenceId",
-				value: ctx.body.referenceId || user$1.id
+				value: referenceId
 			}]
 		});
 		const activeOrTrialingSubscription = subscriptions$1.find((sub) => isActiveOrTrialing(sub));
@@ -416,7 +576,7 @@ const upgradeSubscription = (options) => {
 			return false;
 		});
 		const incompleteSubscription = subscriptions$1.find((sub) => sub.status === "incomplete");
-		if (activeOrTrialingSubscription && activeOrTrialingSubscription.status === "active" && activeOrTrialingSubscription.plan === ctx.body.plan && activeOrTrialingSubscription.seats === (ctx.body.seats || 1)) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.ALREADY_SUBSCRIBED_PLAN);
+		if (activeOrTrialingSubscription && activeOrTrialingSubscription.status === "active" && activeOrTrialingSubscription.plan === ctx.body.plan && activeOrTrialingSubscription.seats === (ctx.body.seats || 1)) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.ALREADY_SUBSCRIBED_PLAN);
 		if (activeSubscription && customerId) {
 			let dbSubscription = await ctx.context.adapter.findOne({
 				model: "subscription",
@@ -502,7 +662,7 @@ const upgradeSubscription = (options) => {
 		});
 		if (!subscription) {
 			ctx.context.logger.error("Subscription ID not found");
-			throw new APIError("INTERNAL_SERVER_ERROR");
+			throw APIError$1.from("NOT_FOUND", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND);
 		}
 		const params = await subscriptionOptions.getCheckoutSessionParams?.({
 			user: user$1,
@@ -530,26 +690,36 @@ const upgradeSubscription = (options) => {
 		const checkoutSession = await client.checkout.sessions.create({
 			...customerId ? {
 				customer: customerId,
-				customer_update: {
+				customer_update: customerType !== "user" ? { address: "auto" } : {
 					name: "auto",
 					address: "auto"
 				}
-			} : { customer_email: session.user.email },
+			} : { customer_email: user$1.email },
 			success_url: getUrl(ctx, `${ctx.context.baseURL}/subscription/success?callbackURL=${encodeURIComponent(ctx.body.successUrl)}&subscriptionId=${encodeURIComponent(subscription.id)}`),
 			cancel_url: getUrl(ctx, ctx.body.cancelUrl),
 			line_items: [{
 				price: priceIdToUse,
 				quantity: ctx.body.seats || 1
 			}],
-			subscription_data: { ...freeTrial },
+			subscription_data: {
+				...freeTrial,
+				metadata: {
+					...ctx.body.metadata,
+					...params?.params?.subscription_data?.metadata,
+					userId: user$1.id,
+					subscriptionId: subscription.id,
+					referenceId
+				}
+			},
 			mode: "subscription",
 			client_reference_id: referenceId,
 			...params?.params,
 			metadata: {
+				...ctx.body.metadata,
+				...params?.params?.metadata,
 				userId: user$1.id,
 				subscriptionId: subscription.id,
-				referenceId,
-				...params?.params?.metadata
+				referenceId
 			}
 		}, params?.options).catch(async (e) => {
 			throw ctx.error("BAD_REQUEST", {
@@ -621,6 +791,7 @@ const cancelSubscriptionCallback = (options) => {
 const cancelSubscriptionBodySchema = z.object({
 	referenceId: z.string().meta({ description: "Reference id of the subscription to cancel. Eg: '123'" }).optional(),
 	subscriptionId: z.string().meta({ description: "The Stripe subscription ID to cancel. Eg: 'sub_1ABC2DEF3GHI4JKL'" }).optional(),
+	customerType: z.enum(["user", "organization"]).meta({ description: "Customer type for the subscription. Eg: \"user\" or \"organization\"" }).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: \"/account\"" }),
 	disableRedirect: z.boolean().meta({ description: "Disable redirect after successful subscription cancellation. Eg: true" }).default(false)
 });
@@ -647,12 +818,13 @@ const cancelSubscription = (options) => {
 		body: cancelSubscriptionBodySchema,
 		metadata: { openapi: { operationId: "cancelSubscription" } },
 		use: [
-			sessionMiddleware,
-			originCheck((ctx) => ctx.body.returnUrl),
-			referenceMiddleware(subscriptionOptions, "cancel-subscription")
+			stripeSessionMiddleware,
+			referenceMiddleware(subscriptionOptions, "cancel-subscription"),
+			originCheck((ctx) => ctx.body.returnUrl)
 		]
 	}, async (ctx) => {
-		const referenceId = ctx.body?.referenceId || ctx.context.session.user.id;
+		const customerType = ctx.body.customerType || "user";
+		const referenceId = ctx.body.referenceId || getReferenceId(ctx.context.session, customerType, options);
 		let subscription = ctx.body.subscriptionId ? await ctx.context.adapter.findOne({
 			model: "subscription",
 			where: [{
@@ -667,7 +839,7 @@ const cancelSubscription = (options) => {
 			}]
 		}).then((subs) => subs.find((sub) => isActiveOrTrialing(sub)));
 		if (ctx.body.subscriptionId && subscription && subscription.referenceId !== referenceId) subscription = void 0;
-		if (!subscription || !subscription.stripeCustomerId) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_FOUND);
+		if (!subscription || !subscription.stripeCustomerId) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND);
 		const activeSubscriptions = await client.subscriptions.list({ customer: subscription.stripeCustomerId }).then((res) => res.data.filter((sub) => isActiveOrTrialing(sub)));
 		if (!activeSubscriptions.length) {
 			/**
@@ -681,10 +853,10 @@ const cancelSubscription = (options) => {
 					value: referenceId
 				}]
 			});
-			throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_FOUND);
+			throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND);
 		}
 		const activeSubscription = activeSubscriptions.find((sub) => sub.id === subscription.stripeSubscriptionId);
-		if (!activeSubscription) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_FOUND);
+		if (!activeSubscription) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND);
 		const { url } = await client.billingPortal.sessions.create({
 			customer: subscription.stripeCustomerId,
 			return_url: getUrl(ctx, `${ctx.context.baseURL}/subscription/cancel/callback?callbackURL=${encodeURIComponent(ctx.body?.returnUrl || "/")}&subscriptionId=${encodeURIComponent(subscription.id)}`),
@@ -727,7 +899,8 @@ const cancelSubscription = (options) => {
 };
 const restoreSubscriptionBodySchema = z.object({
 	referenceId: z.string().meta({ description: "Reference id of the subscription to restore. Eg: '123'" }).optional(),
-	subscriptionId: z.string().meta({ description: "The Stripe subscription ID to restore. Eg: 'sub_1ABC2DEF3GHI4JKL'" }).optional()
+	subscriptionId: z.string().meta({ description: "The Stripe subscription ID to restore. Eg: 'sub_1ABC2DEF3GHI4JKL'" }).optional(),
+	customerType: z.enum(["user", "organization"]).meta({ description: "Customer type for the subscription. Eg: \"user\" or \"organization\"" }).optional()
 });
 const restoreSubscription = (options) => {
 	const client = options.stripeClient;
@@ -736,9 +909,10 @@ const restoreSubscription = (options) => {
 		method: "POST",
 		body: restoreSubscriptionBodySchema,
 		metadata: { openapi: { operationId: "restoreSubscription" } },
-		use: [sessionMiddleware, referenceMiddleware(subscriptionOptions, "restore-subscription")]
+		use: [stripeSessionMiddleware, referenceMiddleware(subscriptionOptions, "restore-subscription")]
 	}, async (ctx) => {
-		const referenceId = ctx.body?.referenceId || ctx.context.session.user.id;
+		const customerType = ctx.body.customerType || "user";
+		const referenceId = ctx.body.referenceId || getReferenceId(ctx.context.session, customerType, options);
 		let subscription = ctx.body.subscriptionId ? await ctx.context.adapter.findOne({
 			model: "subscription",
 			where: [{
@@ -753,11 +927,11 @@ const restoreSubscription = (options) => {
 			}]
 		}).then((subs) => subs.find((sub) => isActiveOrTrialing(sub)));
 		if (ctx.body.subscriptionId && subscription && subscription.referenceId !== referenceId) subscription = void 0;
-		if (!subscription || !subscription.stripeCustomerId) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_FOUND);
-		if (subscription.status != "active" && subscription.status != "trialing") throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_ACTIVE);
-		if (!isPendingCancel(subscription)) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION);
+		if (!subscription || !subscription.stripeCustomerId) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND);
+		if (!isActiveOrTrialing(subscription)) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_ACTIVE);
+		if (!isPendingCancel(subscription)) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION);
 		const activeSubscription = await client.subscriptions.list({ customer: subscription.stripeCustomerId }).then((res) => res.data.filter((sub) => isActiveOrTrialing(sub))[0]);
-		if (!activeSubscription) throw APIError.from("BAD_REQUEST", STRIPE_ERROR_CODES$1.SUBSCRIPTION_NOT_FOUND);
+		if (!activeSubscription) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND);
 		const updateParams = {};
 		if (activeSubscription.cancel_at) updateParams.cancel_at = "";
 		else if (activeSubscription.cancel_at_period_end) updateParams.cancel_at_period_end = false;
@@ -783,7 +957,10 @@ const restoreSubscription = (options) => {
 		return ctx.json(newSub);
 	});
 };
-const listActiveSubscriptionsQuerySchema = z.optional(z.object({ referenceId: z.string().meta({ description: "Reference id of the subscription to list. Eg: '123'" }).optional() }));
+const listActiveSubscriptionsQuerySchema = z.optional(z.object({
+	referenceId: z.string().meta({ description: "Reference id of the subscription to list. Eg: '123'" }).optional(),
+	customerType: z.enum(["user", "organization"]).meta({ description: "Customer type for the subscription. Eg: \"user\" or \"organization\"" }).optional()
+}));
 /**
 * ### Endpoint
 *
@@ -805,13 +982,15 @@ const listActiveSubscriptions = (options) => {
 		method: "GET",
 		query: listActiveSubscriptionsQuerySchema,
 		metadata: { openapi: { operationId: "listActiveSubscriptions" } },
-		use: [sessionMiddleware, referenceMiddleware(subscriptionOptions, "list-subscription")]
+		use: [stripeSessionMiddleware, referenceMiddleware(subscriptionOptions, "list-subscription")]
 	}, async (ctx) => {
+		const customerType = ctx.query?.customerType || "user";
+		const referenceId = ctx.query?.referenceId || getReferenceId(ctx.context.session, customerType, options);
 		const subscriptions$1 = await ctx.context.adapter.findMany({
 			model: "subscription",
 			where: [{
 				field: "referenceId",
-				value: ctx.query?.referenceId || ctx.context.session.user.id
+				value: referenceId
 			}]
 		});
 		if (!subscriptions$1.length) return [];
@@ -838,10 +1017,9 @@ const subscriptionSuccess = (options) => {
 		use: [originCheck((ctx) => ctx.query.callbackURL)]
 	}, async (ctx) => {
 		if (!ctx.query || !ctx.query.callbackURL || !ctx.query.subscriptionId) throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
+		const { callbackURL, subscriptionId } = ctx.query;
 		const session = await getSessionFromCtx(ctx);
 		if (!session) throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
-		const { user: user$1 } = session;
-		const { callbackURL, subscriptionId } = ctx.query;
 		const subscription = await ctx.context.adapter.findOne({
 			model: "subscription",
 			where: [{
@@ -849,41 +1027,53 @@ const subscriptionSuccess = (options) => {
 				value: subscriptionId
 			}]
 		});
-		if (subscription?.status === "active" || subscription?.status === "trialing") return ctx.redirect(getUrl(ctx, callbackURL));
-		const customerId = subscription?.stripeCustomerId || user$1.stripeCustomerId;
-		if (customerId) try {
-			const stripeSubscription = await client.subscriptions.list({
-				customer: customerId,
-				status: "active"
-			}).then((res) => res.data[0]);
-			if (stripeSubscription) {
-				const plan = await getPlanByPriceInfo(options, stripeSubscription.items.data[0]?.price.id, stripeSubscription.items.data[0]?.price.lookup_key);
-				if (plan && subscription) await ctx.context.adapter.update({
-					model: "subscription",
-					update: {
-						status: stripeSubscription.status,
-						seats: stripeSubscription.items.data[0]?.quantity || 1,
-						plan: plan.name.toLowerCase(),
-						periodEnd: /* @__PURE__ */ new Date(stripeSubscription.items.data[0]?.current_period_end * 1e3),
-						periodStart: /* @__PURE__ */ new Date(stripeSubscription.items.data[0]?.current_period_start * 1e3),
-						stripeSubscriptionId: stripeSubscription.id,
-						cancelAtPeriodEnd: stripeSubscription.cancel_at_period_end,
-						cancelAt: stripeSubscription.cancel_at ? /* @__PURE__ */ new Date(stripeSubscription.cancel_at * 1e3) : null,
-						canceledAt: stripeSubscription.canceled_at ? /* @__PURE__ */ new Date(stripeSubscription.canceled_at * 1e3) : null,
-						...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) {
+		if (!subscription) {
+			ctx.context.logger.warn(`Subscription record not found for subscriptionId: ${subscriptionId}`);
+			throw ctx.redirect(getUrl(ctx, callbackURL));
+		}
+		if (isActiveOrTrialing(subscription)) throw ctx.redirect(getUrl(ctx, callbackURL));
+		const customerId = subscription.stripeCustomerId || session.user.stripeCustomerId;
+		if (!customerId) throw ctx.redirect(getUrl(ctx, callbackURL));
+		const stripeSubscription = await client.subscriptions.list({
+			customer: customerId,
+			status: "active"
+		}).then((res) => res.data[0]).catch((error) => {
 			ctx.context.logger.error("Error fetching subscription from Stripe", error);
+			throw ctx.redirect(getUrl(ctx, callbackURL));
+		});
+		if (!stripeSubscription) throw ctx.redirect(getUrl(ctx, callbackURL));
+		const subscriptionItem = stripeSubscription.items.data[0];
+		if (!subscriptionItem) {
+			ctx.context.logger.warn(`No subscription items found for Stripe subscription ${stripeSubscription.id}`);
+			throw ctx.redirect(getUrl(ctx, callbackURL));
+		}
+		const plan = await getPlanByPriceInfo(options, subscriptionItem.price.id, subscriptionItem.price.lookup_key);
+		if (!plan) {
+			ctx.context.logger.warn(`Plan not found for price ${subscriptionItem.price.id}`);
+			throw ctx.redirect(getUrl(ctx, callbackURL));
 		}
+		await ctx.context.adapter.update({
+			model: "subscription",
+			update: {
+				status: stripeSubscription.status,
+				seats: subscriptionItem.quantity || 1,
+				plan: plan.name.toLowerCase(),
+				periodEnd: /* @__PURE__ */ new Date(subscriptionItem.current_period_end * 1e3),
+				periodStart: /* @__PURE__ */ new Date(subscriptionItem.current_period_start * 1e3),
+				stripeSubscriptionId: stripeSubscription.id,
+				cancelAtPeriodEnd: stripeSubscription.cancel_at_period_end,
+				cancelAt: stripeSubscription.cancel_at ? /* @__PURE__ */ new Date(stripeSubscription.cancel_at * 1e3) : null,
+				canceledAt: stripeSubscription.canceled_at ? /* @__PURE__ */ new Date(stripeSubscription.canceled_at * 1e3) : null,
+				...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
+			}]
+		});
 		throw ctx.redirect(getUrl(ctx, callbackURL));
 	});
 };
@@ -892,6 +1082,7 @@ const createBillingPortalBodySchema = z.object({
 		return typeof localization === "string";
 	}).optional(),
 	referenceId: z.string().optional(),
+	customerType: z.enum(["user", "organization"]).meta({ description: "Customer type for the subscription. Eg: \"user\" or \"organization\"" }).optional(),
 	returnUrl: z.string().default("/"),
 	disableRedirect: z.boolean().meta({ description: "Disable redirect after creating billing portal session. Eg: true" }).default(false)
 });
@@ -903,22 +1094,41 @@ const createBillingPortal = (options) => {
 		body: createBillingPortalBodySchema,
 		metadata: { openapi: { operationId: "createBillingPortal" } },
 		use: [
-			sessionMiddleware,
-			originCheck((ctx) => ctx.body.returnUrl),
-			referenceMiddleware(subscriptionOptions, "billing-portal")
+			stripeSessionMiddleware,
+			referenceMiddleware(subscriptionOptions, "billing-portal"),
+			originCheck((ctx) => ctx.body.returnUrl)
 		]
 	}, async (ctx) => {
 		const { user: user$1 } = ctx.context.session;
-		const referenceId = ctx.body.referenceId || user$1.id;
-		let customerId = user$1.stripeCustomerId;
-		if (!customerId) customerId = (await ctx.context.adapter.findMany({
-			model: "subscription",
-			where: [{
-				field: "referenceId",
-				value: referenceId
-			}]
-		}).then((subs) => subs.find((sub) => isActiveOrTrialing(sub))))?.stripeCustomerId;
-		if (!customerId) throw new APIError("BAD_REQUEST", { message: "No Stripe customer found for this user" });
+		const customerType = ctx.body.customerType || "user";
+		const referenceId = ctx.body.referenceId || getReferenceId(ctx.context.session, customerType, options);
+		let customerId;
+		if (customerType === "organization") {
+			customerId = (await ctx.context.adapter.findOne({
+				model: "organization",
+				where: [{
+					field: "id",
+					value: referenceId
+				}]
+			}))?.stripeCustomerId;
+			if (!customerId) customerId = (await ctx.context.adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId
+				}]
+			}).then((subs) => subs.find((sub) => isActiveOrTrialing(sub))))?.stripeCustomerId;
+		} else {
+			customerId = user$1.stripeCustomerId;
+			if (!customerId) customerId = (await ctx.context.adapter.findMany({
+				model: "subscription",
+				where: [{
+					field: "referenceId",
+					value: referenceId
+				}]
+			}).then((subs) => subs.find((sub) => isActiveOrTrialing(sub))))?.stripeCustomerId;
+		}
+		if (!customerId) throw APIError$1.from("NOT_FOUND", STRIPE_ERROR_CODES.CUSTOMER_NOT_FOUND);
 		try {
 			const { url } = await client.billingPortal.sessions.create({
 				locale: ctx.body.locale,
@@ -931,7 +1141,7 @@ const createBillingPortal = (options) => {
 			});
 		} catch (error) {
 			ctx.context.logger.error("Error creating billing portal session", error);
-			throw new APIError("BAD_REQUEST", { message: error.message });
+			throw APIError$1.from("INTERNAL_SERVER_ERROR", STRIPE_ERROR_CODES.UNABLE_TO_CREATE_BILLING_PORTAL);
 		}
 	});
 };
@@ -946,20 +1156,21 @@ const stripeWebhook = (options) => {
 		cloneRequest: true,
 		disableBody: true
 	}, async (ctx) => {
-		if (!ctx.request?.body) throw new APIError("INTERNAL_SERVER_ERROR");
-		const buf = await ctx.request.text();
+		if (!ctx.request?.body) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.INVALID_REQUEST_BODY);
 		const sig = ctx.request.headers.get("stripe-signature");
+		if (!sig) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.STRIPE_SIGNATURE_NOT_FOUND);
 		const webhookSecret = options.stripeWebhookSecret;
+		if (!webhookSecret) throw APIError$1.from("INTERNAL_SERVER_ERROR", STRIPE_ERROR_CODES.STRIPE_WEBHOOK_SECRET_NOT_FOUND);
+		const payload = await ctx.request.text();
 		let event;
 		try {
-			if (!sig || !webhookSecret) throw new APIError("BAD_REQUEST", { message: "Stripe webhook secret not found" });
-			if (typeof client.webhooks.constructEventAsync === "function") event = await client.webhooks.constructEventAsync(buf, sig, webhookSecret);
-			else event = client.webhooks.constructEvent(buf, sig, webhookSecret);
+			if (typeof client.webhooks.constructEventAsync === "function") event = await client.webhooks.constructEventAsync(payload, sig, webhookSecret);
+			else event = client.webhooks.constructEvent(payload, sig, webhookSecret);
 		} catch (err) {
 			ctx.context.logger.error(`${err.message}`);
-			throw new APIError("BAD_REQUEST", { message: `Webhook Error: ${err.message}` });
+			throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.FAILED_TO_CONSTRUCT_STRIPE_EVENT);
 		}
-		if (!event) throw new APIError("BAD_REQUEST", { message: "Failed to construct event" });
+		if (!event) throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.FAILED_TO_CONSTRUCT_STRIPE_EVENT);
 		try {
 			switch (event.type) {
 				case "checkout.session.completed":
@@ -984,23 +1195,11 @@ const stripeWebhook = (options) => {
 			}
 		} catch (e) {
 			ctx.context.logger.error(`Stripe webhook failed. Error: ${e.message}`);
-			throw new APIError("BAD_REQUEST", { message: "Webhook error: See server logs for more information." });
+			throw APIError$1.from("BAD_REQUEST", STRIPE_ERROR_CODES.STRIPE_WEBHOOK_ERROR);
 		}
 		return ctx.json({ success: true });
 	});
 };
-const getUrl = (ctx, url) => {
-	if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(url)) return url;
-	return `${ctx.context.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;
-}
 
 //#endregion
 //#region src/schema.ts
@@ -1067,6 +1266,10 @@ const user = { user: { fields: { stripeCustomerId: {
 	type: "string",
 	required: false
 } } } };
+const organization = { organization: { fields: { stripeCustomerId: {
+	type: "string",
+	required: false
+} } } };
 const getSchema = (options) => {
 	let baseSchema = {};
 	if (options.subscription?.enabled) baseSchema = {
@@ -1074,6 +1277,10 @@ const getSchema = (options) => {
 		...user
 	};
 	else baseSchema = { ...user };
+	if (options.organization?.enabled) baseSchema = {
+		...baseSchema,
+		...organization
+	};
 	if (options.schema && !options.subscription?.enabled && "subscription" in options.schema) {
 		const { subscription: _subscription, ...restSchema } = options.schema;
 		return mergeSchema(baseSchema, restSchema);
@@ -1083,16 +1290,6 @@ const getSchema = (options) => {
 
 //#endregion
 //#region src/index.ts
-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"
-});
 const stripe = (options) => {
 	const client = options.stripeClient;
 	const subscriptionEndpoints = {
@@ -1111,13 +1308,70 @@ const stripe = (options) => {
 			...options.subscription?.enabled ? subscriptionEndpoints : {}
 		},
 		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) => {
+					const { organization: organization$1 } = data;
+					if (!organization$1?.stripeCustomerId) return;
+					try {
+						const stripeCustomer = await client.customers.retrieve(organization$1.stripeCustomerId);
+						if (stripeCustomer.deleted) {
+							ctx.logger.warn(`Stripe customer ${organization$1.stripeCustomerId} was deleted`);
+							return;
+						}
+						if (organization$1.name !== stripeCustomer.name) {
+							await client.customers.update(organization$1.stripeCustomerId, { name: organization$1.name });
+							ctx.logger.info(`Synced organization name to Stripe: "${stripeCustomer.name}" → "${organization$1.name}"`);
+						}
+					} catch (e) {
+						ctx.logger.error(`Failed to sync organization to Stripe: ${e.message}`);
+					}
+				};
+				/**
+				* Block deletion if organization has active subscriptions
+				*/
+				const beforeDeleteStripeOrg = async (data) => {
+					const { organization: organization$1 } = data;
+					if (!organization$1.stripeCustomerId) return;
+					try {
+						const subscriptions$1 = await client.subscriptions.list({
+							customer: organization$1.stripeCustomerId,
+							status: "all",
+							limit: 100
+						});
+						for (const sub of subscriptions$1.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) {
+						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$1, ctx$1) {
-					if (!ctx$1 || !options.createCustomerOnSignUp) return;
+					if (!ctx$1 || !options.createCustomerOnSignUp || user$1.stripeCustomerId) return;
 					try {
-						if (user$1.stripeCustomerId) return;
-						let stripeCustomer = (await client.customers.list({
-							email: user$1.email,
+						let stripeCustomer = (await client.customers.search({
+							query: `email:"${escapeStripeSearchValue(user$1.email)}" AND -metadata["customerType"]:"organization"`,
 							limit: 1
 						})).data[0];
 						if (stripeCustomer) {
@@ -1137,7 +1391,10 @@ const stripe = (options) => {
 						const params = defu({
 							email: user$1.email,
 							name: user$1.name,
-							metadata: { userId: user$1.id }
+							metadata: {
+								userId: user$1.id,
+								customerType: "user"
+							}
 						}, extraCreateParams);
 						stripeCustomer = await client.customers.create(params);
 						await ctx$1.context.internalAdapter.updateUser(user$1.id, { stripeCustomerId: stripeCustomer.id });
@@ -1154,17 +1411,15 @@ const stripe = (options) => {
 					}
 				} },
 				update: { async after(user$1, ctx$1) {
-					if (!ctx$1) return;
+					if (!ctx$1 || !user$1.stripeCustomerId) return;
 					try {
-						const userWithStripe = user$1;
-						if (!userWithStripe.stripeCustomerId) return;
-						const stripeCustomer = await client.customers.retrieve(userWithStripe.stripeCustomerId);
+						const stripeCustomer = await client.customers.retrieve(user$1.stripeCustomerId);
 						if (stripeCustomer.deleted) {
-							ctx$1.context.logger.warn(`Stripe customer ${userWithStripe.stripeCustomerId} was deleted, cannot update email`);
+							ctx$1.context.logger.warn(`Stripe customer ${user$1.stripeCustomerId} was deleted, cannot update email`);
 							return;
 						}
 						if (stripeCustomer.email !== user$1.email) {
-							await client.customers.update(userWithStripe.stripeCustomerId, { email: user$1.email });
+							await client.customers.update(user$1.stripeCustomerId, { email: user$1.email });
 							ctx$1.context.logger.info(`Updated Stripe customer email from ${stripeCustomer.email} to ${user$1.email}`);
 						}
 					} catch (e) {