@atomic-solutions/woocommerce-api-client 0.1.0

package/dist/http/index.js

@@ -0,0 +1,638 @@
+'use strict';
+
+var axios = require('axios');
+
+// src/errors/classes/BaseError.ts
+var BaseError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.options = options;
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    if (this.options.cause instanceof Error && this.options.cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${this.options.cause.stack}`;
+    }
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Subclasses should override this to add their own reportable fields
+   */
+  getReportableData() {
+    const { code, operation, userMessage, retryable } = this.options;
+    return {
+      code,
+      operation,
+      userMessage,
+      retryable
+    };
+  }
+  /**
+   * Custom JSON serialization
+   * Makes the error properly serializable for logging/reporting
+   */
+  toJSON() {
+    return {
+      ...this.getReportableData(),
+      name: this.name,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+};
+
+// src/errors/mapping/mapWooCommerceCode.ts
+var mapWooCommerceCode = (apiCode) => {
+  const directMatches = {
+    woocommerce_rest_cart_empty: "cart_empty",
+    woocommerce_rest_cart_coupon_error: "invalid_coupon",
+    woocommerce_rest_missing_nonce: "missing_nonce",
+    woocommerce_rest_invalid_nonce: "invalid_nonce",
+    rest_invalid_param: "invalid_params",
+    woocommerce_rest_product_invalid_id: "product_not_found",
+    woocommerce_rest_product_out_of_stock: "out_of_stock",
+    woocommerce_rest_product_not_enough_stock: "insufficient_stock",
+    woocommerce_rest_checkout_invalid_payment_method: "invalid_payment_method"
+  };
+  if (directMatches[apiCode]) {
+    return directMatches[apiCode];
+  }
+  if (apiCode.includes("nonce")) return "invalid_nonce";
+  if (apiCode.includes("coupon")) return "invalid_coupon";
+  if (apiCode.includes("stock")) return "insufficient_stock";
+  if (apiCode.includes("checkout")) return "checkout_error";
+  if (apiCode.includes("payment")) return "invalid_payment_method";
+  return "unknown_error";
+};
+
+// src/errors/mapping/constants.ts
+var WOOCOMMERCE_ERROR_METADATA = {
+  cart_empty: {
+    operation: "get_cart",
+    retryable: false,
+    userMessage: "Your cart is empty"
+  },
+  invalid_coupon: {
+    operation: "apply_coupon",
+    retryable: false,
+    userMessage: "Invalid coupon code"
+  },
+  missing_nonce: {
+    operation: "cart_request",
+    retryable: true
+    // Auto-retry with new nonce
+  },
+  invalid_nonce: {
+    operation: "cart_request",
+    retryable: true
+    // Auto-retry with new nonce
+  },
+  invalid_params: {
+    operation: "api_request",
+    retryable: false,
+    userMessage: "Invalid request parameters"
+  },
+  product_not_found: {
+    operation: "get_product",
+    retryable: false,
+    userMessage: "Product not found"
+  },
+  out_of_stock: {
+    operation: "add_to_cart",
+    retryable: false,
+    userMessage: "This product is out of stock"
+  },
+  insufficient_stock: {
+    operation: "add_to_cart",
+    retryable: false,
+    userMessage: "Not enough stock available"
+  },
+  invalid_payment_method: {
+    operation: "process_checkout",
+    retryable: false,
+    userMessage: "Invalid payment method"
+  },
+  checkout_error: {
+    operation: "process_checkout",
+    retryable: false
+  },
+  network_error: {
+    operation: "network_request",
+    retryable: true
+  },
+  unknown_error: {
+    operation: "unknown",
+    retryable: false
+  }
+};
+
+// src/errors/classes/WooCommerceApiError.ts
+var WooCommerceApiError = class extends BaseError {
+  constructor(options) {
+    const metadata = WOOCOMMERCE_ERROR_METADATA[options.code] ?? {
+      operation: "woocommerce_api_request",
+      retryable: false
+    };
+    const enrichedOptions = {
+      ...options,
+      operation: options.operation || metadata.operation,
+      userMessage: options.userMessage || metadata.userMessage,
+      retryable: options.retryable ?? metadata.retryable
+    };
+    super(enrichedOptions);
+  }
+  // Convenient getters for frequently accessed fields (no duplication)
+  get wooCode() {
+    return this.options.code;
+  }
+  get originalCode() {
+    return this.options.originalCode;
+  }
+  get statusCode() {
+    return this.options.statusCode;
+  }
+  get url() {
+    return this.options.url;
+  }
+  get method() {
+    return this.options.method;
+  }
+  get requestBody() {
+    return this.options.requestBody;
+  }
+  get responseBody() {
+    return this.options.responseBody;
+  }
+  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
+    };
+  }
+};
+
+// src/errors/classes/WooCommerceDataValidationError.ts
+var WooCommerceDataValidationError = class _WooCommerceDataValidationError extends BaseError {
+  constructor(options) {
+    const fieldErrors = options.zodError ? _WooCommerceDataValidationError.extractFieldErrorsFromZod(options.zodError) : void 0;
+    super({
+      code: "validation_error",
+      message: options.message,
+      operation: options.operation,
+      userMessage: options.userMessage || "Received unexpected data from WooCommerce",
+      retryable: false,
+      cause: options.cause,
+      url: options.url,
+      zodError: options.zodError,
+      value: options.value,
+      fieldErrors
+    });
+  }
+  // Convenient getters for validation-specific fields (no duplication)
+  get url() {
+    return this.options.url;
+  }
+  get zodError() {
+    return this.options.zodError;
+  }
+  get invalidValue() {
+    return this.options.value;
+  }
+  get fieldErrors() {
+    return this.options.fieldErrors;
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Includes validation-specific fields
+   */
+  getReportableData() {
+    return {
+      code: this.options.code,
+      operation: this.options.operation,
+      userMessage: this.options.userMessage,
+      retryable: false,
+      fieldErrors: this.options.fieldErrors,
+      url: this.options.url
+    };
+  }
+  /**
+   * Extract field errors from Zod error
+   */
+  static extractFieldErrorsFromZod(zodError) {
+    if (!zodError?.errors) {
+      return void 0;
+    }
+    const fieldErrors = {};
+    for (const issue of zodError.errors) {
+      const path = issue.path.join(".");
+      if (!fieldErrors[path]) {
+        fieldErrors[path] = [];
+      }
+      fieldErrors[path].push(issue.message);
+    }
+    return fieldErrors;
+  }
+  /**
+   * Get all error messages as a flat array
+   */
+  getMessages() {
+    if (!this.fieldErrors) {
+      return [this.message];
+    }
+    const messages = [];
+    for (const fieldMessages of Object.values(this.fieldErrors)) {
+      messages.push(...fieldMessages);
+    }
+    return messages;
+  }
+  /**
+   * Check if a specific field has errors
+   */
+  hasFieldError(field) {
+    return this.fieldErrors ? field in this.fieldErrors : false;
+  }
+  /**
+   * Get error messages for a specific field
+   */
+  getFieldError(field) {
+    return this.fieldErrors?.[field];
+  }
+};
+
+// src/http/handleApiResponse.ts
+var handleApiResponse = (response, schema, options) => {
+  const validationMode = options?.validationMode ?? "strict";
+  if (validationMode === "warn") {
+    const result = schema.safeParse(response.data);
+    if (!result.success) {
+      const validationError = new WooCommerceDataValidationError({
+        message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: result.error,
+        value: response.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 result.data;
+  }
+  try {
+    return schema.parse(response.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,
+        zodError: error2,
+        value: response.data,
+        userMessage: "Received unexpected data from WooCommerce"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      throw validationError;
+    }
+    throw error2;
+  }
+};
+var isZodError = (error2) => {
+  return error2 instanceof Error && error2.name === "ZodError";
+};
+
+// src/utils/calculatePagination.ts
+var calculatePagination = (input) => {
+  const { page, perPage, total, totalPages } = input;
+  const hasNextPage = page < totalPages;
+  const hasPrevPage = page > 1;
+  return {
+    page,
+    perPage,
+    total,
+    totalPages,
+    hasNextPage,
+    hasPrevPage,
+    nextPage: hasNextPage ? page + 1 : null,
+    prevPage: hasPrevPage ? page - 1 : null
+  };
+};
+
+// src/utils/getPaginationMeta.ts
+var getPaginationMeta = (headers) => {
+  if (!headers) {
+    return {
+      total: 0,
+      totalPages: 0
+    };
+  }
+  const wpTotal = headers["x-wp-total"];
+  const wpTotalPages = headers["x-wp-totalpages"];
+  if (!wpTotal || !wpTotalPages) {
+    return {
+      total: 0,
+      totalPages: 0
+    };
+  }
+  const total = parseInt(wpTotal, 10);
+  const totalPages = parseInt(wpTotalPages, 10);
+  return {
+    total,
+    totalPages
+  };
+};
+
+// src/http/handlePaginatedApiResponse.ts
+var handlePaginatedApiResponse = (response, schema, params = {}, options) => {
+  const validationMode = options?.validationMode ?? "strict";
+  let data;
+  if (validationMode === "warn") {
+    const result = schema.safeParse(response.data);
+    if (!result.success) {
+      const validationError = new WooCommerceDataValidationError({
+        message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: result.error,
+        value: response.data,
+        userMessage: "Received unexpected data from WooCommerce"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      console.warn("[woocommerce-utils] Validation warning:", validationError.message);
+      data = Array.isArray(response.data) ? response.data : [];
+    } else {
+      data = result.data;
+    }
+  } else {
+    try {
+      data = schema.parse(response.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,
+          zodError: error2,
+          value: response.data,
+          userMessage: "Received unexpected data from WooCommerce"
+        });
+        options?.onValidationError?.(validationError);
+        options?.errorReporter?.(validationError);
+        throw validationError;
+      }
+      throw error2;
+    }
+  }
+  const { total, totalPages } = getPaginationMeta(response.headers);
+  const page = params.page || 1;
+  const perPage = params.per_page || 10;
+  const pagination = calculatePagination({
+    page,
+    perPage,
+    total,
+    totalPages
+  });
+  return {
+    data,
+    pagination
+  };
+};
+
+// src/logging/logger.ts
+var DEBUG_PREFIX = "[woocommerce-utils]";
+var isDebugEnabled = () => {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.DEBUG === "true" || process.env.DEBUG === "1";
+  }
+  return false;
+};
+var debug = (...args) => {
+  if (isDebugEnabled()) {
+    console.log(DEBUG_PREFIX, ...args);
+  }
+};
+var error = (...args) => {
+  console.error(DEBUG_PREFIX, ...args);
+};
+
+// src/http/interceptors/request.ts
+var requiresAuth = (url) => {
+  if (!url) return false;
+  const authEndpoints = ["/jwt-auth/", "/customers/me", "/wp/v2/users/me"];
+  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 (requiresAuth(url) && config.jwtToken) {
+        const token = await config.jwtToken.get();
+        if (token) {
+          requestConfig.headers.Authorization = `Bearer ${token}`;
+          if (config.debug) {
+            debug("Injected JWT token for", url);
+          }
+        }
+      }
+      if (requiresCartAuth(url)) {
+        const headers = await config.cartHeaders.get();
+        if (headers.nonce) {
+          requestConfig.headers.Nonce = headers.nonce;
+        }
+        if (headers.cartToken) {
+          requestConfig.headers["Cart-Token"] = headers.cartToken;
+        }
+        requestConfig.headers["Cache-Control"] = "no-cache, no-store, must-revalidate";
+        requestConfig.headers.Pragma = "no-cache";
+        requestConfig.headers.Expires = "0";
+        if (config.debug) {
+          debug("Injected cart headers for", url, {
+            hasNonce: !!headers.nonce,
+            hasCartToken: !!headers.cartToken
+          });
+        }
+      }
+      if (config.debug) {
+        debug(
+          `${requestConfig.method?.toUpperCase()} ${requestConfig.url}`,
+          requestConfig.params || requestConfig.data
+        );
+      }
+      if (config.onRequest) {
+        return config.onRequest(requestConfig, client);
+      }
+      return requestConfig;
+    },
+    (error2) => {
+      return Promise.reject(error2);
+    }
+  );
+};
+
+// 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 setupResponseInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.response.use(
+    async (response) => {
+      if (isCartResponse(response.config.url)) {
+        const nonce = response.headers["nonce"] || response.headers["Nonce"];
+        const cartToken = response.headers["cart-token"] || response.headers["Cart-Token"];
+        if (nonce || cartToken) {
+          await config.cartHeaders.save({
+            nonce: nonce || void 0,
+            cartToken: cartToken || void 0
+          });
+          if (config.debug) {
+            debug(
+              "Saved updated cart headers:",
+              response.config.url,
+              "nonce:",
+              !!nonce,
+              "cartToken:",
+              !!cartToken
+            );
+          }
+        }
+      }
+      if (config.debug) {
+        debug("Response:", response.config.url, response.status);
+      }
+      if (config.onResponse) {
+        return config.onResponse(response, client);
+      }
+      return response;
+    },
+    (error2) => {
+      return Promise.reject(error2);
+    }
+  );
+};
+
+// src/utils/initializeCartSession.ts
+var initializeCartSession = async (client, cartHeaders) => {
+  try {
+    debug("session", "Initializing cart session");
+    const response = await client.get("/wc/store/v1/cart");
+    const nonce = response.headers["nonce"] || response.headers["Nonce"];
+    const cartToken = response.headers["cart-token"] || response.headers["Cart-Token"];
+    if (nonce || cartToken) {
+      await cartHeaders.save({
+        nonce: nonce || void 0,
+        cartToken: cartToken || void 0
+      });
+      debug("session", "Cart session initialized", {
+        hasNonce: !!nonce,
+        hasCartToken: !!cartToken
+      });
+    }
+  } catch (error2) {
+    debug("session", "Failed to initialize cart session", error2);
+    throw error2;
+  }
+};
+
+// src/http/interceptors/error.ts
+var setupErrorInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.response.use(
+    (response) => response,
+    async (axiosError) => {
+      const status = axiosError.response?.status || 500;
+      const errorData = axiosError.response?.data;
+      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 wcError = new WooCommerceApiError({
+        message: wpMessage,
+        statusCode: status,
+        code: errorCode,
+        // 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,
+        responseBody: errorData,
+        data: errorData?.data,
+        cause: axiosError
+      });
+      if (config.debug) {
+        debug("WooCommerce error:", apiCode, status, wpMessage);
+        error(wcError);
+      }
+      if ((status === 401 || status === 403) && config.onAuthError && axios.isAxiosError(axiosError) && !axiosError.config?._retry) {
+        if (config.debug) {
+          debug("Auth error detected, calling onAuthError handler");
+        }
+        try {
+          const shouldRetry = await config.onAuthError(wcError, client);
+          if (shouldRetry) {
+            if (config.debug) {
+              debug("Retrying request after auth error");
+            }
+            axiosError.config._retry = true;
+            return axiosInstance.request(axiosError.config);
+          }
+        } catch (authErrorHandlerError) {
+          if (config.debug) {
+            debug("onAuthError handler threw error", authErrorHandlerError);
+          }
+        }
+      }
+      if (config.onError) {
+        config.onError(wcError, client);
+      }
+      const isNonceError = errorCode === "missing_nonce" || errorCode === "invalid_nonce";
+      if (isNonceError && axios.isAxiosError(axiosError) && !axiosError.config?._retry) {
+        if (config.debug) {
+          debug("Nonce error detected, retrying with new session");
+        }
+        try {
+          await initializeCartSession(axiosInstance, config.cartHeaders);
+          axiosError.config._retry = true;
+          return axiosInstance.request(axiosError.config);
+        } catch (_retryError) {
+          config.errorReporter?.report(wcError);
+          return Promise.reject(wcError);
+        }
+      }
+      config.errorReporter?.report(wcError);
+      return Promise.reject(wcError);
+    }
+  );
+};
+
+exports.handleApiResponse = handleApiResponse;
+exports.handlePaginatedApiResponse = handlePaginatedApiResponse;
+exports.isZodError = isZodError;
+exports.setupErrorInterceptor = setupErrorInterceptor;
+exports.setupRequestInterceptor = setupRequestInterceptor;
+exports.setupResponseInterceptor = setupResponseInterceptor;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map