@godaddy/gd-commerce-server 0.1.0

package/dist/index.js

@@ -0,0 +1,1567 @@
+import { Router } from "express";
+import { createHash } from "node:crypto";
+
+//#region src/lib/commerce/checkout-config.ts
+const DEFAULT_CHECKOUT_CONFIGURATION = {
+	enablePromotionCodes: false,
+	enableTaxCollection: false,
+	enableShipping: false
+};
+function parseCommerceCheckoutConfiguration(raw) {
+	if (!raw?.trim()) return DEFAULT_CHECKOUT_CONFIGURATION;
+	let value;
+	try {
+		value = JSON.parse(raw);
+	} catch {
+		return DEFAULT_CHECKOUT_CONFIGURATION;
+	}
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return DEFAULT_CHECKOUT_CONFIGURATION;
+	const candidate = value;
+	for (const key of [
+		"enablePromotionCodes",
+		"enableTaxCollection",
+		"enableShipping"
+	]) if (typeof candidate[key] !== "boolean") return DEFAULT_CHECKOUT_CONFIGURATION;
+	const shipping = candidate.shipping;
+	if (shipping !== void 0) {
+		if (shipping === null || typeof shipping !== "object" || Array.isArray(shipping)) return DEFAULT_CHECKOUT_CONFIGURATION;
+		if ((shipping.originAddress !== null && typeof shipping.originAddress === "object" && !Array.isArray(shipping.originAddress)) === (typeof shipping.fulfillmentLocationId === "string" && shipping.fulfillmentLocationId.trim() !== "")) return DEFAULT_CHECKOUT_CONFIGURATION;
+	}
+	return {
+		enablePromotionCodes: candidate.enablePromotionCodes,
+		enableTaxCollection: candidate.enableTaxCollection,
+		enableShipping: candidate.enableShipping,
+		...shipping ? { shipping } : {}
+	};
+}
+
+//#endregion
+//#region src/lib/commerce/config.ts
+const DEFAULT_API_BASE_URL = "https://api.godaddy.com";
+function normalizeApiBaseUrl(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new Error("Commerce config: apiBaseUrl must be a valid HTTPS origin.");
+	}
+	if (url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) throw new Error("Commerce config: apiBaseUrl must be an HTTPS origin without credentials, path, query, or fragment.");
+	return url.origin;
+}
+function requireValue(environment, key) {
+	const value = environment[key]?.trim();
+	if (!value) throw new Error(`Commerce config: ${key} is missing. Configure it in the server environment.`);
+	return value;
+}
+/** Read server environment values on each call. Loading files or secret stores belongs to the host. */
+function readCommerceConfig(options = {}) {
+	const environment = options.environment ?? process.env;
+	return {
+		clientId: requireValue(environment, "GODADDY_OAUTH_CLIENT_ID"),
+		clientSecret: requireValue(environment, "GODADDY_OAUTH_CLIENT_SECRET"),
+		storeId: requireValue(environment, "GODADDY_STORE_ID"),
+		channelId: requireValue(environment, "GODADDY_CHANNEL_ID"),
+		currencyCode: requireValue(environment, "GODADDY_CURRENCY_CODE"),
+		apiBaseUrl: normalizeApiBaseUrl(options.apiBaseUrl ?? DEFAULT_API_BASE_URL),
+		...options.sourceApp ? { sourceApp: options.sourceApp } : {},
+		...options.owner ? { owner: options.owner } : {}
+	};
+}
+function createRuntimeCommerceConfiguration(options = {}) {
+	return {
+		read: () => readCommerceConfig(options),
+		readCheckout: () => parseCommerceCheckoutConfiguration((options.environment ?? process.env).GODADDY_CHECKOUT_CONFIGURATION)
+	};
+}
+function commerceConfigurationForResponse(res) {
+	const configuration = res.locals.commerceConfiguration;
+	if (configuration && typeof configuration === "object" && "read" in configuration && typeof configuration.read === "function" && "readCheckout" in configuration && typeof configuration.readCheckout === "function") return configuration;
+	return createRuntimeCommerceConfiguration();
+}
+function readCommerceConfigForResponse(res) {
+	return commerceConfigurationForResponse(res).read();
+}
+
+//#endregion
+//#region src/lib/commerce/checkout-subgraph.ts
+/**
+* The hosted checkout page will not render a card form without this. GDC's
+* checkout GraphQL accepts a session with no payment methods and returns 200,
+* so an omitted or deleted default fails silently — the shopper sees "No
+* payment methods available" with no error anywhere in the request/response
+* cycle. Do not remove this while debugging an unrelated checkout issue.
+*/
+const DEFAULT_CHECKOUT_PAYMENT_METHODS = { card: {
+	processor: "godaddy",
+	checkoutTypes: ["standard"]
+} };
+function stripUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== void 0));
+}
+function applyCheckoutDefaults(base, overrides = {}) {
+	const definedOverrides = stripUndefined(overrides);
+	const result = {
+		...base,
+		...definedOverrides
+	};
+	if (result.paymentMethods === void 0) result.paymentMethods = DEFAULT_CHECKOUT_PAYMENT_METHODS;
+	if (result.enablePaymentMethodCollection === void 0) result.enablePaymentMethodCollection = true;
+	if (result.enableBillingAddressCollection === void 0) result.enableBillingAddressCollection = true;
+	if (result.enableShipping === void 0) result.enableShipping = false;
+	if (result.enableShippingAddressCollection === void 0) result.enableShippingAddressCollection = false;
+	if (result.enableLocalPickup === void 0) result.enableLocalPickup = false;
+	if (result.enablePhoneCollection === void 0) result.enablePhoneCollection = false;
+	if (result.enableTaxCollection === void 0) result.enableTaxCollection = false;
+	return result;
+}
+function checkoutGraphqlEndpoint({ apiBaseUrl }) {
+	const { host, protocol } = new URL(apiBaseUrl);
+	return `${protocol}//checkout.commerce.${host}`;
+}
+function authorizationHeaders({ accessToken }) {
+	return { Authorization: `Bearer ${accessToken}` };
+}
+async function getOAuthAccessToken({ clientId, clientSecret, apiBaseUrl, scope = "commerce.product:read", fetch: fetchImplementation }) {
+	if (!clientId || !clientSecret) throw new Error("clientId and clientSecret are required");
+	const requestFetch = fetchImplementation ?? fetch;
+	const body = new URLSearchParams();
+	body.append("grant_type", "client_credentials");
+	body.append("client_id", clientId);
+	body.append("client_secret", clientSecret);
+	body.append("scope", scope);
+	const response = await requestFetch(new URL("/v2/oauth2/token", apiBaseUrl).toString(), {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: body.toString(),
+		cache: "no-store"
+	});
+	if (!response.ok) throw new Error(`Failed to get access token: ${response.status} ${response.statusText}`);
+	return await response.json();
+}
+function buildBuyNowCheckoutInput({ storeId, skuId, quantity = 1, returnUrl, successUrl, channelId }, overrides = {}) {
+	return applyCheckoutDefaults({
+		storeId,
+		returnUrl,
+		successUrl,
+		channelId,
+		lineItems: [{
+			skuId,
+			quantity
+		}]
+	}, overrides);
+}
+function buildCartCheckoutInput({ storeId, draftOrderId, returnUrl, successUrl, channelId }, overrides = {}) {
+	return applyCheckoutDefaults({
+		storeId,
+		returnUrl,
+		successUrl,
+		channelId,
+		draftOrderId
+	}, overrides);
+}
+function buildNonCatalogCheckoutInput({ storeId, lineItemData, quantity = 1, returnUrl, successUrl, channelId }, overrides = {}) {
+	return applyCheckoutDefaults({
+		storeId,
+		returnUrl,
+		successUrl,
+		channelId,
+		lineItems: [{
+			lineItemData,
+			quantity
+		}]
+	}, overrides);
+}
+
+//#endregion
+//#region src/lib/commerce/gql.ts
+var GraphQLErrorWithCodes = class extends Error {
+	constructor(errors, status) {
+		const errorMessage = errors.length === 1 ? `${errors[0]?.message || "Unknown error"}` : errors.map((error) => error.message).filter(Boolean).join("; ");
+		super(errorMessage);
+		this.errors = errors;
+		this.status = status;
+		this.name = "GraphQLErrorWithCodes";
+	}
+	get codes() {
+		return this.errors.map((error) => error.code).filter(Boolean);
+	}
+	get messages() {
+		return this.errors.map((error) => error.message).filter(Boolean);
+	}
+	get statuses() {
+		return this.errors.map((error) => error.status).filter((status) => typeof status === "number");
+	}
+};
+function storefrontHeaders({ storeId, clientId }) {
+	return {
+		"X-Store-ID": storeId,
+		"X-Client-ID": clientId
+	};
+}
+async function gqlRequest({ endpoint, query, variables, headers: headersInit, fetch: fetchImplementation }) {
+	const requestHeaders = new Headers(headersInit);
+	requestHeaders.set("Accept", "application/json");
+	requestHeaders.set("Content-Type", "application/json");
+	const response = await (fetchImplementation ?? fetch)(endpoint, {
+		method: "POST",
+		headers: requestHeaders,
+		body: JSON.stringify({
+			query,
+			variables: variables ?? {}
+		}),
+		cache: "no-store"
+	});
+	let result;
+	try {
+		result = await response.json();
+	} catch {
+		throw new GraphQLErrorWithCodes([{
+			message: `GraphQL request failed: ${response.status} ${response.statusText}`,
+			status: response.status
+		}], response.ok ? void 0 : response.status);
+	}
+	if (result.errors?.length) throw new GraphQLErrorWithCodes(result.errors.map((error) => ({
+		message: error.message,
+		code: error.extensions?.code,
+		status: error.extensions?.status ?? error.extensions?.http?.status ?? (response.ok ? void 0 : response.status)
+	})), response.ok ? void 0 : response.status);
+	if (!response.ok) throw new GraphQLErrorWithCodes([{
+		message: `GraphQL request failed: ${response.status} ${response.statusText}`,
+		status: response.status
+	}], response.status);
+	if (result.data === void 0) throw new Error("GraphQL response did not include data");
+	return result.data;
+}
+
+//#endregion
+//#region src/lib/commerce/create-checkout-session.ts
+const createCheckoutSessionMutation = `
+  mutation CreateCheckoutSession($input: MutationCreateCheckoutSessionInput!) {
+    createCheckoutSession(input: $input) {
+      id
+      token
+      url
+      sourceApp
+      returnUrl
+      successUrl
+      storeId
+      businessId
+      channelId
+      customerId
+      storeName
+      environment
+      enableTips
+      enabledLocales
+      enableSurcharge
+      enableLocalPickup
+      enableShipping
+      enablePhoneCollection
+      enableNotesCollection
+      enablePromotionCodes
+      enableTaxCollection
+      enableShippingAddressCollection
+      enableBillingAddressCollection
+      enableAddressAutocomplete
+      paymentMethods {
+        card {
+          processor
+          checkoutTypes
+        }
+        ccavenue {
+          processor
+          checkoutTypes
+        }
+        express {
+          processor
+          checkoutTypes
+        }
+        applePay {
+          processor
+          checkoutTypes
+        }
+        googlePay {
+          processor
+          checkoutTypes
+        }
+        paypal {
+          processor
+          checkoutTypes
+        }
+        paze {
+          processor
+          checkoutTypes
+        }
+        offline {
+          processor
+          checkoutTypes
+        }
+        mercadopago {
+          processor
+          checkoutTypes
+        }
+        ach {
+          processor
+          checkoutTypes
+        }
+      }
+      draftOrder {
+        id
+        statuses {
+          status
+        }
+        totals {
+          total {
+            currencyCode
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+function promotionCodesEnabled(configuration) {
+	return "enablePromotionCodes" in configuration && configuration.enablePromotionCodes === true;
+}
+async function createCheckoutSession(params, configuration = createRuntimeCommerceConfiguration()) {
+	const { draftOrderId, skuId, quantity, lineItemData, returnUrl, successUrl } = params;
+	if (!returnUrl || !successUrl) throw new Error("createCheckoutSession: returnUrl and successUrl are required");
+	if ([
+		draftOrderId,
+		skuId,
+		lineItemData
+	].filter(Boolean).length !== 1) throw new Error("createCheckoutSession: exactly one of draftOrderId, skuId, or lineItemData is required");
+	const { storeId, channelId, clientId, clientSecret, apiBaseUrl, sourceApp, owner, currencyCode: configCurrencyCode } = configuration.read();
+	const checkoutConfiguration = configuration.readCheckout();
+	const enablePromotionCodes = promotionCodesEnabled(checkoutConfiguration);
+	const catalogShippingEnabled = lineItemData === void 0 && checkoutConfiguration.enableShipping;
+	const token = await getOAuthAccessToken({
+		clientId,
+		clientSecret,
+		apiBaseUrl,
+		scope: "commerce.product:read"
+	});
+	const attribution = {
+		sourceApp,
+		owner
+	};
+	const catalogCheckoutOverrides = {
+		...attribution,
+		enablePromotionCodes,
+		enableTaxCollection: checkoutConfiguration.enableTaxCollection,
+		enableShipping: checkoutConfiguration.enableShipping,
+		enableShippingAddressCollection: checkoutConfiguration.enableShipping,
+		paymentMethods: DEFAULT_CHECKOUT_PAYMENT_METHODS,
+		shipping: catalogShippingEnabled ? checkoutConfiguration.shipping : void 0
+	};
+	const resolvedLineItemData = lineItemData !== void 0 ? {
+		...lineItemData,
+		priceData: {
+			...lineItemData.priceData,
+			currencyCode: configCurrencyCode
+		}
+	} : void 0;
+	const input = draftOrderId ? buildCartCheckoutInput({
+		storeId,
+		channelId,
+		draftOrderId,
+		returnUrl,
+		successUrl
+	}, catalogCheckoutOverrides) : resolvedLineItemData ? buildNonCatalogCheckoutInput({
+		storeId,
+		channelId,
+		lineItemData: resolvedLineItemData,
+		quantity: quantity ?? 1,
+		returnUrl,
+		successUrl
+	}, {
+		...attribution,
+		enableTaxCollection: checkoutConfiguration.enableTaxCollection,
+		paymentMethods: DEFAULT_CHECKOUT_PAYMENT_METHODS
+	}) : buildBuyNowCheckoutInput({
+		storeId,
+		channelId,
+		skuId,
+		quantity: quantity ?? 1,
+		returnUrl,
+		successUrl
+	}, catalogCheckoutOverrides);
+	let result;
+	try {
+		result = await gqlRequest({
+			endpoint: checkoutGraphqlEndpoint({ apiBaseUrl }),
+			query: createCheckoutSessionMutation,
+			variables: { input },
+			headers: authorizationHeaders({ accessToken: token.access_token })
+		});
+	} catch (error) {
+		throw new Error("Commerce checkout session could not be created", { cause: error });
+	}
+	const session = result.createCheckoutSession;
+	if (!session?.url || !session.id) throw new Error("Checkout session was not created");
+	if (session.storeId !== storeId || session.channelId !== channelId) throw new Error(`Checkout session binding mismatch: expected store ${storeId} and channel ${channelId}, received store ${session.storeId ?? "missing"} and channel ${session.channelId ?? "missing"}`);
+	const expectedShipping = lineItemData === void 0 && checkoutConfiguration.enableShipping;
+	if (lineItemData === void 0 && enablePromotionCodes && session.enablePromotionCodes !== true) throw new Error("Checkout session did not enable configured promotion codes");
+	if (checkoutConfiguration.enableTaxCollection && session.enableTaxCollection !== true) throw new Error("Checkout session did not enable configured tax collection");
+	if (expectedShipping && (session.enableShipping !== true || session.enableShippingAddressCollection !== true)) throw new Error("Checkout session did not enable configured shipping and address collection");
+	if (!session.paymentMethods?.card?.processor) throw new Error("Checkout session did not configure payment methods.");
+	return {
+		url: session.url,
+		id: session.id,
+		draftOrderId: session.draftOrder?.id ?? null,
+		storeId,
+		channelId,
+		businessId: session.businessId ?? null,
+		storeName: session.storeName ?? null,
+		sourceApp: session.sourceApp ?? null
+	};
+}
+
+//#endregion
+//#region src/lib/commerce/get-order-status.ts
+async function getOrderStatus(orderId, configuration = createRuntimeCommerceConfiguration()) {
+	if (typeof orderId !== "string" || !orderId.trim() || orderId === "." || orderId === "..") throw new Error("getOrderStatus: a valid orderId is required");
+	const { storeId, channelId, clientId, clientSecret, apiBaseUrl, currencyCode } = configuration.read();
+	const token = await getOAuthAccessToken({
+		clientId,
+		clientSecret,
+		apiBaseUrl,
+		scope: "commerce.order:read"
+	});
+	const response = await fetch(new URL(`/v1/commerce/stores/${encodeURIComponent(storeId)}/orders/${encodeURIComponent(orderId)}`, apiBaseUrl), {
+		method: "GET",
+		headers: {
+			...authorizationHeaders({ accessToken: token.access_token }),
+			Accept: "application/json"
+		},
+		cache: "no-store"
+	});
+	if (!response.ok) throw new Error(`Failed to load order: upstream returned ${response.status}`);
+	const order = (await response.json())?.order;
+	if (!order?.id || order.id !== orderId) throw new Error("Order lookup did not return the requested order");
+	if (order.context?.storeId !== storeId || order.context?.channelId !== channelId) throw new Error("Order lookup returned a different store or channel");
+	const total = order.totals?.total;
+	return {
+		id: order.id,
+		status: order.statuses?.paymentStatus ?? "unknown",
+		amount: total?.value ?? 0,
+		currency: total?.currencyCode ?? currencyCode,
+		createdAt: order.createdAt,
+		updatedAt: order.updatedAt,
+		lineItems: (order.lineItems ?? []).map(({ id, title, quantity }) => ({
+			id,
+			name: title,
+			quantity
+		}))
+	};
+}
+
+//#endregion
+//#region src/lib/commerce/checkout-return-urls.ts
+function parseDestination(value) {
+	if (typeof value !== "string" || /[\s\\]/.test(value)) return null;
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "https:" || url.username || url.password || url.hash) return null;
+		return url;
+	} catch {
+		return null;
+	}
+}
+function destinationKey(url) {
+	const canonical = new URL(url);
+	canonical.searchParams.sort();
+	return canonical.href;
+}
+function createCheckoutReturnUrlValidator(policy) {
+	function allowedDestinations(values) {
+		return new Set(values.map((value) => {
+			const url = parseDestination(value);
+			if (!url || url.searchParams.has("orderId")) throw new Error("Checkout return destinations must be absolute HTTPS URLs without credentials, fragments, or orderId.");
+			return destinationKey(url);
+		}));
+	}
+	const returnUrls = allowedDestinations(policy.returnUrls);
+	const successUrls = allowedDestinations(policy.successUrls);
+	return (returnUrl, successUrl) => {
+		const cancel = parseDestination(returnUrl);
+		const success = parseDestination(successUrl);
+		if (!cancel || !success || success.searchParams.getAll("orderId").length > 1) return null;
+		const successDestination = new URL(success);
+		successDestination.searchParams.delete("orderId");
+		if (!returnUrls.has(destinationKey(cancel)) || !successUrls.has(destinationKey(successDestination))) return null;
+		return {
+			returnUrl: cancel.href,
+			successUrl: success.href
+		};
+	};
+}
+
+//#endregion
+//#region src/lib/commerce/cart-scope.ts
+/** Public cache/storage scope, not an authorization credential. */
+function getCommerceCartScope(config) {
+	return createHash("sha256").update(JSON.stringify([
+		config.apiBaseUrl,
+		config.storeId,
+		config.channelId,
+		config.currencyCode
+	])).digest("hex").slice(0, 32);
+}
+/** Existing custom clients may omit the header; managed components always send it. */
+function validateCommerceCartScope(req, res, config) {
+	const suppliedScope = req.headers?.["x-commerce-scope"];
+	if (suppliedScope === void 0 || suppliedScope === getCommerceCartScope(config)) return true;
+	res.status(409).json({ error: "The connected store changed. Reload the page before continuing." });
+	return false;
+}
+
+//#endregion
+//#region src/lib/commerce/order-subgraph.ts
+function createMoney(value, currencyCode) {
+	return {
+		value,
+		currencyCode
+	};
+}
+function orderStorefrontEndpoint({ apiBaseUrl }) {
+	return new URL("/v1/commerce/order-storefront-subgraph", apiBaseUrl).toString();
+}
+function buildEmptyCartOrderInput({ storeId, channelId, currencyCode = "USD", owner }) {
+	return {
+		context: {
+			storeId,
+			channelId: channelId || "",
+			...owner ? { owner } : {}
+		},
+		totals: {
+			subTotal: createMoney(0, currencyCode),
+			shippingTotal: createMoney(0, currencyCode),
+			discountTotal: createMoney(0, currencyCode),
+			feeTotal: createMoney(0, currencyCode),
+			taxTotal: createMoney(0, currencyCode),
+			total: createMoney(0, currencyCode)
+		}
+	};
+}
+function buildAddLineItemBySkuIdInput(orderId, item) {
+	return {
+		orderId,
+		skuId: item.skuId,
+		name: item.name,
+		quantity: item.quantity,
+		fulfillmentMode: "NONE",
+		status: "DRAFT"
+	};
+}
+const getCartOrderQuery = `
+  query GetCartOrder($id: ID!) {
+    orderById(id: $id) {
+      id
+      customerId
+      createdAt
+      updatedAt
+      context {
+        storeId
+        channelId
+      }
+      lineItems {
+        id
+        name
+        quantity
+        skuId
+        type
+        fulfillmentMode
+        details {
+          productAssetUrl
+          sku
+          unitOfMeasure
+          selectedOptions {
+            attribute
+            values
+          }
+          selectedAddons {
+            attribute
+            sku
+            values {
+              name
+              costAdjustment {
+                value
+                currencyCode
+              }
+            }
+          }
+        }
+        totals {
+          subTotal {
+            value
+            currencyCode
+          }
+          taxTotal {
+            value
+            currencyCode
+          }
+          discountTotal {
+            value
+            currencyCode
+          }
+          feeTotal {
+            value
+            currencyCode
+          }
+        }
+        discounts {
+          id
+          name
+          code
+          amount {
+            value
+            currencyCode
+          }
+          ratePercentage
+        }
+        taxes {
+          id
+          name
+          amount {
+            value
+            currencyCode
+          }
+          ratePercentage
+        }
+        notes {
+          id
+          content
+          author
+          authorType
+        }
+      }
+      totals {
+        subTotal {
+          value
+          currencyCode
+        }
+        shippingTotal {
+          value
+          currencyCode
+        }
+        taxTotal {
+          value
+          currencyCode
+        }
+        discountTotal {
+          value
+          currencyCode
+        }
+        productDiscountTotal {
+          value
+          currencyCode
+        }
+        shippingDiscountTotal {
+          value
+          currencyCode
+        }
+        feeTotal {
+          value
+          currencyCode
+        }
+        total {
+          value
+          currencyCode
+        }
+      }
+      discounts {
+        id
+        name
+        code
+        amount {
+          value
+          currencyCode
+        }
+        ratePercentage
+        appliedBeforeTax
+      }
+      taxes {
+        id
+        name
+        amount {
+          value
+          currencyCode
+        }
+        ratePercentage
+        included
+        exempted
+      }
+      shipping {
+        firstName
+        lastName
+        email
+        phone
+        companyName
+        address {
+          addressLine1
+          addressLine2
+          addressLine3
+          adminArea1
+          adminArea2
+          adminArea3
+          adminArea4
+          postalCode
+          countryCode
+        }
+      }
+      notes {
+        id
+        content
+        author
+        authorType
+        createdAt
+      }
+      tags
+    }
+  }
+`;
+
+//#endregion
+//#region src/server/api/commerce/cart/[id]/discounts/POST.ts
+const applyDiscountCodesMutation = `
+  mutation ApplyDiscountCodes($input: ApplyDiscountCodesInput!) {
+    applyDiscountCodes(input: $input) {
+      id
+    }
+  }
+`;
+async function handler(req, res) {
+	try {
+		const cartId = req.params.id;
+		if (typeof cartId !== "string" || !cartId) {
+			res.status(400).json({ error: "Missing cart id" });
+			return;
+		}
+		const body = req.body ?? {};
+		const codes = Array.isArray(body.discountCodes) ? body.discountCodes.filter((code) => typeof code === "string" && code.length > 0) : [];
+		if (codes.length === 0) {
+			res.status(400).json({ error: "discountCodes must be a non-empty string array" });
+			return;
+		}
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const endpoint = orderStorefrontEndpoint({ apiBaseUrl });
+		const headers = storefrontHeaders({
+			storeId,
+			clientId
+		});
+		await gqlRequest({
+			endpoint,
+			query: applyDiscountCodesMutation,
+			variables: { input: {
+				orderId: cartId,
+				discountCodes: codes
+			} },
+			headers
+		});
+		const hydrated = await gqlRequest({
+			endpoint,
+			query: getCartOrderQuery,
+			variables: { id: cartId },
+			headers
+		});
+		res.json({ cart: hydrated.orderById ?? null });
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to apply discount codes",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/cart/[id]/GET.ts
+function isCartNotFoundError(error) {
+	if (!(error instanceof GraphQLErrorWithCodes)) return false;
+	const isFailure = (status) => status !== void 0 && status >= 400 && status !== 404 && status !== 410;
+	if (isFailure(error.status) || error.errors.length === 0) return false;
+	return error.errors.every(({ code, message, status }) => {
+		if (isFailure(status)) return false;
+		if (code === "INTERNAL_SERVER_ERROR" && message === "Order not found") return true;
+		if (code && /^(?:DRAFT[_-]?)?(?:ORDER|CART)[_-]?(?:NOT[_-]?FOUND|EXPIRED)$/i.test(code)) return true;
+		if (code && !/^(?:NOT[_-]?FOUND|EXPIRED)$/i.test(code)) return false;
+		return /\b(?:cart|(?:draft[ -])?order)\s+(?:(?:is|was|has)\s+)?(?:not found|expired)\b/i.test(message ?? "");
+	});
+}
+async function handler$1(req, res) {
+	try {
+		const cartId = req.params.id;
+		if (typeof cartId !== "string" || !cartId) {
+			res.status(400).json({ error: "Missing cart id" });
+			return;
+		}
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const data = await gqlRequest({
+			endpoint: orderStorefrontEndpoint({ apiBaseUrl }),
+			query: getCartOrderQuery,
+			variables: { id: cartId },
+			headers: storefrontHeaders({
+				storeId,
+				clientId
+			})
+		});
+		res.json({ cart: data.orderById ?? null });
+	} catch (error) {
+		if (isCartNotFoundError(error)) {
+			res.status(200).json({ cart: null });
+			return;
+		}
+		res.status(500).json({
+			error: "Failed to load cart",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/cart/[id]/items/[itemId]/DELETE.ts
+const deleteLineItemByIdMutation = `
+  mutation DeleteLineItemById($id: ID!, $orderId: ID!) {
+    deleteLineItemById(id: $id, orderId: $orderId)
+  }
+`;
+async function handler$2(req, res) {
+	try {
+		const cartId = req.params.id;
+		const itemId = req.params.itemId;
+		if (typeof cartId !== "string" || !cartId || typeof itemId !== "string" || !itemId) {
+			res.status(400).json({ error: "Missing cart id or item id" });
+			return;
+		}
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const endpoint = orderStorefrontEndpoint({ apiBaseUrl });
+		const headers = storefrontHeaders({
+			storeId,
+			clientId
+		});
+		await gqlRequest({
+			endpoint,
+			query: deleteLineItemByIdMutation,
+			variables: {
+				id: itemId,
+				orderId: cartId
+			},
+			headers
+		});
+		const hydrated = await gqlRequest({
+			endpoint,
+			query: getCartOrderQuery,
+			variables: { id: cartId },
+			headers
+		});
+		res.json({ cart: hydrated.orderById ?? null });
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to delete line item",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/cart/[id]/items/[itemId]/PATCH.ts
+const updateLineItemByIdMutation = `
+  mutation UpdateLineItemById($input: UpdateLineItemByIdInput!) {
+    updateLineItemById(input: $input) {
+      id
+    }
+  }
+`;
+async function handler$3(req, res) {
+	try {
+		const cartId = req.params.id;
+		const itemId = req.params.itemId;
+		if (typeof cartId !== "string" || !cartId || typeof itemId !== "string" || !itemId) {
+			res.status(400).json({ error: "Missing cart id or item id" });
+			return;
+		}
+		const body = req.body ?? {};
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const endpoint = orderStorefrontEndpoint({ apiBaseUrl });
+		const headers = storefrontHeaders({
+			storeId,
+			clientId
+		});
+		await gqlRequest({
+			endpoint,
+			query: updateLineItemByIdMutation,
+			variables: { input: {
+				id: itemId,
+				orderId: cartId,
+				name: body.name,
+				quantity: body.quantity,
+				fulfillmentMode: body.fulfillmentMode,
+				status: body.status,
+				type: body.type,
+				details: body.details
+			} },
+			headers
+		});
+		const hydrated = await gqlRequest({
+			endpoint,
+			query: getCartOrderQuery,
+			variables: { id: cartId },
+			headers
+		});
+		res.json({ cart: hydrated.orderById ?? null });
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to update line item",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/cart/[id]/items/POST.ts
+const addLineItemBySkuIdMutation$1 = `
+  mutation AddLineItemBySkuId($input: AddLineItemInput!) {
+    addLineItemBySkuId(input: $input) {
+      id
+    }
+  }
+`;
+async function handler$4(req, res) {
+	try {
+		const cartId = req.params.id;
+		if (typeof cartId !== "string" || !cartId) {
+			res.status(400).json({ error: "Missing cart id" });
+			return;
+		}
+		const body = req.body ?? {};
+		if (!body.skuId || !body.name || typeof body.quantity !== "number") {
+			res.status(400).json({ error: "Missing required fields: skuId, name, quantity" });
+			return;
+		}
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const endpoint = orderStorefrontEndpoint({ apiBaseUrl });
+		const headers = storefrontHeaders({
+			storeId,
+			clientId
+		});
+		await gqlRequest({
+			endpoint,
+			query: addLineItemBySkuIdMutation$1,
+			variables: { input: buildAddLineItemBySkuIdInput(cartId, {
+				skuId: body.skuId,
+				name: body.name,
+				quantity: body.quantity
+			}) },
+			headers
+		});
+		const hydrated = await gqlRequest({
+			endpoint,
+			query: getCartOrderQuery,
+			variables: { id: cartId },
+			headers
+		});
+		res.status(201).json({ cart: hydrated.orderById ?? null });
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to add line item",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/cart/POST.ts
+const addCartOrderMutation = `
+  mutation AddCartOrder($input: AddDraftOrderInput!) {
+    addDraftOrder(input: $input) {
+      id
+    }
+  }
+`;
+const addLineItemBySkuIdMutation = `
+  mutation AddLineItemBySkuId($input: AddLineItemInput!) {
+    addLineItemBySkuId(input: $input) {
+      id
+    }
+  }
+`;
+async function handler$5(req, res) {
+	try {
+		const body = req.body ?? {};
+		const initialItems = Array.isArray(body.lineItems) ? body.lineItems : [];
+		for (const item of initialItems) if (!item.skuId || !item.name || typeof item.quantity !== "number") {
+			res.status(400).json({ error: "Each lineItem must have skuId, a non-empty name, and a numeric quantity" });
+			return;
+		}
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, channelId, clientId, apiBaseUrl, currencyCode } = config;
+		const endpoint = orderStorefrontEndpoint({ apiBaseUrl });
+		const headers = storefrontHeaders({
+			storeId,
+			clientId
+		});
+		const newCartId = (await gqlRequest({
+			endpoint,
+			query: addCartOrderMutation,
+			variables: { input: buildEmptyCartOrderInput({
+				storeId,
+				channelId,
+				owner: config.owner,
+				currencyCode: body.currencyCode ?? currencyCode
+			}) },
+			headers
+		})).addDraftOrder?.id;
+		if (!newCartId) {
+			res.status(500).json({ error: "Failed to create cart: missing id in mutation response" });
+			return;
+		}
+		for (const item of initialItems) await gqlRequest({
+			endpoint,
+			query: addLineItemBySkuIdMutation,
+			variables: { input: buildAddLineItemBySkuIdInput(newCartId, item) },
+			headers
+		});
+		const hydrated = await gqlRequest({
+			endpoint,
+			query: getCartOrderQuery,
+			variables: { id: newCartId },
+			headers
+		});
+		res.status(201).json({ cart: hydrated.orderById ?? null });
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to create cart",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/checkout/POST.ts
+async function handler$6(req, res) {
+	try {
+		const configuration = commerceConfigurationForResponse(res);
+		const { draftOrderId, skuId, quantity, lineItemData, returnUrl, successUrl } = req.body ?? {};
+		if (lineItemData !== void 0) {
+			res.status(400).json({ error: "Non-catalog checkout must be created by the server." });
+			return;
+		}
+		if ([draftOrderId, skuId].filter(Boolean).length !== 1 || [draftOrderId, skuId].some((value) => value !== void 0 && (typeof value !== "string" || !value.trim()))) {
+			res.status(400).json({ error: "exactly one non-empty draftOrderId or skuId is required" });
+			return;
+		}
+		if (quantity !== void 0 && (!Number.isSafeInteger(quantity) || quantity < 1)) {
+			res.status(400).json({ error: "quantity must be a positive whole number" });
+			return;
+		}
+		if (req.headers?.["x-commerce-scope"] !== void 0) {
+			if (!validateCommerceCartScope(req, res, configuration.read())) return;
+		}
+		const validateReturnUrls = res.locals.commerceCheckoutReturnUrlValidator;
+		if (!validateReturnUrls) {
+			res.status(503).json({ error: "Checkout return destinations are not configured." });
+			return;
+		}
+		const destinations = validateReturnUrls(returnUrl, successUrl);
+		if (!destinations) {
+			res.status(400).json({ error: "Checkout return destinations are not allowed." });
+			return;
+		}
+		const session = await createCheckoutSession({
+			draftOrderId,
+			skuId,
+			quantity,
+			...destinations
+		}, configuration);
+		res.status(200).json(session);
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to create checkout session",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/config/GET.ts
+async function handler$7(_req, res) {
+	res.setHeader("Cache-Control", "no-store");
+	try {
+		const config = commerceConfigurationForResponse(res).read();
+		res.json({
+			cartScope: getCommerceCartScope(config),
+			currencyCode: config.currencyCode
+		});
+	} catch (cause) {
+		res.status(503).json({
+			error: "Commerce configuration is unavailable. Complete the store connection before continuing.",
+			message: cause instanceof Error ? cause.message : "Invalid Commerce configuration."
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/order-status/GET.ts
+async function handler$8(req, res) {
+	try {
+		const { orderId } = req.query;
+		if (!orderId || typeof orderId !== "string") {
+			res.status(400).json({
+				success: false,
+				error: "missing or invalid orderId query parameter"
+			});
+			return;
+		}
+		const order = await getOrderStatus(orderId, commerceConfigurationForResponse(res));
+		res.status(200).json({
+			success: true,
+			order
+		});
+	} catch (error) {
+		res.status(500).json({
+			success: false,
+			error: "Failed to get order status",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/lib/commerce/catalog-subgraph.ts
+function catalogStorefrontEndpoint({ storeId, apiBaseUrl }) {
+	return new URL(`/v2/commerce/stores/${storeId}/catalog-subgraph/storefront`, apiBaseUrl).toString();
+}
+function buildSkuGroupsVariables(input) {
+	const productIds = input.productIds?.filter(Boolean) ?? [];
+	const categoryIds = input.categoryIds?.filter(Boolean) ?? [];
+	const hasExplicitFilters = productIds.length > 0 || categoryIds.length > 0;
+	return {
+		...input.first !== void 0 && { first: input.first },
+		...input.after && { after: input.after },
+		...productIds.length > 0 && { id: { in: [...productIds] } },
+		...categoryIds.length > 0 && { listId: { in: [...categoryIds] } },
+		...!hasExplicitFilters && input.searchQuery && { label: { contains: input.searchQuery } }
+	};
+}
+function buildSkuGroupVariables({ productId, selectedAttributeValues, skuGroupFirst }) {
+	const attributeValues = selectedAttributeValues ? [...selectedAttributeValues] : [];
+	return {
+		id: productId,
+		attributeValues,
+		...!attributeValues.length && { first: skuGroupFirst ?? 50 }
+	};
+}
+
+//#endregion
+//#region src/server/api/commerce/products/[id]/GET.ts
+const skuGroupQuery = `
+  query SkuGroup($id: String!, $first: Int, $attributeValues: [String!] = []) {
+    skuGroup(id: $id) {
+      id
+      status
+      name
+      label
+      description
+      htmlDescription
+      type
+      priceRange(status: { eq: "ACTIVE" }) {
+        min
+        max
+      }
+      compareAtPriceRange(status: { eq: "ACTIVE" }) {
+        min
+        max
+      }
+      mediaObjects(first: 25) {
+        edges {
+          node {
+            url
+            type
+          }
+        }
+      }
+      attributes(first: 50, orderBy: { position: ASC }) {
+        edges {
+          node {
+            id
+            name
+            label
+            description
+            htmlDescription
+            values(first: 50, orderBy: { position: ASC }) {
+              edges {
+                node {
+                  id
+                  name
+                  label
+                }
+              }
+            }
+          }
+        }
+      }
+      skus(attributeValues: { has: $attributeValues }, first: $first, status: { eq: "ACTIVE" }) {
+        pageInfo { hasNextPage }
+        totalCount
+        edges {
+          node {
+           id
+           label
+           name
+            description
+            prices(first: 10) {
+              edges {
+                node {
+                  value { value currencyCode }
+                  compareAtValue { value currencyCode }
+                }
+              }
+            }
+            mediaObjects(first: 25) {
+              edges { node { url type } }
+            }
+           inventoryCounts {
+              edges {
+                node {
+                  id
+                  quantity
+                  type
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+function asStringArray$1(value) {
+	if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+	if (typeof value === "string" && value.length > 0) return [value];
+	return [];
+}
+function asNumber$1(value) {
+	if (typeof value !== "string" || value.length === 0) return void 0;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : void 0;
+}
+async function handler$9(req, res) {
+	try {
+		const productId = req.params.id;
+		if (typeof productId !== "string" || !productId) {
+			res.status(400).json({ error: "Missing product id" });
+			return;
+		}
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const variables = buildSkuGroupVariables({
+			productId,
+			selectedAttributeValues: asStringArray$1(req.query.attributeValues),
+			skuGroupFirst: asNumber$1(req.query.skuGroupFirst)
+		});
+		const data = await gqlRequest({
+			endpoint: catalogStorefrontEndpoint({
+				storeId,
+				apiBaseUrl
+			}),
+			query: skuGroupQuery,
+			variables,
+			headers: storefrontHeaders({
+				storeId,
+				clientId
+			})
+		});
+		res.json(data);
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to load product",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/products/GET.ts
+const skuGroupsQuery = `
+  query SkuGroups($first: Int, $after: String, $id: SKUGroupIdsFilter, $listId: ListIdFilter, $label: LabelFilter) {
+    skuGroups(
+      first: $first
+      after: $after
+      id: $id
+      listId: $listId
+      label: $label
+      status: { eq: "ACTIVE" }
+    ) {
+      edges {
+        cursor
+        node {
+          id
+          name
+          label
+          description
+          htmlDescription
+          type
+          priceRange(status: { eq: "ACTIVE" }) {
+            min
+            max
+          }
+          compareAtPriceRange(status: { eq: "ACTIVE" }) {
+            min
+            max
+          }
+          mediaObjects(first: 25) {
+            edges {
+              node {
+                url
+                type
+              }
+            }
+          }
+          attributes(first: 50, orderBy: { position: ASC }) {
+            edges {
+              node {
+                id
+                name
+                label
+                description
+                htmlDescription
+                values(first: 50, orderBy: { position: ASC }) {
+                  edges {
+                    node {
+                      id
+                      name
+                      label
+                    }
+                  }
+                }
+              }
+            }
+          }
+          skus(first: 2, status: { eq: "ACTIVE" }) {
+            pageInfo { hasNextPage }
+            totalCount
+            edges {
+              node {
+               id
+               label
+               name
+               inventoryCounts {
+                  edges {
+                    node {
+                      id
+                      quantity
+                      type
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+        startCursor
+        endCursor
+      }
+      totalCount
+    }
+  }
+`;
+function asStringArray(value) {
+	if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+	if (typeof value === "string" && value.length > 0) return [value];
+	return [];
+}
+function asNumber(value) {
+	if (typeof value !== "string" || value.length === 0) return void 0;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : void 0;
+}
+async function handler$10(req, res) {
+	try {
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const variables = buildSkuGroupsVariables({
+			first: asNumber(req.query.first) ?? 24,
+			after: typeof req.query.after === "string" ? req.query.after : void 0,
+			searchQuery: typeof req.query.searchQuery === "string" ? req.query.searchQuery : void 0,
+			productIds: asStringArray(req.query.productIds),
+			categoryIds: asStringArray(req.query.categoryIds)
+		});
+		const data = await gqlRequest({
+			endpoint: catalogStorefrontEndpoint({
+				storeId,
+				apiBaseUrl
+			}),
+			query: skuGroupsQuery,
+			variables,
+			headers: storefrontHeaders({
+				storeId,
+				clientId
+			})
+		});
+		res.json(data);
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to load products",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/server/api/commerce/skus/[id]/GET.ts
+const skuQuery = `
+  query Sku($id: String!) {
+    sku(id: $id) {
+      id
+      label
+      name
+      description
+      htmlDescription
+      code
+      prices {
+        edges {
+          node {
+            id
+            value {
+              value
+              currencyCode
+            }
+            compareAtValue {
+              value
+              currencyCode
+            }
+          }
+        }
+      }
+      inventoryCounts {
+        edges {
+          node {
+            id
+            quantity
+            type
+          }
+        }
+      }
+      mediaObjects {
+        edges {
+          node {
+            id
+            url
+            type
+            label
+            position
+          }
+        }
+      }
+      attributeValues {
+        edges {
+          node {
+            id
+            name
+            label
+          }
+        }
+      }
+    }
+  }
+`;
+async function handler$11(req, res) {
+	try {
+		const skuId = req.params.id;
+		if (typeof skuId !== "string" || !skuId) {
+			res.status(400).json({ error: "Missing sku id" });
+			return;
+		}
+		const config = readCommerceConfigForResponse(res);
+		if (!validateCommerceCartScope(req, res, config)) return;
+		const { storeId, clientId, apiBaseUrl } = config;
+		const data = await gqlRequest({
+			endpoint: catalogStorefrontEndpoint({
+				storeId,
+				apiBaseUrl
+			}),
+			query: skuQuery,
+			variables: { id: skuId },
+			headers: storefrontHeaders({
+				storeId,
+				clientId
+			})
+		});
+		res.json(data);
+	} catch (error) {
+		res.status(500).json({
+			error: "Failed to load sku",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+
+//#endregion
+//#region src/router.ts
+function createCommerceRouter(options = {}) {
+	const router = Router();
+	const configuration = options.configuration ?? createRuntimeCommerceConfiguration();
+	const catalogEnabled = options.features?.catalog ?? true;
+	const paymentsEnabled = options.features?.payments ?? true;
+	const validateCheckoutReturnUrls = options.checkoutReturnUrls ? createCheckoutReturnUrlValidator(options.checkoutReturnUrls) : void 0;
+	router.use((_req, res, next) => {
+		res.locals.commerceConfiguration = configuration;
+		res.locals.commerceCheckoutReturnUrlValidator = validateCheckoutReturnUrls;
+		next();
+	});
+	if (catalogEnabled) {
+		router.get("/config", handler$7);
+		router.get("/products", handler$10);
+		router.get("/products/:id", handler$9);
+		router.get("/skus/:id", handler$11);
+		router.post("/cart", handler$5);
+		router.get("/cart/:id", handler$1);
+		router.post("/cart/:id/items", handler$4);
+		router.patch("/cart/:id/items/:itemId", handler$3);
+		router.delete("/cart/:id/items/:itemId", handler$2);
+		router.post("/cart/:id/discounts", handler);
+	}
+	if (paymentsEnabled) {
+		router.post("/checkout", handler$6);
+		router.get("/order-status", handler$8);
+	}
+	return router;
+}
+function createCommerceCatalogRouter(configuration) {
+	return createCommerceRouter({
+		configuration,
+		features: {
+			catalog: true,
+			payments: false
+		}
+	});
+}
+function createGoDaddyPaymentsRouter(configuration, checkoutReturnUrls) {
+	return createCommerceRouter({
+		configuration,
+		checkoutReturnUrls,
+		features: {
+			catalog: false,
+			payments: true
+		}
+	});
+}
+
+//#endregion
+export { createCheckoutSession, createCommerceCatalogRouter, createCommerceRouter, createGoDaddyPaymentsRouter, createRuntimeCommerceConfiguration, getOrderStatus, parseCommerceCheckoutConfiguration, readCommerceConfig };