@monkeyplus/payscope 1.0.0

package/dist/server/router.mjs

@@ -0,0 +1,1157 @@
+import { checkouts, customerAddresses, customerBillings, customerWhislists } from "../_chunks/database.mjs";
+import { GRAPHQL_TOKEN, TASKS_ENDPOINT, URL } from "./env.mjs";
+import { createGraphql, createPayment } from "../_chunks/lib.mjs";
+import { eq } from "drizzle-orm";
+import dayjs from "dayjs";
+import { HTTPError, createError, eventHandler, getCookie, getQuery, getRequestIP, getRouterParam, readBody, redirect, setCookie } from "h3";
+import { joinURL } from "ufo";
+import { defu } from "defu";
+function useUser(event) {
+	return event.context.user;
+}
+function registerAccount(app, db, { path, storeId }) {
+	app.post(path("/account/billings"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		const data = await readBody(event);
+		return await db.insert(customerBillings).values({
+			storeId,
+			customerId,
+			data
+		});
+	}));
+	app.get(path("/account/billings"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		const items = await db.query.customerBillings.findMany({ where: {
+			storeId,
+			customerId
+		} });
+		const formatted = (data) => {
+			return { formatted: [
+				data.identification,
+				data.fullname,
+				data.email
+			].filter((v) => !!v).join("/ ") };
+		};
+		return items.map((item) => ({
+			...item,
+			...item.data,
+			...formatted(item.data),
+			data: void 0
+		}));
+	}));
+	app.patch(path("/account/billings/:id"), eventHandler(async (event) => {
+		const id = getRouterParam(event, "id");
+		const data = await readBody(event);
+		return await db.update(customerBillings).set({ data }).where(eq(customerBillings.id, Number(id))).returning();
+	}));
+	app.delete(path("/account/billings/:id"), eventHandler(async (event) => {
+		const id = getRouterParam(event, "id");
+		return await db.delete(customerBillings).where(eq(customerBillings.id, Number(id)));
+	}));
+	app.post(path("/account/addresses"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		const data = await readBody(event);
+		return await db.insert(customerAddresses).values({
+			storeId,
+			customerId,
+			data
+		});
+	}));
+	app.get(path("/account/addresses"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		const items = await db.query.customerAddresses.findMany({ where: {
+			storeId,
+			customerId
+		} });
+		const formatted = (data) => {
+			return {
+				name: [data.firstName, data.lastName].filter((v) => !!v).join(" "),
+				formatted: [
+					data.address1,
+					data.address2,
+					data.zip,
+					data.city,
+					data.country
+				].filter((v) => !!v).join(", ")
+			};
+		};
+		return items.map((item) => ({
+			...item,
+			...item.data,
+			...formatted(item.data),
+			data: void 0
+		}));
+	}));
+	app.patch(path("/account/addresses/:id"), eventHandler(async (event) => {
+		const id = getRouterParam(event, "id");
+		const data = await readBody(event);
+		return await db.update(customerAddresses).set({ data }).where(eq(customerAddresses.id, Number(id))).returning();
+	}));
+	app.delete(path("/account/addresses/:id"), eventHandler(async (event) => {
+		const id = getRouterParam(event, "id");
+		return await db.delete(customerAddresses).where(eq(customerAddresses.id, Number(id)));
+	}));
+	app.post(path("/account/wishlist"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		const data = await readBody(event);
+		return await db.insert(customerWhislists).values({
+			storeId,
+			customerId,
+			productId: data?.productId,
+			data: data?.data
+		});
+	}));
+	app.get(path("/account/wishlist"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		return await db.query.customerWhislists.findMany({ where: {
+			storeId,
+			customerId
+		} });
+	}));
+	app.patch(path("/account/wishlist/:id"), eventHandler(async (event) => {
+		const id = getRouterParam(event, "id");
+		const data = await readBody(event);
+		return await db.update(customerWhislists).set({ data }).where(eq(customerWhislists.id, Number(id))).returning();
+	}));
+	app.delete(path("/account/wishlist/:id"), eventHandler(async (event) => {
+		const id = getRouterParam(event, "id");
+		return await db.delete(customerWhislists).where(eq(customerWhislists.id, Number(id)));
+	}));
+	app.get(path("/account/returns"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		return await db.query.customerReturns.findMany({ where: {
+			storeId,
+			customerId
+		} });
+	}));
+	app.get(path("/account/orders"), eventHandler(async (event) => {
+		const { id: customerId } = useUser(event);
+		return await db.query.orders.findMany({ where: {
+			storeId,
+			customerId
+		} });
+	}));
+}
+function useGuardSession(auth, options) {
+	return eventHandler(async (event) => {
+		console.log(`${event.method}::${event.path}`);
+		if (options.pathsToExclude.some((p) => event.path.startsWith(p))) return;
+		const session = await auth.api.getSession({ headers: event.req.headers });
+		if (!session?.user) return createError({
+			statusCode: 401,
+			statusMessage: "Unauthorized"
+		});
+		event.context.user = session.user;
+		event.context.session = session.session;
+	});
+}
+function registerAuthMiddleware(app, options) {
+	app.use(options.guard?.path || "/**", useGuardSession(options.auth, { pathsToExclude: [
+		"/api/auth/",
+		"/api/session",
+		...options.guard?.excludePaths || []
+	] }));
+}
+function registerAuth(app, auth) {
+	app.use("/api/auth/**", eventHandler(async (event) => {
+		const r = await auth.handler(event.req);
+		if (r.status === 302) return redirect(r.headers.get("location"));
+		r.headers.forEach((value, key) => {
+			event.res.errHeaders.set(key, value);
+		});
+		return r;
+	}));
+	app.get("/api/session/me", eventHandler(async (event) => {
+		return await auth.api.getSession({ headers: event.headers });
+	}));
+}
+function getTax(store) {
+	const tax = store?.storeTaxes?.default;
+	const taxes = store.country.taxesList;
+	const def = taxes.find((e) => String(e.id) === tax);
+	const def0 = taxes.find((e) => +e.value === 0);
+	return def || def0;
+}
+function normalizeProduct(opts) {
+	const calcPrice = (price, discount) => {
+		const p = +price;
+		return (p - p * +discount / 100).toFixed(2);
+	};
+	const theTax = getTax(opts.store);
+	const taxIncluded = opts.store?.storeTaxes?.included;
+	const getTaxPercentage = () => {
+		return Number(theTax?.value || 0);
+	};
+	const priceWithTaxt = (price = 0) => {
+		price = +price;
+		const tax = getTaxPercentage();
+		if (taxIncluded) return price.toFixed(2);
+		return (price + price * tax / 100).toFixed(2);
+	};
+	return (product) => {
+		const image = product?.images?.[0];
+		const discount = product?.discount || 0;
+		const options = product?.variants?.options?.map((option) => {
+			return {
+				id: option?.option?.name?.toLowerCase(),
+				name: option?.option?.name?.toLowerCase(),
+				values: option.values,
+				type: option?.option?.select
+			};
+		});
+		const variants = product.variants?.variants?.map((variant) => {
+			const imageVariant = variant?.images?.[0];
+			let price = variant.price || product.price;
+			if (discount) price = calcPrice(price, discount);
+			return {
+				id: variant.id,
+				productId: product.id,
+				sku: variant?.sku || product?.sku || "",
+				image: imageVariant || image,
+				price,
+				showPrice: priceWithTaxt(price),
+				priceWithTax: priceWithTaxt(price),
+				comparedPrice: product.comparedPrice,
+				title: product.title,
+				available: true,
+				selectedOptions: Object.entries(variant?.options || {}).map(([key, value]) => {
+					return {
+						name: key,
+						value
+					};
+				})
+			};
+		});
+		let price = product.price;
+		if (discount) price = calcPrice(price, discount);
+		const taxes = product.taxes?.length ? product.taxes.map((tax) => {
+			return {
+				...tax.tax,
+				included: tax.included
+			};
+		}) : theTax ? [{
+			...theTax,
+			included: taxIncluded
+		}] : [];
+		return {
+			...product,
+			price,
+			showPrice: priceWithTaxt(price),
+			priceWithTax: priceWithTaxt(price),
+			comparedPrice: product.comparedPrice || priceWithTaxt(+(product.price || 0)),
+			image,
+			taxes,
+			variants: variants || [{
+				id: product.sku || product.id,
+				productId: product.id,
+				comparedPrice: product.comparedPrice,
+				priceWithTax: priceWithTaxt(price),
+				image,
+				price: product.price,
+				selectedOptions: [{
+					name: product.sku ? "sku" : "item",
+					value: product.sku ? String(product.sku) : String(product.id)
+				}],
+				title: product.title,
+				available: true
+			}],
+			noVariants: !variants?.length,
+			options: options || [{
+				id: "1",
+				name: product.sku ? "sku" : "item",
+				values: [product.sku ? String(product.sku) : String(product.id)]
+			}]
+		};
+	};
+}
+const cache = /* @__PURE__ */ new Map();
+function useProducts(db) {
+	const getStore = async (storeId) => {
+		const _cache = cache.get(`store:${storeId}`);
+		if (_cache && _cache.expires > Date.now()) return _cache.data;
+		const store = await db.query.stores.findFirst({
+			where: { id: storeId },
+			with: { country: { with: { taxesList: { with: { type: true } } } } }
+		});
+		cache.set(`store:${storeId}`, {
+			expires: Date.now() + 3600 * 1e3,
+			data: store
+		});
+		return store;
+	};
+	const getProducts = async (storeId) => {
+		const _cache = cache.get(`products:${storeId}`);
+		if (_cache && _cache.expires > Date.now()) return _cache.data;
+		const items = await db.query.products.findMany({
+			limit: 1e3,
+			columns: {
+				id: true,
+				title: true,
+				variants: true,
+				extras: true,
+				discount: true
+			},
+			with: { taxes: {
+				columns: {
+					id: true,
+					included: true
+				},
+				with: { tax: {
+					columns: {
+						id: true,
+						code: true,
+						value: true
+					},
+					with: { type: { columns: {
+						code: true,
+						name: true
+					} } }
+				} }
+			} }
+		});
+		cache.set(`products:${storeId}`, {
+			expires: Date.now() + 3600 * 1e3,
+			data: items
+		});
+		return items;
+	};
+	return {
+		getProducts: async (storeId) => {
+			const store = await getStore(storeId);
+			return (await getProducts(storeId)).map((p) => normalizeProduct({ store })(p));
+		},
+		getStore
+	};
+}
+function registerCache(app, db, { path, storeId }) {
+	const { getProducts } = useProducts(db);
+	app.get(path("/cache/products"), eventHandler(async () => {
+		return await getProducts(storeId);
+	}));
+	app.get(path("/cache/products/:id/stock"), eventHandler(async (event) => {
+		const productId = getRouterParam(event, "id");
+		const items = await db.query.productStocks.findMany({ where: {
+			productId: +productId,
+			variant: { ne: "" }
+		} });
+		const query = getQuery(event);
+		if (typeof query.selectedOptions === "string") query.selectedOptions = JSON.parse(query.selectedOptions || "[]");
+		const variantId = {
+			selectedOptions: [],
+			...query
+		}.selectedOptions.map((e) => e.value).join("/");
+		const quantityAvailable = items.find((e) => e.variant === variantId)?.quantity || 0;
+		const firstOption = items.reduce((acc, stock) => {
+			if (!stock?.variant) return { ...acc };
+			const [option] = stock?.variant?.split("/");
+			const v = (stock.quantity || 0) + (acc[option] || 0);
+			return {
+				...acc,
+				[option]: v
+			};
+		}, {});
+		const total = Object.values(firstOption).reduce((acc, e) => acc + e, 0);
+		return {
+			variant: {
+				availableForSale: !!quantityAvailable,
+				quantityAvailable
+			},
+			stocks: items,
+			firstOption,
+			total
+		};
+	}));
+	app.get(path("/cache/products/:id/verify"), eventHandler(async (event) => {
+		const productId = getRouterParam(event, "id");
+		const items = await db.query.productStocks.findMany({ where: {
+			productId: +productId,
+			variant: { ne: "" }
+		} });
+		const query = getQuery(event);
+		if (typeof query.selectedOptions === "string") query.selectedOptions = JSON.parse(query.selectedOptions || "[]");
+		const variantId = {
+			selectedOptions: [],
+			...query
+		}.selectedOptions.map((e) => e.value).join("/");
+		return { ok: !!(items.find((e) => e.variant === variantId)?.quantity || 0) };
+	}));
+}
+async function getLineItems(cart, getProducts) {
+	const products = await getProducts();
+	const keys = Object.keys(cart);
+	const allVariants = products.filter((product) => product.variants.some((variant) => {
+		return keys.includes(`${product.id}:${variant.id}`);
+	})).map((product) => {
+		return product.variants.map((variant) => {
+			return {
+				id: `${product.id}:${variant.id}`,
+				title: product.title,
+				quantity: cart[`${product.id}:${variant.id}`],
+				variant,
+				taxes: product.taxes,
+				category: product.extras?.category || "none",
+				originalPrice: variant?.originalPrice || product?.originalPrice || 0,
+				originalDiscount: product?.discount || 0
+			};
+		});
+	});
+	return [].concat(...allVariants).filter((line) => keys.includes(`${line.id}`));
+}
+async function returnCart(event, cart, getProducts) {
+	const expires = new Date(dayjs().add(20, "minutes").format());
+	const start = Date.now();
+	const lineItems = await getLineItems(cart, getProducts);
+	console.log("getLineItems", `${Date.now() - start}ms`);
+	setCookie(event, "eCart", JSON.stringify(cart), { expires });
+	return { lineItems };
+}
+function registerCart(app, { getProducts, path }) {
+	const useCart = (event) => {
+		const rawCart = getCookie(event, "eCart");
+		if (!rawCart) return {};
+		return JSON.parse(rawCart);
+	};
+	app.get(path("/cart"), eventHandler(async (event) => {
+		const cart = useCart(event);
+		if (!Object.keys(cart).length) return { lineItems: [] };
+		return await returnCart(event, cart, getProducts);
+	}));
+	const getCartItem = async (event) => {
+		const body = await readBody(event);
+		return {
+			id: getQuery(event).id || body?.id,
+			quantity: body?.quantity
+		};
+	};
+	app.post(path("/cart"), eventHandler(async (event) => {
+		let cart = useCart(event);
+		const payload = await getCartItem(event);
+		cart = {
+			...cart,
+			[payload.id]: payload.quantity
+		};
+		return await returnCart(event, cart, getProducts);
+	}));
+	app.delete(path("/cart"), eventHandler((event) => {
+		setCookie(event, "eCart", "{}");
+		return { lineItems: [] };
+	}));
+	app.delete(path("/cart/**:id"), eventHandler(async (event) => {
+		const cart = useCart(event);
+		let id = getRouterParam(event, "id");
+		id = decodeURIComponent(id);
+		delete cart[id];
+		return await returnCart(event, cart, getProducts);
+	}));
+}
+function roundNum(v, r = 2) {
+	return Number(Number(v).toFixed(r));
+}
+function calcPercentaje(value, percentaje, hasInclude) {
+	const val = +value;
+	const per = +percentaje;
+	if (hasInclude) return roundNum(val * per / (100 + per));
+	else return roundNum(val / 100 * per);
+}
+function calcDiscount(amount, discount) {
+	if ("percent" in discount) return {
+		amount: calcPercentaje(amount, discount.percent),
+		percent: +discount.percent
+	};
+	else return { amount: +discount.amount };
+}
+const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+const flatten = (arr) => arr.reduce((a, b) => a.concat(b), []);
+function groupBy(fn, arr) {
+	return arr.reduce((acc, value) => {
+		const key = fn(value);
+		if (!acc[key]) acc[key] = [];
+		acc[key].push(value);
+		return acc;
+	}, {});
+}
+function calcAmount(_itemDiscount, _parentDiscount, taxIncluded) {
+	return (price) => {
+		if (!taxIncluded) {
+			const itemDiscount = calcDiscount(price, _itemDiscount);
+			const parentDiscount = calcDiscount(price - itemDiscount.amount, _parentDiscount);
+			const unitBase = price - (itemDiscount.amount + parentDiscount.amount);
+			return {
+				price,
+				discounts: {
+					itemDiscount,
+					parentDiscount
+				},
+				unitAmount: unitBase,
+				unitBase
+			};
+		} else {
+			const parentDiscount = calcDiscount(price, _parentDiscount);
+			const itemDiscount = calcDiscount(price - parentDiscount.amount, _itemDiscount);
+			return {
+				price,
+				discounts: {
+					itemDiscount,
+					parentDiscount
+				},
+				unitAmount: price - (itemDiscount.amount + parentDiscount.amount),
+				unitBase: 0
+			};
+		}
+	};
+}
+function calcSingleItem(parentDiscount = { amount: 0 }) {
+	return (item) => {
+		const quantity = +item.quantity;
+		const taxes = item.taxes || [];
+		const calcRawTax = (base, rate) => base * rate / 100;
+		const calculateTaxesForward = (originalBase, finalBase, raw = false) => {
+			const firstTaxes = [];
+			const latestTaxes = [];
+			let totalFirstTaxesAmount = 0;
+			let totalLatestTaxesAmount = 0;
+			for (const t of taxes) if (t.beforeTaxes) {
+				const baseToUse = t.excludeDiscount ? originalBase : finalBase;
+				const amount = raw ? calcRawTax(baseToUse, +t.value) : calcPercentaje(baseToUse, t.value, false);
+				firstTaxes.push({
+					...t,
+					base: baseToUse,
+					amount,
+					totalBase: baseToUse * quantity,
+					totalAmount: amount * quantity
+				});
+				totalFirstTaxesAmount += amount;
+			}
+			for (const t of taxes) if (!t.beforeTaxes) {
+				const baseToUse = (t.excludeDiscount ? originalBase : finalBase) + totalFirstTaxesAmount;
+				const amount = raw ? calcRawTax(baseToUse, +t.value) : calcPercentaje(baseToUse, t.value, false);
+				latestTaxes.push({
+					...t,
+					base: baseToUse,
+					amount,
+					totalBase: baseToUse * quantity,
+					totalAmount: amount * quantity
+				});
+				totalLatestTaxesAmount += amount;
+			}
+			return {
+				firstTaxes,
+				latestTaxes,
+				totalTaxes: totalFirstTaxesAmount + totalLatestTaxesAmount,
+				totalPrice: finalBase + totalFirstTaxesAmount + totalLatestTaxesAmount
+			};
+		};
+		if (!item.taxIncluded) {
+			const amounts = calcAmount(item.discount, parentDiscount, false)(+item.price);
+			const originalBase = amounts.price;
+			const finalBase = amounts.unitBase;
+			const result = calculateTaxesForward(originalBase, finalBase, false);
+			amounts.total = amounts.unitBase * quantity + result.totalTaxes * quantity;
+			return {
+				id: item.id,
+				title: item.title,
+				taxIncluded: item.taxIncluded,
+				item: amounts,
+				taxes: [...result.firstTaxes, ...result.latestTaxes],
+				quantity,
+				product: item.product,
+				variant: item.variant,
+				discountAllocations: item.discountAllocations
+			};
+		} else {
+			const amounts = calcAmount(item.discount, parentDiscount, true)(+item.price);
+			const originalPriceWithTaxes = amounts.price;
+			const finalPriceWithTaxes = amounts.unitAmount;
+			const T1_1 = calculateTaxesForward(1, 1, true).totalPrice;
+			const originalBaseRaw = originalPriceWithTaxes / (T1_1 === 0 ? 1 : T1_1);
+			const T0 = calculateTaxesForward(originalBaseRaw, 0, true).totalPrice;
+			const M = calculateTaxesForward(originalBaseRaw, 1, true).totalPrice - T0;
+			const result = calculateTaxesForward(originalBaseRaw, M === 0 ? finalPriceWithTaxes - T0 : (finalPriceWithTaxes - T0) / M, false);
+			const adjustedFinalBase = finalPriceWithTaxes - result.totalTaxes;
+			amounts.unitBase = adjustedFinalBase;
+			amounts.total = finalPriceWithTaxes * quantity;
+			for (const t of result.firstTaxes) if (!t.excludeDiscount) {
+				t.base = adjustedFinalBase;
+				t.totalBase = adjustedFinalBase * quantity;
+			}
+			const firstTotal = sum(result.firstTaxes.map((t) => t.amount));
+			for (const t of result.latestTaxes) if (!t.excludeDiscount) {
+				t.base = adjustedFinalBase + firstTotal;
+				t.totalBase = t.base * quantity;
+			}
+			return {
+				id: item.id,
+				title: item.title,
+				taxIncluded: item.taxIncluded,
+				item: amounts,
+				taxes: [...result.firstTaxes, ...result.latestTaxes],
+				quantity,
+				product: item.product,
+				variant: item.variant,
+				discountAllocations: item.discountAllocations
+			};
+		}
+	};
+}
+function calcItems(items, parentDiscount = { amount: 0 }) {
+	return items.map(calcSingleItem(parentDiscount));
+}
+function buildInvoice(items) {
+	const base = sum(items.map((item) => item.item.unitBase * item.quantity));
+	const lineItemsSubtotalPrice = sum(items.filter((item) => !["_envio"].includes(item.id)).map((item) => item.item.price * item.quantity));
+	const shipping = sum(items.filter((item) => ["_envio"].includes(item.id)).map((item) => item.item.price * item.quantity));
+	const totalDiscount = sum(items.map((item) => {
+		const discounts = item.item.discounts;
+		if (!discounts) return 0;
+		return ((discounts.itemDiscount?.amount || 0) + (discounts.parentDiscount?.amount || 0)) * item.quantity;
+	}));
+	const imp = groupBy((tax) => {
+		return `${tax.type.code}_${tax.code}`;
+	}, flatten(items.map((item) => item.taxes)));
+	const _taxes = Object.values(imp).map((taxes) => {
+		let taxBase = 0;
+		let value = 0;
+		const type = taxes[0].type.code;
+		const title = taxes[0].type.name;
+		const code = taxes[0].code;
+		const rate = +taxes[0].value;
+		for (const iterator of taxes) {
+			taxBase += +iterator.totalBase;
+			value += +iterator.totalAmount;
+		}
+		return {
+			type,
+			code,
+			base: taxBase,
+			value,
+			rate,
+			title
+		};
+	});
+	return {
+		total: base + sum(_taxes.map((tax) => tax.value)),
+		totalTax: sum(_taxes.map((t) => t.value)),
+		totalDiscount,
+		base,
+		items,
+		taxes: _taxes,
+		lineItemsSubtotalPrice,
+		shipping
+	};
+}
+function calculateFormula(expression, variables) {
+	if (!/^[\w+\-*/().\s<>=?:&|"']+$/.test(expression)) throw new TypeError("Formula contains invalid characters");
+	const context = { ...variables };
+	try {
+		let processedExpression = expression;
+		for (const [key, value] of Object.entries(context)) {
+			const regex = new RegExp(`\\b${key}\\b`, "g");
+			const safeValue = typeof value === "string" ? `"${value}"` : String(value);
+			processedExpression = processedExpression.replace(regex, safeValue);
+		}
+		const result = new Function(`return ${processedExpression}`)();
+		if (typeof result !== "number" || Number.isNaN(result)) throw new TypeError("Formula result is not a valid number");
+		return result;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Error evaluating formula "${expression}": ${errorMessage}`);
+	}
+}
+function getCheckoutId(event) {
+	const cookie = getCookie(event, "eCheckout");
+	if (!cookie) throw new HTTPError({
+		statusCode: 404,
+		status: 404,
+		message: "Checkout not found"
+	});
+	return +cookie;
+}
+function registerCheckout(app, db, { path, storeId }) {
+	const { getStore } = useProducts(db);
+	app.post(path("/checkout"), eventHandler(async (event) => {
+		const payload = await readBody(event);
+		if (!payload.items) return new HTTPError({
+			status: 400,
+			statusCode: 400,
+			message: "Items not found"
+		});
+		const checkout = await db.insert(checkouts).values({
+			taxes: [],
+			billingInfo: {},
+			shippingInfo: {},
+			...payload
+		}).returning();
+		setCookie(event, "eCheckout", `${checkout[0].id}`);
+		return { id: checkout[0].id };
+	}));
+	app.get(path("/checkout"), eventHandler(async (event) => {
+		const id = getCheckoutId(event);
+		const checkout = await db.query.checkouts.findFirst({ where: { id } });
+		if (!checkout) return;
+		const store = await getStore(storeId);
+		if (!store) return;
+		const theDiscount = (checkout.discount || [])[0]?.options || {};
+		const theTax = getTax(store);
+		const TAX_INCLUDED = store.storeTaxes?.included ?? true;
+		console.log(theTax, TAX_INCLUDED);
+		const items = checkout.items.filter((el) => !el?.id.startsWith("_")).map((el) => {
+			const discount = theDiscount?.type === "percentage" ? { percent: theDiscount?.value } : theDiscount?.type === "amount" ? { amount: theDiscount?.value } : { amount: 0 };
+			console.log("el.taxes", el.taxes);
+			const taxIncluded = el.taxes?.some((tax) => tax.included) ?? TAX_INCLUDED;
+			const taxes = el.taxes && el.taxes.length ? el.taxes : theTax ? [{
+				...theTax,
+				included: taxIncluded
+			}] : [];
+			console.log("taxes", taxes);
+			return {
+				productId: el.variant?.productId,
+				discount,
+				id: el.variant.id,
+				price: el.variant.price,
+				quantity: el.quantity,
+				product: el.product,
+				variant: el.variant,
+				discountAllocations: el.discountAllocations || [],
+				taxes,
+				taxIncluded,
+				title: `${el.variant?.title} - ${el.variant?.id}`,
+				category: el.category || "none",
+				originalPrice: el.originalPrice || 0,
+				originalDiscount: el.originalDiscount || 0
+			};
+		});
+		if (checkout.shippingType && checkout.shippingType?.id) {
+			const taxShipping = checkout.shippingType.addTax ? {
+				code: "4",
+				description: "Envio",
+				included: false,
+				value: 15,
+				type: {
+					code: "2",
+					name: "IVA"
+				}
+			} : {
+				code: "0",
+				description: "Envio",
+				included: true,
+				value: 0,
+				type: {
+					code: "2",
+					name: "IVA"
+				}
+			};
+			const taxIncluded = !checkout.shippingType.addTax;
+			items.push({
+				discount: { amount: 0 },
+				price: +(checkout.shippingType.priceV2?.amount || checkout.shippingType.price),
+				id: "_envio",
+				quantity: 1,
+				taxIncluded,
+				title: "envio",
+				taxes: [taxShipping]
+			});
+		}
+		const itemsInvoice = calcItems(items);
+		const invoice = buildInvoice(itemsInvoice);
+		await db.update(checkouts).set({
+			items: items.map((el) => {
+				const item = itemsInvoice.find((e) => e.id === el.id);
+				return {
+					...el,
+					item: item?.item,
+					lineItem: item
+				};
+			}),
+			total: invoice.total,
+			base: invoice.base,
+			taxes: invoice.taxes,
+			shippingType: checkout.shippingType || {}
+		}).where(eq(checkouts.id, id));
+		return {
+			invoice: {
+				...invoice,
+				discounts: checkout.discount || []
+			},
+			lineItems: checkout.items.filter((el) => !el?.id.startsWith("_")),
+			address: checkout.shippingInfo,
+			billing: checkout.billingInfo,
+			shipping: checkout.shippingType
+		};
+	}));
+	app.post(path("/checkout/address"), eventHandler(async (event) => {
+		const id = getCheckoutId(event);
+		const payload = await readBody(event);
+		await db.update(checkouts).set({ shippingInfo: { ...payload } }).where(eq(checkouts.id, id));
+		return { ok: true };
+	}));
+	app.post(path("/checkout/billing"), eventHandler(async (event) => {
+		const id = getCheckoutId(event);
+		const payload = await readBody(event);
+		await db.update(checkouts).set({ billingInfo: { ...payload } }).where(eq(checkouts.id, id));
+		return { ok: true };
+	}));
+	app.get(path("/checkout/shippings"), eventHandler(async (event) => {
+		const store = await getStore(storeId);
+		const id = getCheckoutId(event);
+		const shippings = store.storeShippings || store?.storeSettings?.shippingType || [];
+		const type = store?.storeShippingsOptions?.type || "simple";
+		const checkout = await db.query.checkouts.findFirst({ where: { id } });
+		if (!checkout) return new HTTPError({
+			statusCode: 404,
+			statusMessage: "Checkout not found"
+		});
+		if (type === "complex") {
+			const allFormulates = store.storeShippingsOptions?.formulate || [];
+			const normalizeText = (text) => {
+				return text.toLowerCase().replace(/ /g, "-").replace(/[^a-z0-9-]/g, "");
+			};
+			const state = normalizeText(checkout.shippingInfo?.state || "TUNGURAHUA");
+			const city = normalizeText(checkout.shippingInfo?.city || "");
+			const item = shippings.find((e) => {
+				const _city = normalizeText(e.regionCity || "");
+				const _state = normalizeText(e.regionState || "");
+				return _city === city && _state === state;
+			});
+			console.log("item", item);
+			const pickup = {
+				_raw: [{
+					name: "Pickup - Retiro en tienda(Quito o Guayaquil)",
+					value: "0.00"
+				}],
+				items: [{
+					title: "Pickup - Retiro en tienda",
+					handle: "shopify-Pickup-0.00",
+					priceV2: {
+						amount: "0.00",
+						currencyCode: "USD"
+					},
+					price: "USD 0.00",
+					id: "shopify-Pickup-0.00",
+					name: "Pickup - Retiro en tienda (Sucursal Quito o Guayaquil)"
+				}]
+			};
+			if (item) {
+				let stocks = await ofetch(`${store.endpoint}/storefront/cache/the-stocks/${checkout.items.map((e) => e.productId || e.id).join("-")}`, { params: { ids: checkout.items.map((e) => e.productId || e.id).join(",") } }).catch(() => []);
+				stocks = stocks.map((v) => {
+					return {
+						...v,
+						category: checkout.items.find((e) => {
+							return String(e.id) === String(v.sku) || String(e.productId) === String(v.sku);
+						})?.category || "none",
+						quantity: checkout.items.find((e) => {
+							return String(e.id) === String(v.sku) || String(e.productId) === String(v.sku);
+						})?.quantity || 1
+					};
+				});
+				console.log("stocks", stocks);
+				const variables = store.storeShippingsOptions.variables.reduce((acc, curr) => {
+					return {
+						...acc,
+						[curr.name]: curr.default
+					};
+				}, {});
+				let sumTax = false;
+				const prices = stocks.filter(({ id }) => !id.startsWith("_")).map((curr) => {
+					console.log("curr", curr);
+					let quantity = curr.quantity || 1;
+					const _formulate = allFormulates.find((f) => f.key === curr.category) || allFormulates.find((f) => f.key === "default") || item.formulate[0];
+					if (_formulate.noQuantity) quantity = 1;
+					const weight = Number(curr.weight || 0) * Number(quantity || 1);
+					const vars = {
+						...variables,
+						...item,
+						weight,
+						sku: curr.sku,
+						quantity
+					};
+					const formulate = _formulate.value;
+					if (_formulate.key !== "default") sumTax = _formulate.tax || false;
+					console.log("formulate", curr, formulate, vars);
+					return calculateFormula(formulate, vars);
+				});
+				console.log("prices", prices);
+				if (prices.some((p) => p < 0)) return {
+					_raw: [],
+					items: [],
+					message: "Elemento sin covertura"
+				};
+				const title = `${item?.regionState || ""} - ${item?.regionCity || ""}`;
+				const total = prices.reduce((acc, curr) => acc + curr, 0).toFixed(2);
+				return {
+					_raw: [{
+						name: title,
+						value: total
+					}, ...pickup._raw],
+					items: [{
+						title,
+						handle: title,
+						priceV2: {
+							amount: total,
+							currencyCode: "USD"
+						},
+						notify: item.correos || "",
+						notify2: item.facturacion || "",
+						addTax: sumTax,
+						item,
+						price: `USD ${total}`,
+						id: title,
+						name: title
+					}, ...pickup.items]
+				};
+			} else return {
+				...pickup,
+				code: "no-shipping"
+			};
+		}
+		if (!shippings.length) return {
+			_raw: [{
+				name: "Standard",
+				value: "0.00"
+			}],
+			items: [{
+				title: "Standard",
+				handle: "shopify-Standard-0.00",
+				priceV2: {
+					amount: "0.0",
+					currencyCode: "USD"
+				},
+				price: "USD 0.0",
+				id: "shopify-Standard-0.00",
+				name: "Standard"
+			}]
+		};
+		return {
+			_raw: shippings,
+			items: shippings.map((item) => {
+				const id = `${item.name}-${item.value}`;
+				return {
+					_raw: item,
+					title: item.name,
+					handle: id,
+					priceV2: {
+						amount: item.value,
+						currencyCode: "USD"
+					},
+					price: (+item.value).toFixed(2),
+					id,
+					name: item.name
+				};
+			})
+		};
+	}));
+	app.post(path("/checkout/shippings"), eventHandler(async (event) => {
+		const id = getCheckoutId(event);
+		const payload = await readBody(event);
+		await db.update(checkouts).set({ shippingType: { ...payload } }).where(eq(checkouts.id, id));
+		return { ok: true };
+	}));
+	app.post(path("/checkout/discount"), eventHandler(async (event) => {
+		const id = getCheckoutId(event);
+		const store = await getStore(storeId);
+		const { coupon } = await readBody(event);
+		const coupons = store?.storeDiscounts || [];
+		const user = useUser(event);
+		const item = coupons.filter((e) => e.select.toLowerCase() === "codigo").find((c) => c.value === coupon);
+		if (!item) return {
+			message: "Cupón no válido",
+			code: 0
+		};
+		const condition = {
+			storeId,
+			customerId: user.id,
+			code: coupon
+		};
+		if (await db.query.discountCoupons.findFirst({ where: condition }) && item.options.apply === "once") return {
+			message: "Cupón ya utilizado",
+			code: 0
+		};
+		if (item) await db.update(checkouts).set({ discount: [{
+			...item,
+			coupon,
+			customerId: user.id
+		}] }).where(eq(checkouts.id, id));
+		return {
+			message: "Cupón aplicado",
+			code: 1
+		};
+	}));
+	app.delete(path("/checkout/discount"), eventHandler(async (event) => {
+		const id = getCheckoutId(event);
+		await db.update(checkouts).set({ discount: [] }).where(eq(checkouts.id, id));
+		return { ok: true };
+	}));
+}
+const safeParams = (v) => v.split("?")[0];
+const TASKS = {
+	notify: {
+		type: "external",
+		endpoint: `${URL}/storefront/webhooks/notify/success`
+	},
+	stock: {
+		type: "internal",
+		task: "updateStocks",
+		payload: { omit: "tranference" }
+	}
+};
+const presets = { ecommerce: { prepare: { preHandle: async (event, payment) => {
+	const checkoutId = getCheckoutId(event);
+	const _body = await readBody(event);
+	const user = useUser(event);
+	const { customer, shippingIdentification, extras } = _body;
+	const { card, ...body } = _body;
+	const session = {
+		email: user.email,
+		identification: customer?.billingInfo?.identification || shippingIdentification || "0000000000",
+		customer: {
+			givenName: customer?.billingInfo?.fullname || "",
+			surname: "",
+			billingInfo: customer?.billingInfo,
+			...user
+		}
+	};
+	const theSession = await payment.session.create(session);
+	const store = await payment.getStore();
+	const successTasks = [];
+	if (store.storeTasks?.success?.notify) successTasks.push(TASKS.notify);
+	if (store.storeTasks?.success?.stock) successTasks.push(TASKS.stock);
+	store.storeTasks?.successTasks?.forEach((el) => {
+		const endpoint = el.url.startsWith("/") ? `${URL}${el.url}` : el.url;
+		successTasks.push({
+			type: "external",
+			task: String(el.id),
+			endpoint
+		});
+	});
+	const success = successTasks.map((el) => ({
+		...el,
+		payload: {
+			...body,
+			...el.payload
+		}
+	}));
+	const failed = (store.storeSettings?.flow?.failed || [{
+		type: "external",
+		endpoint: `${URL}/storefront/webhooks/notify/failed`
+	}]).map((el) => ({
+		...el,
+		payload: body
+	}));
+	await payment.checkout.associate(checkoutId, theSession.id);
+	const provider = getRouterParam(event, "provider");
+	console.log("Preparing payment for provider:", provider);
+	event.context.body = {
+		sessionId: theSession.id,
+		checkoutId,
+		description: "Compra",
+		ip: getRequestIP(event),
+		endpoints: { verify: { endpoint: `${URL}/payment/verify/${provider}` } },
+		tasks: {
+			success,
+			failed
+		},
+		extras
+	};
+	event.context.card = card;
+} } } };
+function registerPayment(app, db, { path, storeId, providers, preset, providerOptions, redirect: globalRedirect }) {
+	const instance = createPayment({
+		graphql: createGraphql(db),
+		storeId,
+		providers,
+		secret: "secret",
+		tasks: {
+			url: TASKS_ENDPOINT,
+			headers: { Authorization: `Bearer ${GRAPHQL_TOKEN}` }
+		}
+	});
+	const extend = typeof preset === "string" ? presets[preset] || {} : preset;
+	const payHandle = eventHandler(async (event) => {
+		const { payment } = instance;
+		console.log(event, event.headers);
+		const query = getQuery(event);
+		const { uid } = query;
+		const redirect$1 = query.redirect || globalRedirect;
+		const provider = safeParams(event.context.params?.provider || "");
+		let body = {};
+		if (event.req.method === "POST") body = await readBody(event);
+		const r = await payment.pay(provider, {
+			...query,
+			uid,
+			body
+		});
+		const { provider: _1, uid: _2, id: _3, ...rest } = query;
+		const params = Object.entries(rest).map(([key, value]) => `${key}=${value}`).join("&");
+		const pathRedirect = joinURL(URL, `${redirect$1}?provider=${provider}&id=${r.id}&uid=${uid}&${params}`);
+		console.log("pathredirect", pathRedirect);
+		if (redirect$1 !== "0" || redirect$1.startsWith("/")) return redirect(pathRedirect, 301);
+		return {
+			redirect: pathRedirect,
+			payload: r
+		};
+	});
+	app.post(path("/pay/:provider"), payHandle);
+	app.get(path("/pay/:provider"), payHandle);
+	app.post(path("/post-prepare/:provider"), eventHandler(async (event) => {
+		const { payment } = instance;
+		const hooks = extend?.postPrepare;
+		if (hooks?.preHandle) await hooks.preHandle(event, instance);
+		let body = event.context.body;
+		if (!body) body = await readBody(event);
+		const { options } = body;
+		const provider = safeParams(getRouterParam(event, "provider") || "");
+		const defaultProviderOptions = defu(providerOptions?.[provider] || {}, options || {});
+		const { options: _opt, ...theBody } = body;
+		try {
+			const r = await payment.postPrepare(provider, theBody, {
+				...defaultProviderOptions,
+				card: event.context.card || void 0,
+				returnUrl: event.context.returnUrl || void 0,
+				transactionMode: event.context.transactionMode || void 0,
+				deviceInformation: event.context.deviceInformation || void 0
+			});
+			if (hooks?.postHandle) await hooks.postHandle(event, r);
+			return r;
+		} catch (error) {
+			console.log(error?.response?.body || error);
+			throw createError({ statusCode: 500 });
+		}
+	}));
+	app.post(path("/prepare/:provider"), eventHandler(async (event) => {
+		const _payment = instance;
+		const { payment } = _payment;
+		const hooks = extend?.prepare;
+		if (hooks?.preHandle) await hooks.preHandle(event, _payment);
+		let body = event.context.body;
+		if (!body) body = await readBody(event);
+		const { options } = body;
+		const provider = safeParams(getRouterParam(event, "provider") || "");
+		const defaultProviderOptions = defu(providerOptions?.[provider] || {}, options || {});
+		const { options: _opt, ...theBody } = body;
+		try {
+			const r = await payment.prepare(provider, theBody, {
+				...defaultProviderOptions,
+				card: event.context.card || void 0
+			});
+			if (hooks?.postHandle) await hooks.postHandle(event, r);
+			return r;
+		} catch (error) {
+			console.log(error?.response?.body || error);
+			throw createError({ statusCode: 500 });
+		}
+	}));
+	app.post(path("/verify/:provider"), eventHandler(async (event) => {
+		const { payment } = instance;
+		const { uid } = await readBody(event);
+		const provider = safeParams(event.context.params?.provider || "");
+		const query = getQuery(event);
+		return await payment.verify(provider, uid, !!query.override);
+	}));
+	app.post(path("/webhook/:provider"), eventHandler(async (event) => {
+		const { payment } = instance;
+		const body = await readBody(event);
+		const { reference: uid } = body;
+		const provider = safeParams(event.context.params?.provider || "");
+		return await payment?.webhook?.(provider, uid, body);
+	}));
+}
+export { getCheckoutId, getTax, registerAccount, registerAuth, registerAuthMiddleware, registerCache, registerCart, registerCheckout, registerPayment, safeParams, useProducts, useUser };