@atomic-solutions/woocommerce-api-client 0.4.0 → 0.5.1

package/dist/client/index.mjs

@@ -1,7 +1,14 @@
-import axios, { isAxiosError } from 'axios';
+import axios, { AxiosError, isCancel, isAxiosError } from 'axios';
+import { BaseError as BaseError$1 } from '@atomic-solutions/errors';
 import { z } from 'zod';
 
-// src/client/createClient.ts
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 
 // src/errors/classes/BaseError.ts
 var BaseError = class extends Error {
@@ -130,8 +137,16 @@ var WOOCOMMERCE_ERROR_METADATA = {
   }
 };
 
+// src/errors/classes/http-error.ts
+var redactPath = (url) => url.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]+/i, "").replace(/[?#].*$/, "").split("/").map((segment) => /^(\d+|[0-9a-f]{16,}|[0-9a-f-]{36})$/i.test(segment) ? ":id" : segment).join("/");
+var classifyHttpStatus = (status) => ({
+  domain: status === void 0 ? "network" : status === 401 || status === 403 ? "auth" : "integration",
+  severity: status !== void 0 && status < 500 ? "warning" : "error"
+});
+
 // src/errors/classes/WooCommerceApiError.ts
-var WooCommerceApiError = class extends BaseError {
+var _options;
+var WooCommerceApiError = class extends BaseError$1 {
   constructor(options) {
     const metadata = WOOCOMMERCE_ERROR_METADATA[options.code] ?? {
       operation: "woocommerce_api_request",
@@ -143,7 +158,30 @@ var WooCommerceApiError = class extends BaseError {
       userMessage: options.userMessage || metadata.userMessage,
       retryable: options.retryable ?? metadata.retryable
     };
-    super(enrichedOptions);
+    const status = enrichedOptions.statusCode;
+    const { domain, severity } = classifyHttpStatus(status);
+    super({
+      domain,
+      severity,
+      operation: enrichedOptions.operation,
+      message: enrichedOptions.message,
+      code: enrichedOptions.code,
+      retryable: enrichedOptions.retryable,
+      userMessage: enrichedOptions.userMessage,
+      cause: enrichedOptions.cause,
+      fingerprint: [domain, enrichedOptions.code, String(status ?? "network")],
+      extras: {
+        originalCode: enrichedOptions.originalCode,
+        statusCode: status,
+        path: redactPath(enrichedOptions.url),
+        method: enrichedOptions.method
+      }
+    });
+    __privateAdd(this, _options);
+    __privateSet(this, _options, enrichedOptions);
+  }
+  get options() {
+    return __privateGet(this, _options);
   }
   // Convenient getters for frequently accessed fields (no duplication)
   get wooCode() {
@@ -170,24 +208,8 @@ var WooCommerceApiError = class extends BaseError {
   get data() {
     return this.options.data;
   }
-  /**
-   * Get reportable data for error tracking/logging
-   * Includes HTTP context and WooCommerce-specific fields
-   */
-  getReportableData() {
-    return {
-      code: this.options.code,
-      operation: this.options.operation,
-      userMessage: this.options.userMessage,
-      retryable: this.options.retryable,
-      statusCode: this.options.statusCode,
-      url: this.options.url,
-      method: this.options.method,
-      wooCode: this.options.code,
-      originalCode: this.options.originalCode
-    };
-  }
 };
+_options = new WeakMap();
 
 // src/errors/classes/WooCommerceDataValidationError.ts
 var WooCommerceDataValidationError = class _WooCommerceDataValidationError extends BaseError {
@@ -278,34 +300,34 @@ var WooCommerceDataValidationError = class _WooCommerceDataValidationError exten
 };
 
 // src/http/handleApiResponse.ts
-var handleApiResponse = (response, schema, options) => {
+var handleApiData = (data, schema, options, url) => {
   const validationMode = options?.validationMode ?? "strict";
   if (validationMode === "warn") {
-    const result = schema.safeParse(response.data);
+    const result = schema.safeParse(data);
     if (!result.success) {
       const validationError = new WooCommerceDataValidationError({
-        message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
-        url: response.config.url,
+        message: `WooCommerce API response validation failed for ${url || "unknown endpoint"}`,
+        url,
         zodError: result.error,
-        value: response.data,
+        value: data,
         userMessage: "Received unexpected data from WooCommerce"
       });
       options?.onValidationError?.(validationError);
       options?.errorReporter?.(validationError);
       console.warn("[woocommerce-utils] Validation warning:", validationError.message);
-      return response.data;
+      return data;
     }
     return result.data;
   }
   try {
-    return schema.parse(response.data);
+    return schema.parse(data);
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "issues" in error2) {
       const validationError = new WooCommerceDataValidationError({
-        message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
-        url: response.config.url,
+        message: `WooCommerce API response validation failed for ${url || "unknown endpoint"}`,
+        url,
         zodError: error2,
-        value: response.data,
+        value: data,
         userMessage: "Received unexpected data from WooCommerce"
       });
       options?.onValidationError?.(validationError);
@@ -315,6 +337,7 @@ var handleApiResponse = (response, schema, options) => {
     throw error2;
   }
 };
+var handleApiResponse = (response, schema, options) => handleApiData(response.data, schema, options, response.config.url);
 
 // src/utils/calculatePagination.ts
 var calculatePagination = (input) => {
@@ -429,6 +452,12 @@ var error = (...args) => {
   console.error(DEBUG_PREFIX, ...args);
 };
 
+// src/http/storeRoutes.ts
+var CART_ROUTE = /\/wc\/store\/(v\d+\/)?(cart|checkout|batch)/;
+var BATCH_ROUTE = /\/wc\/store\/(v\d+\/)?batch/;
+var isCartRoute = (url) => !!url && CART_ROUTE.test(url);
+var isBatchRoute = (url) => !!url && BATCH_ROUTE.test(url);
+
 // src/http/interceptors/request.ts
 var requiresAuth = (url) => {
   if (!url) return false;
@@ -442,30 +471,26 @@ var requiresAuth = (url) => {
   ];
   return authEndpoints.some((endpoint) => url.includes(endpoint));
 };
-var requiresCartAuth = (url) => {
-  if (!url) return false;
-  return /\/wc\/store\/(v\d+\/)?cart/.test(url) || /\/wc\/store\/(v\d+\/)?checkout/.test(url);
-};
 var setupRequestInterceptor = (axiosInstance, config, client) => {
   axiosInstance.interceptors.request.use(
     async (requestConfig) => {
       const url = requestConfig.url;
       if (config.jwtToken) {
         const token = await config.jwtToken.get();
-        if (token && (requiresAuth(url) || requiresCartAuth(url))) {
+        if (token && (requiresAuth(url) || isCartRoute(url))) {
           requestConfig.headers.Authorization = `Bearer ${token}`;
           if (config.debug) {
             debug("Injected JWT token for", url);
           }
         }
       }
-      if (requiresCartAuth(url)) {
+      if (isCartRoute(url)) {
         const headers = await config.cartHeaders.get();
         const isAuthenticated = !!await config.jwtToken?.get();
         if (headers.nonce) {
           requestConfig.headers.Nonce = headers.nonce;
         }
-        if (headers.cartToken && !isAuthenticated) {
+        if (headers.cartToken && (!isAuthenticated || isBatchRoute(url))) {
           requestConfig.headers["Cart-Token"] = headers.cartToken;
         }
         requestConfig.headers["Cache-Control"] = "no-cache, no-store, must-revalidate";
@@ -494,16 +519,19 @@ var setupRequestInterceptor = (axiosInstance, config, client) => {
     }
   );
 };
-
-// src/http/interceptors/response.ts
-var isCartResponse = (url) => {
-  if (!url) return false;
-  return /\/wc\/store\/(v\d+\/)?cart/.test(url) || /\/wc\/store\/(v\d+\/)?checkout/.test(url);
+var NONCE_ERROR_CODES = ["woocommerce_rest_missing_nonce", "woocommerce_rest_invalid_nonce"];
+var isNonceRejectedBatch = (data) => {
+  const responses = data?.responses;
+  if (!Array.isArray(responses) || responses.length === 0) return false;
+  return responses.every((response) => {
+    const code = response?.body?.code;
+    return typeof code === "string" && NONCE_ERROR_CODES.includes(code);
+  });
 };
 var setupResponseInterceptor = (axiosInstance, config, client) => {
   axiosInstance.interceptors.response.use(
     async (response) => {
-      if (isCartResponse(response.config.url)) {
+      if (isCartRoute(response.config.url)) {
         const nonce = response.headers["nonce"] || response.headers["Nonce"];
         const cartToken = response.headers["cart-token"] || response.headers["Cart-Token"];
         if (nonce || cartToken) {
@@ -523,6 +551,15 @@ var setupResponseInterceptor = (axiosInstance, config, client) => {
           }
         }
       }
+      if (isBatchRoute(response.config.url) && isNonceRejectedBatch(response.data)) {
+        throw new AxiosError(
+          "Batch rejected for a nonce error",
+          AxiosError.ERR_BAD_REQUEST,
+          response.config,
+          response.request,
+          { ...response, status: 401, data: { code: "woocommerce_rest_missing_nonce" } }
+        );
+      }
       if (config.debug) {
         debug("Response:", response.config.url, response.status);
       }
@@ -565,12 +602,15 @@ var setupErrorInterceptor = (axiosInstance, config, client) => {
   axiosInstance.interceptors.response.use(
     (response) => response,
     async (axiosError) => {
-      const status = axiosError.response?.status || 500;
+      if (isCancel(axiosError)) {
+        return Promise.reject(axiosError);
+      }
+      const status = axiosError.response?.status;
       const errorData = axiosError.response?.data;
+      const isNetworkError = isAxiosError(axiosError) && !axiosError.response;
       const apiCode = errorData?.code || "unknown_error";
       const wpMessage = errorData?.message || axiosError.message || "Unknown error";
-      const errorCode = mapWooCommerceCode(apiCode);
-      const errorMetadata = WOOCOMMERCE_ERROR_METADATA[errorCode];
+      const errorCode = isNetworkError ? "network_error" : mapWooCommerceCode(apiCode);
       const wcError = new WooCommerceApiError({
         message: wpMessage,
         statusCode: status,
@@ -578,9 +618,6 @@ var setupErrorInterceptor = (axiosInstance, config, client) => {
         // Transformed app-level code
         originalCode: apiCode,
         // Original WooCommerce API code
-        retryable: errorMetadata.retryable,
-        userMessage: errorMetadata.userMessage,
-        operation: errorMetadata.operation,
         url: axiosError.config?.url || "",
         method: axiosError.config?.method?.toUpperCase() || "GET",
         requestBody: axiosError.config?.data,
@@ -961,7 +998,7 @@ var cartSchema = z.object({
   cross_sells: z.array(z.unknown()),
   fees: z.array(z.unknown())
 });
-z.object({
+var addToCartInputSchema = z.object({
   id: z.number(),
   quantity: z.number().int().positive(),
   variation: z.array(
@@ -971,6 +1008,18 @@ z.object({
     })
   ).optional()
 });
+z.object({
+  items: z.array(addToCartInputSchema).min(1)
+});
+var batchResponseSchema = z.object({
+  responses: z.array(
+    z.object({
+      status: z.number(),
+      body: z.unknown(),
+      headers: z.record(z.string(), z.unknown()).optional()
+    })
+  )
+});
 z.object({
   key: z.string(),
   quantity: z.number().int().positive()
@@ -1330,6 +1379,19 @@ z.object({
 var ORDER_ATTRIBUTION_NAMESPACE = "woocommerce/order-attribution";
 
 // src/api/cart.ts
+var BATCH_MAX_REQUESTS = 25;
+var chunk = (list, size) => Array.from(
+  { length: Math.ceil(list.length / size) },
+  (_, index) => list.slice(index * size, index * size + size)
+);
+var isAccepted = (status) => status >= 200 && status < 300;
+var bodyError = (body) => {
+  const data = body;
+  return {
+    code: typeof data?.code === "string" ? data.code : void 0,
+    message: typeof data?.message === "string" ? data.message : void 0
+  };
+};
 var createCartAPI = (client, endpoints, options) => ({
   get: async () => {
     const response = await client.get(endpoints.cart);
@@ -1339,6 +1401,48 @@ var createCartAPI = (client, endpoints, options) => ({
     const response = await client.post(endpoints.addItem, input);
     return handleApiResponse(response, cartSchema, options);
   },
+  addItems: async ({ items }) => {
+    const responses = [];
+    let chunkFailed = false;
+    for (const batch of chunk(items, BATCH_MAX_REQUESTS)) {
+      try {
+        const response = await client.post(endpoints.batch, {
+          requests: batch.map((item) => ({
+            method: "POST",
+            path: endpoints.addItem,
+            body: item
+          }))
+        });
+        responses.push(...handleApiResponse(response, batchResponseSchema, options).responses);
+      } catch (error2) {
+        if (responses.length === 0) throw error2;
+        chunkFailed = true;
+        break;
+      }
+    }
+    const results = items.map((item, index) => {
+      const entry = responses[index];
+      const { code, message } = bodyError(entry?.body);
+      return {
+        item,
+        status: entry?.status ?? 500,
+        ...code ? { code } : {},
+        ...message ? { message } : {}
+      };
+    });
+    const lastAccepted = [...responses].reverse().find((entry) => isAccepted(entry.status));
+    const batchCart = lastAccepted ? handleApiData(lastAccepted.body, cartSchema, options, endpoints.batch) : void 0;
+    let cart = chunkFailed ? void 0 : batchCart;
+    if (!cart) {
+      try {
+        cart = handleApiResponse(await client.get(endpoints.cart), cartSchema, options);
+      } catch (error2) {
+        if (!batchCart) throw error2;
+        cart = batchCart;
+      }
+    }
+    return { cart, results };
+  },
   updateItem: async (input) => {
     const response = await client.post(endpoints.updateItem, input);
     return handleApiResponse(response, cartSchema, options);
@@ -1428,6 +1532,8 @@ var createEndpoints = (version = "legacy") => {
     removeCoupon: `${prefix}/cart/remove-coupon`,
     updateCustomer: `${prefix}/cart/update-customer`,
     selectShippingRate: `${prefix}/cart/select-shipping-rate`,
+    // Batch
+    batch: `${prefix}/batch`,
     // Checkout
     checkout: `${prefix}/checkout`,
     // Orders