@bacano/sdk 1.2.7 → 1.2.8

package/catalog-management-types.d.ts

@@ -0,0 +1,143 @@
+export interface CatalogCapabilities {
+    references: true;
+    drafts: boolean;
+    images: boolean;
+    content: boolean;
+}
+export interface CatalogManagementContext {
+    companyId: string;
+    grantId: string;
+    capabilities: CatalogCapabilities;
+    allProducts: boolean;
+    productIds: string[];
+    branchIds: string[];
+    expiresAt: string;
+    /** Only draft writes; never confirmation or direct product edits. */
+    writesAvailable: boolean;
+}
+export interface CatalogReferences {
+    contractVersion: 1;
+    company: {
+        id: string;
+        name: string;
+        country_code: string;
+        is_vat_responsible: boolean;
+        sales_prices_include_tax_default: boolean;
+    };
+    priceTypes: Array<{
+        price_type: string;
+        is_enabled: boolean;
+        is_enabled_for_sales: boolean;
+        sort_order: number;
+    }>;
+    taxProfiles: Array<{
+        code: string;
+        name: string;
+        category: string;
+        rate: number;
+    }>;
+    branches: Array<{
+        id: string;
+        name: string;
+        chains_warehouses: Array<{
+            warehouse: {
+                id: string;
+                name: string;
+            };
+        }>;
+    }>;
+    websites: Array<{
+        id: string;
+        name: string;
+        chain_id: string | null;
+        is_active: boolean;
+    }>;
+    categories: Array<{
+        name: string;
+        product_subcategories: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
+    measurementUnits: Array<{
+        name: string;
+    }>;
+    rules: {
+        saleMustBeLowerThanClient: true;
+        existingProductsContentOnly: true;
+        humanConfirmationRequired: true;
+        inventoryRequiresExistingWarehouse: true;
+        taxonomyEndpoint: string;
+    };
+}
+export interface CatalogAttributeRule {
+    attribute_id: string;
+    sort_order: number;
+    usage_scope: string;
+    is_required: boolean;
+    is_filterable: boolean;
+}
+export interface CatalogTaxonomy {
+    attribute_categories: Array<CatalogAttributeRule & {
+        category: string;
+    }>;
+    attribute_subcategories: Array<CatalogAttributeRule & {
+        subcategory_id: string;
+    }>;
+    attribute_subcategory_exclusions: Array<{
+        subcategory_id: string;
+        attribute_id: string;
+        reason: string | null;
+    }>;
+    attributes: Array<{
+        id: string;
+        name: string;
+        is_multiple: boolean;
+        tooltip: string | null;
+        values: unknown;
+        attribute_values: Array<{
+            id: string;
+            code: string;
+            sort_order: number;
+            metadata: unknown;
+        }>;
+        attribute_value_sets: Array<{
+            id: string;
+            code: string;
+            category: string;
+            attribute_id: string;
+            product_subcategory_attribute_value_sets: Array<{
+                subcategory_id: string;
+                position: number;
+            }>;
+            attribute_value_set_values: Array<{
+                position: number;
+                attribute_value: {
+                    id: string;
+                    code: string;
+                    metadata: unknown;
+                };
+            }>;
+        }>;
+    }>;
+}
+export interface CatalogProductContent {
+    id: string;
+    name: string;
+    sku: string | null;
+    description: string | null;
+    long_description: unknown;
+    seo_title: string | null;
+    seo_description: string | null;
+    updated_at: string | null;
+}
+export interface CatalogProductPage {
+    items: CatalogProductContent[];
+    hasMore: boolean;
+    nextOffset: number | null;
+}
+export interface CatalogManagementConfig {
+    apiUrl: string;
+    accessToken: string | (() => string | Promise<string>);
+    fetch?: typeof fetch;
+}

package/catalog-management.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/sdk/src/catalog-management.ts
+var catalog_management_exports = {};
+__export(catalog_management_exports, {
+  CatalogManagementError: () => CatalogManagementError,
+  createCatalogManagementClient: () => createCatalogManagementClient
+});
+module.exports = __toCommonJS(catalog_management_exports);
+var CatalogManagementError = class extends Error {
+  constructor(code, status, message, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "CatalogManagementError";
+  }
+  code;
+  status;
+  details;
+};
+function createCatalogManagementClient(config) {
+  const base = config.apiUrl.trim().replace(/\/+$/, "");
+  const url = new URL(base);
+  if (url.username || url.password || url.search || url.hash || !(url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+    throw new CatalogManagementError(
+      "CATALOG_CONFIG_INVALID",
+      0,
+      "Usa HTTPS o localhost para el acceso temporal."
+    );
+  }
+  const fetcher = config.fetch ?? globalThis.fetch;
+  async function request(path, input) {
+    const token = typeof config.accessToken === "function" ? await config.accessToken() : config.accessToken;
+    if (!token.trim())
+      throw new CatalogManagementError(
+        "CATALOG_ACCESS_INVALID",
+        401,
+        "Falta el acceso temporal."
+      );
+    const response = await fetcher(`${base}/api/v1/catalog-management${path}`, {
+      method: input ? "POST" : "GET",
+      headers: {
+        Authorization: `Bearer ${token.trim()}`,
+        Accept: "application/json",
+        ...input ? {
+          "Content-Type": input.bytes ? "application/octet-stream" : "application/json"
+        } : {}
+      },
+      ...input ? { body: input.bytes ?? JSON.stringify(input.json) } : {},
+      cache: "no-store",
+      redirect: "error",
+      credentials: "omit"
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload.success !== true || payload.data === void 0) {
+      throw new CatalogManagementError(
+        payload.error?.code ?? "CATALOG_REQUEST_FAILED",
+        response.status,
+        payload.error?.message ?? payload.message ?? "No fue posible consultar el cat\xE1logo.",
+        payload.error?.details
+      );
+    }
+    return payload.data;
+  }
+  return {
+    createBatch: (input) => request("/batches", { json: input }),
+    getBatch: (batchId, input = {}) => {
+      const query = new URLSearchParams();
+      if (input.limit !== void 0) query.set("limit", String(input.limit));
+      if (input.after !== void 0) query.set("after", input.after);
+      return request(
+        `/batches/${encodeURIComponent(batchId)}${query.size ? `?${query}` : ""}`
+      );
+    },
+    getDraft: (batchId, itemId) => request(
+      `/batches/${encodeURIComponent(batchId)}/items/${encodeURIComponent(itemId)}`
+    ),
+    sendProposals: (batchId, items) => request(
+      `/batches/${encodeURIComponent(batchId)}/items`,
+      { json: { items } }
+    ),
+    uploadImage: (input) => {
+      const query = new URLSearchParams({
+        source_key: input.source_key,
+        expected_revision: String(input.expected_revision),
+        request_id: input.request_id
+      });
+      return request(
+        `/batches/${encodeURIComponent(input.batchId)}/items/${encodeURIComponent(input.itemId)}/images?${query}`,
+        { bytes: input.bytes }
+      );
+    },
+    getContext: () => request("/context"),
+    getReferences: () => request("/references"),
+    getTaxonomy: (category) => request(
+      `/references/taxonomy?category=${encodeURIComponent(category)}`
+    ),
+    listProducts: (input = {}) => {
+      const query = new URLSearchParams();
+      if (input.limit !== void 0) query.set("limit", String(input.limit));
+      if (input.offset !== void 0) query.set("offset", String(input.offset));
+      return request(
+        `/products${query.size ? `?${query}` : ""}`
+      );
+    }
+  };
+}

package/catalog-management.d.ts

@@ -0,0 +1,37 @@
+import type { CatalogManagementConfig, CatalogManagementContext, CatalogProductPage, CatalogReferences, CatalogTaxonomy } from "./catalog-management-types";
+export * from "./catalog-draft-types";
+export * from "./catalog-management-types";
+import type { CatalogDraftBatch, CatalogDraftBatchPage, CatalogDraftChunkResult, CatalogDraftImageResult, CatalogDraftResult, CatalogDraftWrite } from "./catalog-draft-types";
+export declare class CatalogManagementError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details?: unknown | undefined;
+    constructor(code: string, status: number, message: string, details?: unknown | undefined);
+}
+export declare function createCatalogManagementClient(config: CatalogManagementConfig): {
+    createBatch: (input: {
+        request_id: string;
+        name: string;
+    }) => Promise<CatalogDraftBatch>;
+    getBatch: (batchId: string, input?: {
+        limit?: number;
+        after?: string;
+    }) => Promise<CatalogDraftBatchPage>;
+    getDraft: (batchId: string, itemId: string) => Promise<CatalogDraftResult>;
+    sendProposals: (batchId: string, items: CatalogDraftWrite[]) => Promise<CatalogDraftChunkResult>;
+    uploadImage: (input: {
+        batchId: string;
+        itemId: string;
+        source_key: string;
+        expected_revision: number;
+        request_id: string;
+        bytes: Blob;
+    }) => Promise<CatalogDraftImageResult>;
+    getContext: () => Promise<CatalogManagementContext>;
+    getReferences: () => Promise<CatalogReferences>;
+    getTaxonomy: (category: string) => Promise<CatalogTaxonomy>;
+    listProducts: (input?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<CatalogProductPage>;
+};

package/catalog-management.js

@@ -0,0 +1,104 @@
+// libs/sdk/src/catalog-management.ts
+var CatalogManagementError = class extends Error {
+  constructor(code, status, message, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "CatalogManagementError";
+  }
+  code;
+  status;
+  details;
+};
+function createCatalogManagementClient(config) {
+  const base = config.apiUrl.trim().replace(/\/+$/, "");
+  const url = new URL(base);
+  if (url.username || url.password || url.search || url.hash || !(url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+    throw new CatalogManagementError(
+      "CATALOG_CONFIG_INVALID",
+      0,
+      "Usa HTTPS o localhost para el acceso temporal."
+    );
+  }
+  const fetcher = config.fetch ?? globalThis.fetch;
+  async function request(path, input) {
+    const token = typeof config.accessToken === "function" ? await config.accessToken() : config.accessToken;
+    if (!token.trim())
+      throw new CatalogManagementError(
+        "CATALOG_ACCESS_INVALID",
+        401,
+        "Falta el acceso temporal."
+      );
+    const response = await fetcher(`${base}/api/v1/catalog-management${path}`, {
+      method: input ? "POST" : "GET",
+      headers: {
+        Authorization: `Bearer ${token.trim()}`,
+        Accept: "application/json",
+        ...input ? {
+          "Content-Type": input.bytes ? "application/octet-stream" : "application/json"
+        } : {}
+      },
+      ...input ? { body: input.bytes ?? JSON.stringify(input.json) } : {},
+      cache: "no-store",
+      redirect: "error",
+      credentials: "omit"
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload.success !== true || payload.data === void 0) {
+      throw new CatalogManagementError(
+        payload.error?.code ?? "CATALOG_REQUEST_FAILED",
+        response.status,
+        payload.error?.message ?? payload.message ?? "No fue posible consultar el cat\xE1logo.",
+        payload.error?.details
+      );
+    }
+    return payload.data;
+  }
+  return {
+    createBatch: (input) => request("/batches", { json: input }),
+    getBatch: (batchId, input = {}) => {
+      const query = new URLSearchParams();
+      if (input.limit !== void 0) query.set("limit", String(input.limit));
+      if (input.after !== void 0) query.set("after", input.after);
+      return request(
+        `/batches/${encodeURIComponent(batchId)}${query.size ? `?${query}` : ""}`
+      );
+    },
+    getDraft: (batchId, itemId) => request(
+      `/batches/${encodeURIComponent(batchId)}/items/${encodeURIComponent(itemId)}`
+    ),
+    sendProposals: (batchId, items) => request(
+      `/batches/${encodeURIComponent(batchId)}/items`,
+      { json: { items } }
+    ),
+    uploadImage: (input) => {
+      const query = new URLSearchParams({
+        source_key: input.source_key,
+        expected_revision: String(input.expected_revision),
+        request_id: input.request_id
+      });
+      return request(
+        `/batches/${encodeURIComponent(input.batchId)}/items/${encodeURIComponent(input.itemId)}/images?${query}`,
+        { bytes: input.bytes }
+      );
+    },
+    getContext: () => request("/context"),
+    getReferences: () => request("/references"),
+    getTaxonomy: (category) => request(
+      `/references/taxonomy?category=${encodeURIComponent(category)}`
+    ),
+    listProducts: (input = {}) => {
+      const query = new URLSearchParams();
+      if (input.limit !== void 0) query.set("limit", String(input.limit));
+      if (input.offset !== void 0) query.set("offset", String(input.offset));
+      return request(
+        `/products${query.size ? `?${query}` : ""}`
+      );
+    }
+  };
+}
+export {
+  CatalogManagementError,
+  createCatalogManagementClient
+};

package/index.cjs

@@ -3338,6 +3338,78 @@ function hasRecoverableCartSessionError(errors) {
   );
 }
 
+// libs/sdk/src/modules/checkout-contact.ts
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var PHONE_PATTERN = /^\+?\d{7,15}$/;
+function validEmail(value) {
+  if (value.length > 320 || !EMAIL_PATTERN.test(value)) return false;
+  const [local, domain] = value.split("@");
+  if (!local || !domain || local.length > 64 || domain.length > 255 || local.startsWith(".") || local.endsWith(".") || local.includes("..")) {
+    return false;
+  }
+  return domain.split(".").every((label) => /^[a-z\d](?:[a-z\d-]*[a-z\d])?$/i.test(label));
+}
+function normalizePhone(value) {
+  return value.trim().replace(/[\s().-]/g, "");
+}
+function invalidContact(field) {
+  const messages = {
+    email: "Revisa el correo electr\xF3nico: debe estar completo y sin espacios.",
+    phone: "Revisa el n\xFAmero de tel\xE9fono: usa entre 7 y 15 d\xEDgitos.",
+    contact: "Ingresa un correo electr\xF3nico o un n\xFAmero de tel\xE9fono v\xE1lido."
+  };
+  return new WebsiteError(
+    messages[field],
+    `INVALID_CHECKOUT_${field.toUpperCase()}`
+  );
+}
+function normalizeCheckoutContact(contact, mode) {
+  const email = contact.email?.trim() || void 0;
+  const phone = contact.phone ? normalizePhone(contact.phone) : void 0;
+  const cellphone = contact.cellphone ? normalizePhone(contact.cellphone) : void 0;
+  const emailValid = !email || validEmail(email);
+  const phoneValid = !phone || PHONE_PATTERN.test(phone);
+  const cellphoneValid = !cellphone || PHONE_PATTERN.test(cellphone);
+  if (mode === "submit") {
+    if (!emailValid) throw invalidContact("email");
+    if (!phoneValid || !cellphoneValid) throw invalidContact("phone");
+  }
+  const normalized = {
+    ...contact,
+    name: contact.name?.trim() || void 0,
+    firstName: contact.firstName?.trim() || void 0,
+    lastName: contact.lastName?.trim() || void 0,
+    email: emailValid ? email : void 0,
+    phone: phoneValid ? phone : void 0,
+    cellphone: cellphoneValid ? cellphone : void 0
+  };
+  if ((normalized.name?.length ?? 0) > 160 || (normalized.firstName?.length ?? 0) > 80 || (normalized.lastName?.length ?? 0) > 80) {
+    throw new WebsiteError(
+      "Revisa los datos de contacto: el nombre es demasiado largo.",
+      "INVALID_CHECKOUT_CONTACT"
+    );
+  }
+  if (!normalized.email && !normalized.phone && !normalized.cellphone) {
+    throw invalidContact(
+      !emailValid ? "email" : !phoneValid || !cellphoneValid ? "phone" : "contact"
+    );
+  }
+  return normalized;
+}
+function explainCheckoutRequestError(error) {
+  if (error instanceof GraphQLRequestError && error.graphqlErrors.some(
+    (item) => /invalid request payload|hay un error en los datos del pedido/i.test(
+      item.message
+    )
+  )) {
+    throw new WebsiteError(
+      "Hay un error en los datos del pedido. Rev\xEDsalos e intenta de nuevo.",
+      "INVALID_CHECKOUT_DATA"
+    );
+  }
+  throw error;
+}
+
 // libs/sdk/src/modules/cart.ts
 function mapCartItem(raw) {
   return {
@@ -3413,6 +3485,15 @@ function requireCartSession(storage) {
   return session;
 }
 function createCartModule(graphqlUrl, getHeaders, getContext, cartSessionStorage) {
+  let pendingCartSessionOperation = Promise.resolve();
+  function enqueueCartSessionOperation(run) {
+    const operation = pendingCartSessionOperation.then(run, run);
+    pendingCartSessionOperation = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
+  }
   async function fetchCart(orderId, cartToken) {
     const data = await executeGraphQL(graphqlUrl, GET_CART, { orderId, cartToken }, getHeaders);
     const result = data.websiteGetCart;
@@ -3435,72 +3516,80 @@ function createCartModule(graphqlUrl, getHeaders, getContext, cartSessionStorage
   }
   return {
     async getOrCreate(contact, fulfillmentFamily) {
-      const ctx = getContext();
-      if (!ctx.chainId) {
-        throw new WebsiteError(
-          "This website has no chain configured. Cart requires a chain_id.",
-          "NO_CHAIN"
-        );
-      }
-      const existing = cartSessionStorage.get();
-      const data = await executeGraphQL(
-        graphqlUrl,
-        CREATE_CART,
-        {
-          websiteId: ctx.websiteId,
-          cartToken: existing?.cartToken,
-          contact,
-          fulfillmentFamily
-        },
-        getHeaders
-      );
-      const result = data.websiteCreateCart;
-      assertActionSuccess(result, "CART_CREATE_ERROR");
-      cartSessionStorage.set({
-        orderId: result.order_id,
-        cartToken: result.cart_token
-      });
-      return mapCart(result.cart, result.cart_token);
-    },
-    async startCheckout(input) {
-      const ctx = getContext();
-      if (!ctx.chainId) {
-        throw new WebsiteError(
-          "This website has no chain configured. Checkout requires a chain_id.",
-          "NO_CHAIN"
-        );
-      }
-      const requestStartCheckout = async (cartToken) => {
+      return enqueueCartSessionOperation(async () => {
+        const normalizedContact = contact ? normalizeCheckoutContact(contact, "draft") : void 0;
+        const ctx = getContext();
+        if (!ctx.chainId) {
+          throw new WebsiteError(
+            "This website has no chain configured. Cart requires a chain_id.",
+            "NO_CHAIN"
+          );
+        }
+        const existing = cartSessionStorage.get();
         const data = await executeGraphQL(
           graphqlUrl,
-          START_GUEST_CHECKOUT,
+          CREATE_CART,
           {
             websiteId: ctx.websiteId,
-            cartToken,
-            contact: input.contact,
-            fulfillmentFamily: input.fulfillmentFamily,
-            items: input.items.map((item) => ({
-              product_variant_id: item.productVariantId,
-              quantity: item.quantity
-            })),
-            marketingAttribution: input.marketingAttribution ? serializeWebsiteMarketingAttribution(input.marketingAttribution) : void 0
+            cartToken: existing?.cartToken,
+            contact: normalizedContact,
+            fulfillmentFamily
           },
           getHeaders
-        );
-        return data.websiteStartGuestCheckout;
-      };
-      const existing = cartSessionStorage.get();
-      let result = await requestStartCheckout(existing?.cartToken);
-      if (existing && !result.success && hasRecoverableCartSessionError(result.errors)) {
-        cartSessionStorage.clear();
-        result = await requestStartCheckout();
-      }
-      assertActionSuccess(result, "CHECKOUT_START_ERROR");
-      cartSessionStorage.set({
-        orderId: result.order_id,
-        cartToken: result.cart_token
+        ).catch(explainCheckoutRequestError);
+        const result = data.websiteCreateCart;
+        assertActionSuccess(result, "CART_CREATE_ERROR");
+        cartSessionStorage.set({
+          orderId: result.order_id,
+          cartToken: result.cart_token
+        });
+        return mapCart(result.cart, result.cart_token);
+      });
+    },
+    async startCheckout(input) {
+      return enqueueCartSessionOperation(async () => {
+        const contact = normalizeCheckoutContact(input.contact, "draft");
+        const ctx = getContext();
+        if (!ctx.chainId) {
+          throw new WebsiteError(
+            "This website has no chain configured. Checkout requires a chain_id.",
+            "NO_CHAIN"
+          );
+        }
+        const requestStartCheckout = async (cartToken) => {
+          const data = await executeGraphQL(
+            graphqlUrl,
+            START_GUEST_CHECKOUT,
+            {
+              websiteId: ctx.websiteId,
+              cartToken,
+              contact,
+              fulfillmentFamily: input.fulfillmentFamily,
+              items: input.items.map((item) => ({
+                product_variant_id: item.productVariantId,
+                quantity: item.quantity
+              })),
+              marketingAttribution: input.marketingAttribution ? serializeWebsiteMarketingAttribution(
+                input.marketingAttribution
+              ) : void 0
+            },
+            getHeaders
+          ).catch(explainCheckoutRequestError);
+          return data.websiteStartGuestCheckout;
+        };
+        const existing = cartSessionStorage.get();
+        let result = await requestStartCheckout(existing?.cartToken);
+        if (existing && !result.success && hasRecoverableCartSessionError(result.errors)) {
+          cartSessionStorage.clear();
+          result = await requestStartCheckout();
+        }
+        assertActionSuccess(result, "CHECKOUT_START_ERROR");
+        cartSessionStorage.set({
+          orderId: result.order_id,
+          cartToken: result.cart_token
+        });
+        return mapCart(result.cart, result.cart_token);
       });
-      return mapCart(result.cart, result.cart_token);
     },
     async get() {
       const session = cartSessionStorage.get();
@@ -5599,6 +5688,7 @@ function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionSto
       return mapCouponResult(data.websiteRemoveCoupon);
     },
     async submit(input) {
+      const contact = normalizeCheckoutContact(input.contact, "submit");
       const session = requireCartSession2(cartSessionStorage);
       const data = await executeGraphQL(
         graphqlUrl,
@@ -5606,7 +5696,7 @@ function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionSto
         {
           orderId: session.orderId,
           cartToken: session.cartToken,
-          contact: input.contact,
+          contact,
           fulfillmentFamily: input.fulfillmentFamily,
           address: input.address,
           shippingQuoteId: input.shippingQuoteId,
@@ -5626,7 +5716,7 @@ function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionSto
           } : void 0
         },
         getHeaders
-      );
+      ).catch(explainCheckoutRequestError);
       const result = data.websiteCheckout;
       if (!result.success && result.errors && result.errors.length > 0) {
         throw new CheckoutError(result.errors);
@@ -5667,7 +5757,7 @@ function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionSto
           returnUrl: input.returnUrl
         },
         getHeaders
-      );
+      ).catch(explainCheckoutRequestError);
       const result = data.websiteCreatePaymentSession;
       if (result.success && result.payment_session_id && (result.integration_mode !== "redirect" || !result.redirect_url)) {
         throw new WebsiteError(
@@ -5702,7 +5792,7 @@ function createCheckoutModule(graphqlUrl, getHeaders, getContext, cartSessionSto
           gatewayTransactionId: input.gatewayTransactionId
         },
         getHeaders
-      );
+      ).catch(explainCheckoutRequestError);
       const result = data.websiteReconcilePaymentSession;
       return {
         success: result.success,