@nexo-labs/payload-stripe-inventory 1.6.1

package/dist/server/index.mjs

@@ -0,0 +1,1031 @@
+import { S as generateUserInventory, _ as PricingType, a as getPermissionsSlugs, b as permissionSlugs, d as COLLECTION_SLUG_PRICES, f as COLLECTION_SLUG_PRODUCTS, g as PricingPlanInterval, m as MAX_UNLOCKS_PER_WEEK, n as countWeeklyUnlocksQuery, p as COLLECTION_SLUG_USER, r as checkIfUserCanUnlockQuery, u as COLLECTION_SLUG_CUSTOMERS, x as generateCustomerInventory, y as formatOptions } from "../src-BmlQoR4x.mjs";
+import Stripe from "stripe";
+import { headers } from "next/headers.js";
+import { NextResponse } from "next/server.js";
+import { COLLECTION_SLUG_TAXONOMY, buildTaxonomyRelationship } from "@nexo-labs/payload-taxonomies";
+import { stripePlugin } from "@payloadcms/plugin-stripe";
+
+//#region src/server/utils/payload/upsert.ts
+const payloadUpsert = async ({ payload, collection, data, where }) => {
+	try {
+		const existingDocId = (await payload.find({
+			collection,
+			where,
+			pagination: false,
+			limit: 1
+		})).docs?.at(0)?.id;
+		if (existingDocId) return await payload.update({
+			collection,
+			id: existingDocId,
+			data
+		}) || null;
+		return await payload.create({
+			collection,
+			data
+		});
+	} catch (error) {
+		console.error(`Error in payloadUpsert: ${error}`);
+		throw new Error(`Failed to upsert document in collection ${collection} ${error}`);
+	}
+};
+
+//#endregion
+//#region src/server/utils/stripe/stripe-builder.ts
+const stripeBuilder = () => {
+	return new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2024-09-30.acacia" });
+};
+
+//#endregion
+//#region src/server/actions/price.ts
+const updatePrices = async (payload) => {
+	const promises = (await (await stripeBuilder()).prices.list({
+		limit: 100,
+		active: true
+	})).data.map((price) => priceUpsert(price, payload));
+	const pricesByProductId = (await Promise.all(promises)).mapNotNull((t) => t).reduce((acc, { productId, priceId }) => {
+		if (!acc[productId]) acc[productId] = [];
+		acc[productId].push(priceId);
+		return acc;
+	}, {});
+	Object.entries(pricesByProductId).map(async ([productId, prices$1]) => {
+		await payload.update({
+			collection: COLLECTION_SLUG_PRODUCTS,
+			data: { prices: prices$1 },
+			where: { stripeID: { equals: productId } }
+		});
+	});
+};
+async function priceUpsert(price, payload) {
+	const stripeProductID = typeof price.product === "string" ? price.product : price.product.id;
+	if (price.deleted !== void 0) {
+		priceDeleted(price, payload);
+		return null;
+	}
+	if (price.unit_amount == null) return null;
+	const priceUpserted = await payloadUpsert({
+		payload,
+		collection: COLLECTION_SLUG_PRICES,
+		data: {
+			stripeID: price.id,
+			stripeProductId: stripeProductID,
+			active: price.active,
+			unitAmount: price.unit_amount,
+			currency: price.currency,
+			type: price.type,
+			interval: price.recurring?.interval,
+			intervalCount: price.recurring?.interval_count
+		},
+		where: { stripeID: { equals: price.id } }
+	});
+	if (!priceUpserted) return null;
+	return {
+		productId: stripeProductID,
+		priceId: priceUpserted.id
+	};
+}
+const priceDeleted = async (price, payload) => {
+	const { id } = price;
+	try {
+		await payload.delete({
+			collection: COLLECTION_SLUG_PRICES,
+			where: { stripeID: { equals: id } }
+		});
+	} catch (error) {
+		payload.logger.error(`- Error deleting price: ${error}`);
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/server/actions/product.ts
+const updateProducts = async (payload) => {
+	(await (await stripeBuilder()).products.list({
+		limit: 100,
+		active: true
+	})).data.forEach((product) => productSync(product, payload));
+};
+const productSync = async (object, payload) => {
+	const { id: stripeProductID, name, description, images } = object;
+	if (object.deleted !== void 0) return productDeleted(object, payload);
+	try {
+		await payloadUpsert({
+			payload,
+			collection: COLLECTION_SLUG_PRODUCTS,
+			data: {
+				prices: [],
+				stripeID: stripeProductID,
+				active: true,
+				metadata: object.metadata,
+				type: object.type,
+				name,
+				description,
+				images: images?.map((image) => ({ url: image })) || []
+			},
+			where: { stripeID: { equals: stripeProductID } }
+		});
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+const productDeleted = async (object, payload) => {
+	const { id: stripeProductID } = object;
+	try {
+		const payloadProductID = (await payload.find({
+			collection: COLLECTION_SLUG_PRODUCTS,
+			where: { stripeID: { equals: stripeProductID } }
+		})).docs?.[0]?.id;
+		if (payloadProductID) await payload.delete({
+			collection: COLLECTION_SLUG_PRODUCTS,
+			id: payloadProductID
+		});
+	} catch (error) {
+		payload.logger.error(`- Error deleting product: ${error}`);
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/server/utils/payload/sync-customer-by-email.ts
+async function syncCustomerByEmail({ email, payload }) {
+	const customerId = (await payload.find({
+		collection: COLLECTION_SLUG_CUSTOMERS,
+		where: { email: { equals: email } }
+	})).docs?.[0]?.id;
+	await payload.update({
+		collection: "users",
+		data: { customer: customerId },
+		where: { email: { equals: email } }
+	});
+}
+
+//#endregion
+//#region src/server/utils/payload/upsert-customer-inventory-and-sync-with-user.ts
+async function upsertCustomerInventoryAndSyncWithUser(payload, inventory, email, stripeCustomerId) {
+	await payloadUpsert({
+		payload,
+		collection: COLLECTION_SLUG_CUSTOMERS,
+		data: {
+			email,
+			stripeId: stripeCustomerId,
+			inventory: inventory ?? generateCustomerInventory()
+		},
+		where: { email: { equals: email } }
+	});
+	await syncCustomerByEmail({
+		email,
+		payload
+	});
+}
+
+//#endregion
+//#region src/server/utils/payload/get-userId-by-email.ts
+/**
+* Gets a user ID by email address using Payload's find method
+* @param email - The email address to search for
+* @returns The user ID if found, null otherwise
+*/
+async function getUserIdByEmail({ email, payload }) {
+	return ((await payload.find({
+		collection: COLLECTION_SLUG_USER,
+		where: { email: { equals: email } }
+	})).docs?.[0])?.id;
+}
+
+//#endregion
+//#region src/server/utils/stripe/get-customer.ts
+async function getCustomer({ stripe, email }) {
+	stripe = stripe ?? stripeBuilder();
+	const customers$1 = await stripe.customers.search({ query: `email:'${email}'` });
+	return customers$1.data.length ? customers$1.data[0] : null;
+}
+async function resolveStripeCustomer({ customer }) {
+	const stripe = stripeBuilder();
+	if (typeof customer === "string") return await stripe.customers.retrieve(customer);
+	return customer;
+}
+
+//#endregion
+//#region src/server/utils/payload/remove-customer-by-stripe-id.ts
+async function removeCustomerByStripeId({ stripeId, payload }) {
+	await payload.delete({
+		collection: COLLECTION_SLUG_CUSTOMERS,
+		where: { stripeId: { equals: stripeId } }
+	});
+	payload.logger.info(`✅ Successfully removed customer with Stripe ID: ${stripeId}`);
+}
+
+//#endregion
+//#region src/server/utils/payload/find-or-create-customer.ts
+/**
+* Finds a customer by email address in the customers collection, or creates one if not found
+* @param email - The email address to search for
+* @param payload - Payload instance
+* @param stripeId - Optional Stripe customer ID to set when creating
+* @returns The customer document (found or created)
+*/
+async function findOrCreateCustomer({ email, payload, stripeId }) {
+	if (!email) {
+		payload.logger.error("Email is required to find or create customer");
+		return null;
+	}
+	try {
+		let existingCustomer = (await payload.find({
+			collection: COLLECTION_SLUG_CUSTOMERS,
+			where: { email: { equals: email } }
+		})).docs?.[0];
+		if (existingCustomer) {
+			existingCustomer.inventory = existingCustomer?.inventory ? existingCustomer.inventory : generateCustomerInventory();
+			return existingCustomer;
+		}
+		payload.logger.info(`Creating new customer for email: ${email}`);
+		const newCustomer = await payload.create({
+			collection: COLLECTION_SLUG_CUSTOMERS,
+			data: {
+				email,
+				stripeId: stripeId || "",
+				inventory: generateCustomerInventory()
+			}
+		});
+		payload.logger.info(`✅ Successfully created customer for email: ${email}`);
+		return newCustomer;
+	} catch (error) {
+		payload.logger.error(`Error finding or creating customer for email ${email}: ${error}`);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/server/actions/subscription.ts
+const subscriptionUpsert = async (subscription, payload, onSubscriptionUpdate) => {
+	const { id: stripeID, status, customer: stripeCustomer } = subscription;
+	const customer = await resolveStripeCustomer({ customer: stripeCustomer });
+	const error = (message) => payload.logger.error("Subscription Upsert: ", message);
+	const info = (message) => payload.logger.info("Subscription Upsert: ", message);
+	if (!customer) {
+		error("No stripe customer found for subscription");
+		return;
+	}
+	if (customer.deleted) {
+		await removeCustomerByStripeId({
+			stripeId: customer.id,
+			payload
+		});
+		return;
+	}
+	if (!customer.email) {
+		error("No email found for stripe customer");
+		return;
+	}
+	const email = customer.email;
+	const stripeId = customer.id;
+	try {
+		const customer$1 = await findOrCreateCustomer({
+			email,
+			payload,
+			stripeId
+		});
+		const item = subscription.items.data.at(0);
+		if (!item || !customer$1) {
+			error(`No item ${item} or customer ${customer$1} found`);
+			return;
+		}
+		const { docs: products$1 } = await payload.find({
+			collection: COLLECTION_SLUG_PRODUCTS,
+			where: { stripeID: { equals: item.price.product } }
+		});
+		const product = products$1.at(0);
+		if (!product) return;
+		const inventory = customer$1.inventory;
+		inventory.subscriptions[stripeID] = {
+			...subscription,
+			permissions: getPermissionsSlugs({ permissions: product.roles })
+		};
+		info(`INVENTORY OF THE SUBSCRIPTION ${inventory}`);
+		await upsertCustomerInventoryAndSyncWithUser(payload, inventory, email, stripeId);
+		if (["active", "trialing"].includes(status)) {
+			const userId = await getUserIdByEmail({
+				email,
+				payload
+			});
+			if (!userId) return;
+			await onSubscriptionUpdate("create", userId);
+		}
+		info(`✅ Successfully updated subscription with ID: ${stripeID} for user: ${email}`);
+	} catch (e) {
+		error(`- Error managing subscription: ${e}`);
+		throw e;
+	}
+};
+const subscriptionDeleted = async (subscription, payload, onSubscriptionUpdate) => {
+	const { id, customer: customerId } = subscription;
+	const customer = await resolveStripeCustomer({ customer: customerId });
+	const stripeId = customer?.id;
+	if (!customer) {
+		payload.logger.error("No stripe customer found for subscription");
+		return;
+	}
+	if (customer.deleted) {
+		await removeCustomerByStripeId({
+			stripeId: customer.id,
+			payload
+		});
+		return;
+	}
+	if (!customer.email) {
+		payload.logger.error("No email found for stripe customer");
+		return;
+	}
+	const email = customer.email;
+	try {
+		const customer$1 = await findOrCreateCustomer({
+			email,
+			payload,
+			stripeId
+		});
+		if (!customer$1) {
+			payload.logger.error("No customer found for subscription");
+			return;
+		}
+		const inventory = customer$1.inventory;
+		delete inventory.subscriptions[id];
+		await upsertCustomerInventoryAndSyncWithUser(payload, inventory, email, stripeId);
+		const userId = await getUserIdByEmail({
+			email,
+			payload
+		});
+		if (!userId) {
+			payload.logger.error("No user found for subscription");
+			return;
+		}
+		await onSubscriptionUpdate("delete", userId);
+		payload.logger.info(`✅ Successfully deleted subscription: ${id} for user: ${email}`);
+	} catch (error) {
+		payload.logger.error(`- Error deleting subscription: ${error}`);
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/server/actions/donation.ts
+const paymentSucceeded = async (paymentIntent, payload) => {
+	const { id, customer: paymentCustomer } = paymentIntent;
+	const stripeCustomer = await resolveStripeCustomer({ customer: paymentCustomer });
+	if (!stripeCustomer) {
+		payload.logger.error("No stripe customer found for payment");
+		return;
+	}
+	if (stripeCustomer.deleted) {
+		await removeCustomerByStripeId({
+			stripeId: stripeCustomer.id,
+			payload
+		});
+		return;
+	}
+	if (!stripeCustomer.email) {
+		payload.logger.error("No email found for stripe customer");
+		return;
+	}
+	try {
+		const customer = await findOrCreateCustomer({
+			email: stripeCustomer.email,
+			payload,
+			stripeId: stripeCustomer.id
+		});
+		if (!customer) return;
+		if (!customer) {
+			payload.logger.error(`User not found for payment: ${stripeCustomer.email}`);
+			return;
+		}
+		let inventory = customer.inventory;
+		inventory.payments[id] = paymentIntent;
+		await payload.update({
+			collection: COLLECTION_SLUG_CUSTOMERS,
+			data: { inventory },
+			where: { email: { equals: stripeCustomer.email } }
+		});
+		payload.logger.info(`✅ Successfully recorded ${stripeCustomer.metadata?.type ?? "subscription"} with Payment Intent ID: ${id} for user: ${stripeCustomer.email}`);
+	} catch (error) {
+		payload.logger.error(`- Error recording payment: ${error}`);
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/server/actions/invoice.ts
+const invoiceSucceeded = async (invoiceIntent, payload) => {
+	const { id, customer: paymentCustomer } = invoiceIntent;
+	const stripeCustomer = await resolveStripeCustomer({ customer: paymentCustomer });
+	if (!stripeCustomer) {
+		payload.logger.error("No stripe customer found for payment");
+		return;
+	}
+	if (stripeCustomer.deleted) {
+		await removeCustomerByStripeId({
+			stripeId: stripeCustomer.id,
+			payload
+		});
+		return;
+	}
+	if (!stripeCustomer.email) {
+		payload.logger.error("No email found for stripe customer");
+		return;
+	}
+	try {
+		const customer = await findOrCreateCustomer({
+			email: stripeCustomer.email,
+			payload,
+			stripeId: stripeCustomer.id
+		});
+		if (!customer) return;
+		let inventory = customer.inventory;
+		inventory.invoices[id] = invoiceIntent;
+		await payload.update({
+			collection: COLLECTION_SLUG_CUSTOMERS,
+			data: { inventory },
+			where: { email: { equals: stripeCustomer.email } }
+		});
+		payload.logger.info(`✅ Successfully recorded ${stripeCustomer.metadata?.type ?? "subscription"} with Payment Intent ID: ${id} for user: ${stripeCustomer.email}`);
+	} catch (error) {
+		payload.logger.error(`- Error recording payment: ${error}`);
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/server/actions/customer.ts
+const customerDeleted = async (customer, payload) => {
+	const { id, email } = customer;
+	try {
+		await payload.delete({
+			collection: COLLECTION_SLUG_CUSTOMERS,
+			where: { email: { equals: email } }
+		});
+		payload.logger.info(`✅ Successfully deleted customer with Stripe ID: ${id}`);
+	} catch (error) {
+		payload.logger.error(`- Error deleting subscription: ${error}`);
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/server/access/get-current-user-query.ts
+async function getCurrentUserQuery(payload) {
+	const headers$1 = await headers();
+	return (await payload.auth({ headers: headers$1 })).user;
+}
+
+//#endregion
+//#region src/server/actions/unlock-item-for-user-action.ts
+const addUniqueUnlock = (unlocks, collection, contentId) => {
+	if (unlocks.some((unlock) => unlock.collection === collection && unlock.id === contentId)) return unlocks;
+	return [...unlocks, {
+		collection,
+		id: contentId,
+		dateUnlocked: /* @__PURE__ */ new Date()
+	}];
+};
+const unlockItemForUser = async (getPayload, collection, contentId) => {
+	const payload = await getPayload();
+	const user = await getCurrentUserQuery(payload);
+	if (!user || !user.id) return { error: "Usuario no válido" };
+	const item = await payload.findByID({
+		collection,
+		id: contentId.toString()
+	});
+	if (!item) return { error: "Elemento no encontrado" };
+	if (!checkIfUserCanUnlockQuery(user, getPermissionsSlugs({ permissions: item.permissions }))) return { error: "No tienes permisos para desbloquear este elemento" };
+	if (countWeeklyUnlocksQuery(user) >= MAX_UNLOCKS_PER_WEEK) return { error: `Has alcanzado el límite de ${MAX_UNLOCKS_PER_WEEK} desbloqueos para esta semana` };
+	const inventory = user.inventory ?? generateUserInventory();
+	const updatedUnlocks = addUniqueUnlock(inventory.unlocks, collection, contentId);
+	if (updatedUnlocks.length === inventory.unlocks.length) return { data: true };
+	try {
+		await payload.update({
+			collection: COLLECTION_SLUG_USER,
+			id: user.id.toString(),
+			data: { inventory: {
+				...inventory,
+				unlocks: updatedUnlocks
+			} }
+		});
+		return { data: true };
+	} catch (error) {
+		console.error("Error al actualizar el inventario del usuario:", error);
+		return { error: "Error al actualizar el inventario del usuario" };
+	}
+};
+
+//#endregion
+//#region src/server/actions/update-products-and-prices-action.ts
+async function updateProductsAndPrices(payload) {
+	await updateProducts(payload);
+	await updatePrices(payload);
+}
+
+//#endregion
+//#region src/server/utils/stripe/create-customer-at-stripe.ts
+async function createCustomerAtStripe({ stripe, email, name }) {
+	stripe = stripe ?? stripeBuilder();
+	return await stripe.customers.create({
+		email,
+		name: name || void 0
+	});
+}
+
+//#endregion
+//#region src/server/utils/stripe/get-customer-from-stripe-or-create.ts
+async function getCustomerFromStripeOrCreate(email, name) {
+	const stripe = stripeBuilder();
+	let customer = await getCustomer({
+		stripe,
+		email
+	});
+	if (!customer) customer = await createCustomerAtStripe({
+		stripe,
+		email,
+		name
+	});
+	return customer.id;
+}
+
+//#endregion
+//#region src/server/api/handle-donation.ts
+async function handleDonation(request, getPayload, getRoutes) {
+	const payload = await getPayload();
+	const payloadUser = await getCurrentUserQuery(payload);
+	if (!payloadUser || !payloadUser.email) throw new Error("You must be logged in to make a donation");
+	const amountParam = new URL(request.url).searchParams.get("amount");
+	if (!amountParam) throw new Error("Amount is required");
+	const amount = parseInt(amountParam);
+	if (amount < 100) throw new Error("Minimum donation amount is €1");
+	const stripe = stripeBuilder();
+	const customerId = await getCustomerFromStripeOrCreate(payloadUser.email, payloadUser.name);
+	await upsertCustomerInventoryAndSyncWithUser(payload, payloadUser.customer?.inventory, payloadUser.email, customerId);
+	const metadata = { type: "donation" };
+	const session = await stripe.checkout.sessions.create({
+		customer: customerId,
+		payment_method_types: ["card"],
+		line_items: [{
+			price_data: {
+				currency: "eur",
+				product_data: {
+					name: "Donación - Portal Escohotado",
+					description: "Apoyo al mantenimiento del legado digital de Antonio Escohotado"
+				},
+				unit_amount: amount
+			},
+			quantity: 1
+		}],
+		mode: "payment",
+		success_url: `${process.env.DOMAIN}${getRoutes().nextJS.subscriptionPageHref}?success=donation`,
+		cancel_url: `${process.env.DOMAIN}${getRoutes().nextJS.subscriptionPageHref}?error=donation_cancelled`,
+		metadata,
+		payment_intent_data: { metadata },
+		invoice_creation: {
+			enabled: true,
+			invoice_data: { metadata }
+		}
+	});
+	return NextResponse.json({ url: session.url });
+}
+
+//#endregion
+//#region src/server/api/handle-update.ts
+async function handleUpdate(request, getPayload, getRoutes) {
+	const payload = await getPayload();
+	const payloadUser = await getCurrentUserQuery(payload);
+	if (!payloadUser) throw new Error("You must be logged in to access this page");
+	const { searchParams } = new URL(request.url);
+	const subscriptionId = searchParams.get("subscriptionId");
+	const cancelAtPeriodEnd = searchParams.get("cancelAtPeriodEnd") === "true";
+	if (!subscriptionId) throw Error("SubscriptionId could not be found.");
+	await stripeBuilder().subscriptions.update(subscriptionId, { cancel_at_period_end: cancelAtPeriodEnd });
+	const customer = payloadUser.customer;
+	console.error("UPDATE: customer", customer);
+	const inventory = customer.inventory;
+	if (inventory && inventory.subscriptions && inventory.subscriptions[subscriptionId]) inventory.subscriptions[subscriptionId].cancel_at_period_end = cancelAtPeriodEnd;
+	await upsertCustomerInventoryAndSyncWithUser(payload, inventory, customer.email);
+	const routes = getRoutes();
+	return NextResponse.redirect(`${process.env.DOMAIN}${routes.nextJS.subscriptionPageHref}?refresh=${Date.now()}`, 303);
+}
+
+//#endregion
+//#region src/server/api/handle-portal.ts
+async function handlePortal(request, getPayload, getRoutes) {
+	const payload = await getPayload();
+	const payloadUser = await getCurrentUserQuery(payload);
+	if (!payloadUser || !payloadUser.email) throw new Error("You must be logged in to access this page");
+	const url = new URL(request.url);
+	const cancelSubscriptionId = url.searchParams.get("cancelSubscriptionId");
+	const updateSubscriptionId = url.searchParams.get("updateSubscriptionId");
+	let flowData;
+	if (cancelSubscriptionId) flowData = {
+		type: "subscription_cancel",
+		subscription_cancel: { subscription: cancelSubscriptionId }
+	};
+	else if (updateSubscriptionId) flowData = {
+		type: "subscription_update",
+		subscription_update: { subscription: updateSubscriptionId }
+	};
+	const stripe = stripeBuilder();
+	const routes = getRoutes();
+	const customerId = await getCustomerFromStripeOrCreate(payloadUser.email, payloadUser.name);
+	await upsertCustomerInventoryAndSyncWithUser(payload, payloadUser.customer?.inventory, payloadUser.email, customerId);
+	const session = await stripe.billingPortal.sessions.create({
+		flow_data: flowData,
+		customer: customerId,
+		return_url: `${process.env.DOMAIN}${routes.nextJS.subscriptionPageHref}`
+	});
+	return NextResponse.redirect(session.url, 303);
+}
+
+//#endregion
+//#region src/server/api/handle-checkout.ts
+async function handleCheckout(request, getPayload, getRoutes) {
+	const payload = await getPayload();
+	const payloadUser = await getCurrentUserQuery(payload);
+	const priceId = new URL(request.url).searchParams.get("priceId");
+	if (!priceId || !payloadUser || !payloadUser.email) throw new Error("Invalid request");
+	const stripe = stripeBuilder();
+	const routes = getRoutes();
+	const customerId = await getCustomerFromStripeOrCreate(payloadUser.email, payloadUser.name);
+	await upsertCustomerInventoryAndSyncWithUser(payload, payloadUser.customer?.inventory, payloadUser.email, customerId);
+	const metadata = { type: "subscription" };
+	const checkoutResult = await stripe.checkout.sessions.create({
+		success_url: `${process.env.DOMAIN}${routes.nextJS.subscriptionPageHref}?success=${Date.now()}`,
+		cancel_url: `${process.env.DOMAIN}${routes.nextJS.subscriptionPageHref}?error=${Date.now()}`,
+		mode: "subscription",
+		customer: customerId,
+		client_reference_id: String(payloadUser.id),
+		line_items: [{
+			price: priceId,
+			quantity: 1
+		}],
+		metadata,
+		tax_id_collection: { enabled: true },
+		customer_update: {
+			name: "auto",
+			address: "auto",
+			shipping: "auto"
+		},
+		subscription_data: { metadata }
+	});
+	if (checkoutResult.url) return NextResponse.redirect(checkoutResult.url, 303);
+	else return NextResponse.json("Create checkout url failed", { status: 406 });
+}
+
+//#endregion
+//#region src/server/api/index.ts
+function createStripeInventoryHandlers(getPayload, getRoutes) {
+	return {
+		checkout: { GET: (request) => handleCheckout(request, getPayload, getRoutes) },
+		portal: { GET: (request) => handlePortal(request, getPayload, getRoutes) },
+		update: { GET: (request) => handleUpdate(request, getPayload, getRoutes) },
+		donation: { GET: (request) => handleDonation(request, getPayload, getRoutes) }
+	};
+}
+function createRouteHandlers(getPayload, getRoutes) {
+	return { GET: async (request, { params }) => {
+		const path = (await params).stripe[0];
+		const handlers = createStripeInventoryHandlers(getPayload, getRoutes);
+		if (path === "checkout" || path === "portal" || path === "update" || path === "donation") return handlers[path].GET(request);
+		return NextResponse.json({ error: "Route not found" }, { status: 404 });
+	} };
+}
+
+//#endregion
+//#region src/server/access/access-queries.ts
+const isAdmin = ({ req }) => {
+	return req?.user?.roles?.includes(permissionSlugs.webAdmin) || false;
+};
+const isAnyone = () => true;
+const isAdminOrCurrentUser = ({ req }) => {
+	if (req?.user?.roles?.includes(permissionSlugs.webAdmin)) return true;
+	return { id: { equals: req.user?.id } };
+};
+const isAdminOrPublished = ({ req: { user } }) => {
+	if (user && user?.roles?.includes(permissionSlugs.webAdmin)) return true;
+	return { _status: { equals: "published" } };
+};
+const isAdminOrStripeActive = ({ req: { user } }) => {
+	if (user && user?.roles?.includes(permissionSlugs.webAdmin)) return true;
+	return { active: { equals: true } };
+};
+const isAdminOrUserFieldMatchingCurrentUser = ({ req: { user } }) => {
+	if (user) {
+		if (user?.roles?.includes(permissionSlugs.webAdmin)) return true;
+		return { user: { equals: user?.id } };
+	}
+	return false;
+};
+const loggedInOrPublished = ({ req: { user } }) => {
+	if (user) return true;
+	return { _status: { equals: "published" } };
+};
+
+//#endregion
+//#region src/server/collections/customers.ts
+const customers = {
+	slug: COLLECTION_SLUG_CUSTOMERS,
+	admin: {
+		useAsTitle: "email",
+		group: "Stripe",
+		defaultColumns: [
+			"email",
+			"stripeId",
+			"createdAt"
+		]
+	},
+	access: {
+		read: () => true,
+		create: () => false,
+		update: () => false,
+		delete: isAdmin
+	},
+	fields: [
+		{
+			name: "email",
+			type: "email",
+			required: true,
+			unique: true,
+			admin: { position: "sidebar" }
+		},
+		{
+			name: "stripeId",
+			type: "text",
+			required: true,
+			unique: true,
+			admin: {
+				position: "sidebar",
+				readOnly: true
+			}
+		},
+		{
+			name: "inventory",
+			type: "json",
+			label: "Inventario",
+			admin: {
+				description: "Datos de inventario de Stripe almacenados como JSON",
+				readOnly: true
+			}
+		}
+	]
+};
+
+//#endregion
+//#region src/server/collections/fields/permission-evaluation-field.ts
+const permissionEvaluationField = {
+	type: "row",
+	fields: [{
+		type: "select",
+		name: "type_of_permissions",
+		options: [
+			{
+				label: "Todos",
+				value: "all"
+			},
+			{
+				label: "Permisos por roles",
+				value: "roles"
+			},
+			{
+				label: "Solo para usuarios sin roles",
+				value: "only_no_roles"
+			},
+			{
+				label: "Solo invitados",
+				value: "only_guess"
+			}
+		],
+		defaultValue: "all",
+		label: "Tipo de permisos"
+	}, {
+		type: "relationship",
+		name: "permissions",
+		relationTo: [COLLECTION_SLUG_TAXONOMY],
+		hasMany: false,
+		admin: { condition: (_, siblingData) => siblingData.type_of_permissions === "roles" }
+	}]
+};
+
+//#endregion
+//#region src/server/collections/prices.ts
+const prices = {
+	slug: COLLECTION_SLUG_PRICES,
+	admin: {
+		useAsTitle: "unitAmount",
+		group: "Stripe"
+	},
+	access: {
+		read: isAdminOrStripeActive,
+		create: () => false,
+		update: () => false,
+		delete: isAdmin
+	},
+	fields: [
+		{
+			name: "stripeID",
+			label: "Stripe ID",
+			type: "text",
+			required: true,
+			admin: {
+				position: "sidebar",
+				readOnly: true
+			}
+		},
+		{
+			name: "stripeProductId",
+			type: "text",
+			required: true,
+			admin: {
+				position: "sidebar",
+				readOnly: true
+			}
+		},
+		{
+			name: "product",
+			type: "join",
+			collection: COLLECTION_SLUG_PRODUCTS,
+			on: "prices",
+			hasMany: false
+		},
+		{
+			name: "active",
+			type: "checkbox",
+			required: true,
+			admin: { position: "sidebar" }
+		},
+		{
+			name: "description",
+			type: "textarea"
+		},
+		{
+			type: "row",
+			fields: [
+				{
+					name: "unitAmount",
+					type: "number",
+					required: true
+				},
+				{
+					name: "currency",
+					type: "text",
+					required: true
+				},
+				{
+					name: "type",
+					type: "select",
+					options: formatOptions(PricingType),
+					required: true
+				}
+			]
+		},
+		{
+			type: "row",
+			fields: [
+				{
+					name: "interval",
+					type: "select",
+					options: formatOptions(PricingPlanInterval)
+				},
+				{
+					name: "intervalCount",
+					type: "number"
+				},
+				{
+					name: "trialPeriodDays",
+					type: "number"
+				}
+			]
+		},
+		{
+			name: "metadata",
+			type: "json",
+			label: "Metadata"
+		}
+	]
+};
+
+//#endregion
+//#region src/server/collections/products.ts
+const products = {
+	slug: COLLECTION_SLUG_PRODUCTS,
+	admin: {
+		useAsTitle: "name",
+		group: "Stripe"
+	},
+	access: {
+		read: isAdminOrStripeActive,
+		create: () => false
+	},
+	fields: [
+		{
+			name: "stripeID",
+			label: "Stripe ID",
+			type: "text",
+			required: true,
+			admin: {
+				position: "sidebar",
+				readOnly: true
+			}
+		},
+		{
+			name: "type",
+			type: "select",
+			options: [{
+				value: "good",
+				label: "Bienes"
+			}, {
+				value: "service",
+				label: "Service"
+			}]
+		},
+		{
+			name: "active",
+			type: "checkbox",
+			required: true,
+			admin: { position: "sidebar" }
+		},
+		{
+			name: "show",
+			type: "checkbox",
+			defaultValue: false,
+			admin: { position: "sidebar" }
+		},
+		{
+			name: "name",
+			type: "text",
+			required: true
+		},
+		{
+			name: "description",
+			type: "textarea"
+		},
+		{
+			name: "images",
+			type: "array",
+			fields: [{
+				type: "text",
+				name: "url"
+			}]
+		},
+		{
+			name: "prices",
+			type: "relationship",
+			relationTo: COLLECTION_SLUG_PRICES,
+			hasMany: true,
+			required: false
+		},
+		{
+			name: "metadata",
+			type: "json",
+			label: "Metadata"
+		},
+		{
+			type: "array",
+			name: "features",
+			fields: [{
+				type: "text",
+				name: "title"
+			}]
+		},
+		buildTaxonomyRelationship({
+			name: "roles",
+			label: "Roles",
+			defaultValue: [],
+			filterOptions: () => {
+				return { "payload.types": { in: ["role"] } };
+			},
+			required: false
+		})
+	]
+};
+
+//#endregion
+//#region src/server/plugin.ts
+const plugin = (onSubscriptionUpdate) => {
+	return stripePlugin({
+		isTestKey: process.env.STRIPE_SECRET_KEY?.includes("sk_test"),
+		stripeSecretKey: process.env.STRIPE_SECRET_KEY || "",
+		stripeWebhooksEndpointSecret: process.env.STRIPE_WEBHOOK_SECRET,
+		webhooks: {
+			"price.deleted": async ({ event, payload }) => await priceDeleted(event.data.object, payload),
+			"customer.subscription.created": async ({ event, payload }) => await subscriptionUpsert(event.data.object, payload, onSubscriptionUpdate),
+			"customer.subscription.paused": async ({ event, payload }) => await subscriptionUpsert(event.data.object, payload, onSubscriptionUpdate),
+			"customer.subscription.updated": async ({ event, payload }) => await subscriptionUpsert(event.data.object, payload, onSubscriptionUpdate),
+			"customer.subscription.deleted": async ({ event, payload }) => await subscriptionDeleted(event.data.object, payload, onSubscriptionUpdate),
+			"customer.deleted": async ({ event, payload }) => await customerDeleted(event.data.object, payload),
+			"product.deleted": async ({ event, payload }) => await productDeleted(event.data.object, payload),
+			"payment_intent.succeeded": async ({ event, payload }) => {
+				await paymentSucceeded(event.data.object, payload);
+			},
+			"invoice.paid": async ({ event, payload }) => {
+				await invoiceSucceeded(event.data.object, payload);
+			}
+		}
+	});
+};
+
+//#endregion
+export { createCustomerAtStripe, createRouteHandlers, createStripeInventoryHandlers, customerDeleted, customers, getCustomer, getCustomerFromStripeOrCreate, invoiceSucceeded, isAdmin, isAdminOrCurrentUser, isAdminOrPublished, isAdminOrStripeActive, isAdminOrUserFieldMatchingCurrentUser, isAnyone, loggedInOrPublished, payloadUpsert, paymentSucceeded, permissionEvaluationField, plugin, priceDeleted, priceUpsert, prices, productDeleted, productSync, products, resolveStripeCustomer, stripeBuilder, subscriptionDeleted, subscriptionUpsert, syncCustomerByEmail, unlockItemForUser, updatePrices, updateProducts, updateProductsAndPrices, upsertCustomerInventoryAndSyncWithUser };
+//# sourceMappingURL=index.mjs.map