@szymonpiatek/nextwordpress 0.0.7 → 0.0.9

package/dist/index.cjs

@@ -9,10 +9,96 @@ function resolveBaseUrl(config) {
   return typeof window === "undefined" ? config.serverURL : config.clientURL;
 }
 
+// src/shared/errors/codes.ts
+var ErrorCode = {
+  // WordPress REST API
+  WP_REQUEST_FAILED: "WP_REQUEST_FAILED",
+  WP_NOT_FOUND: "WP_NOT_FOUND",
+  WP_UNAUTHORIZED: "WP_UNAUTHORIZED",
+  WP_FORBIDDEN: "WP_FORBIDDEN",
+  // WPGraphQL
+  GQL_REQUEST_FAILED: "GQL_REQUEST_FAILED",
+  GQL_NO_DATA: "GQL_NO_DATA",
+  GQL_ERRORS_IN_RESPONSE: "GQL_ERRORS_IN_RESPONSE",
+  // WooCommerce — generic
+  WOO_REQUEST_FAILED: "WOO_REQUEST_FAILED",
+  WOO_NOT_FOUND: "WOO_NOT_FOUND",
+  WOO_UNAUTHORIZED: "WOO_UNAUTHORIZED",
+  WOO_FORBIDDEN: "WOO_FORBIDDEN",
+  // WooCommerce — resource-specific
+  WOO_COUPON_NOT_FOUND: "WOO_COUPON_NOT_FOUND",
+  WOO_PRODUCT_NOT_FOUND: "WOO_PRODUCT_NOT_FOUND",
+  WOO_ORDER_NOT_FOUND: "WOO_ORDER_NOT_FOUND",
+  WOO_CUSTOMER_NOT_FOUND: "WOO_CUSTOMER_NOT_FOUND",
+  WOO_CATEGORY_NOT_FOUND: "WOO_CATEGORY_NOT_FOUND",
+  WOO_TAG_NOT_FOUND: "WOO_TAG_NOT_FOUND",
+  WOO_REVIEW_NOT_FOUND: "WOO_REVIEW_NOT_FOUND",
+  WOO_WEBHOOK_NOT_FOUND: "WOO_WEBHOOK_NOT_FOUND",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "WOO_SHIPPING_ZONE_NOT_FOUND",
+  // Auth
+  AUTH_JWT_FAILED: "AUTH_JWT_FAILED",
+  AUTH_CREDENTIALS_INVALID: "AUTH_CREDENTIALS_INVALID",
+  AUTH_TOKEN_INVALID: "AUTH_TOKEN_INVALID"
+};
+var defaultMessages = {
+  WP_REQUEST_FAILED: "WordPress API request failed",
+  WP_NOT_FOUND: "WordPress resource not found",
+  WP_UNAUTHORIZED: "WordPress authentication required",
+  WP_FORBIDDEN: "WordPress access denied",
+  GQL_REQUEST_FAILED: "WPGraphQL request failed",
+  GQL_NO_DATA: "No data returned from WPGraphQL",
+  GQL_ERRORS_IN_RESPONSE: "WPGraphQL returned errors",
+  WOO_REQUEST_FAILED: "WooCommerce API request failed",
+  WOO_NOT_FOUND: "WooCommerce resource not found",
+  WOO_UNAUTHORIZED: "WooCommerce authentication required",
+  WOO_FORBIDDEN: "WooCommerce access denied",
+  WOO_COUPON_NOT_FOUND: "Coupon not found",
+  WOO_PRODUCT_NOT_FOUND: "Product not found",
+  WOO_ORDER_NOT_FOUND: "Order not found",
+  WOO_CUSTOMER_NOT_FOUND: "Customer not found",
+  WOO_CATEGORY_NOT_FOUND: "Category not found",
+  WOO_TAG_NOT_FOUND: "Tag not found",
+  WOO_REVIEW_NOT_FOUND: "Product review not found",
+  WOO_WEBHOOK_NOT_FOUND: "Webhook not found",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "Shipping zone not found",
+  AUTH_JWT_FAILED: "JWT authentication failed",
+  AUTH_CREDENTIALS_INVALID: "Invalid credentials",
+  AUTH_TOKEN_INVALID: "JWT token is invalid or expired"
+};
+var defaultMessagesPl = {
+  WP_REQUEST_FAILED: "B\u0142\u0105d \u017C\u0105dania do WordPress API",
+  WP_NOT_FOUND: "Zas\xF3b WordPress nie istnieje",
+  WP_UNAUTHORIZED: "Wymagane uwierzytelnienie WordPress",
+  WP_FORBIDDEN: "Brak dost\u0119pu do zasobu WordPress",
+  GQL_REQUEST_FAILED: "B\u0142\u0105d \u017C\u0105dania WPGraphQL",
+  GQL_NO_DATA: "WPGraphQL nie zwr\xF3ci\u0142o danych",
+  GQL_ERRORS_IN_RESPONSE: "WPGraphQL zwr\xF3ci\u0142o b\u0142\u0119dy",
+  WOO_REQUEST_FAILED: "B\u0142\u0105d \u017C\u0105dania do WooCommerce API",
+  WOO_NOT_FOUND: "Zas\xF3b WooCommerce nie istnieje",
+  WOO_UNAUTHORIZED: "Wymagane uwierzytelnienie WooCommerce",
+  WOO_FORBIDDEN: "Brak dost\u0119pu do zasobu WooCommerce",
+  WOO_COUPON_NOT_FOUND: "Kupon nie istnieje",
+  WOO_PRODUCT_NOT_FOUND: "Produkt nie istnieje",
+  WOO_ORDER_NOT_FOUND: "Zam\xF3wienie nie istnieje",
+  WOO_CUSTOMER_NOT_FOUND: "Klient nie istnieje",
+  WOO_CATEGORY_NOT_FOUND: "Kategoria produkt\xF3w nie istnieje",
+  WOO_TAG_NOT_FOUND: "Tag produkt\xF3w nie istnieje",
+  WOO_REVIEW_NOT_FOUND: "Opinia o produkcie nie istnieje",
+  WOO_WEBHOOK_NOT_FOUND: "Webhook nie istnieje",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "Strefa wysy\u0142ki nie istnieje",
+  AUTH_JWT_FAILED: "B\u0142\u0105d uwierzytelnienia JWT",
+  AUTH_CREDENTIALS_INVALID: "Nieprawid\u0142owe dane logowania",
+  AUTH_TOKEN_INVALID: "Token JWT jest nieprawid\u0142owy lub wygas\u0142"
+};
+function resolveMessage(code, overrides) {
+  return overrides?.[code] ?? defaultMessages[code];
+}
+
 // src/integrations/restApi/core/client/types.ts
 var WordPressAPIError = class extends Error {
-  constructor(message, status, endpoint) {
-    super(message);
+  constructor(code, status, endpoint, message, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
     __publicField(this, "status", status);
     __publicField(this, "endpoint", endpoint);
     this.name = "WordPressAPIError";
@@ -35,19 +121,28 @@ function buildUrl(config, path, query) {
 
 // src/integrations/restApi/core/client/fetcher.ts
 var USER_AGENT = "NextWordpress Client";
-async function doFetch(url, init = {}) {
-  const response = await fetch(url, init);
-  if (!response.ok) {
-    throw new WordPressAPIError(
-      `WordPress API request failed: ${response.statusText}`,
-      response.status,
-      url
-    );
-  }
-  return response;
+function resolveWpErrorCode(status) {
+  if (status === 401) return ErrorCode.WP_UNAUTHORIZED;
+  if (status === 403) return ErrorCode.WP_FORBIDDEN;
+  if (status === 404) return ErrorCode.WP_NOT_FOUND;
+  return ErrorCode.WP_REQUEST_FAILED;
 }
 function createFetcher(config) {
   const cacheTtl = config.cacheTTL ?? 300;
+  async function doFetch(url, init = {}) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const code = resolveWpErrorCode(response.status);
+      throw new WordPressAPIError(
+        code,
+        response.status,
+        url,
+        resolveMessage(code, config.errorMessages),
+        response.statusText
+      );
+    }
+    return response;
+  }
   async function wpFetch(path, query, tags = ["wordpress"]) {
     const url = buildUrl(config, path, query);
     const res = await doFetch(url, {
@@ -94,7 +189,7 @@ function createFetcher(config) {
       "User-Agent": USER_AGENT
     };
     if (authToken) {
-      headers["Authorization"] = authToken;
+      headers["Authorization"] = `Bearer ${authToken}`;
     }
     const res = await doFetch(url, {
       method,
@@ -112,7 +207,7 @@ function createFetcher(config) {
         "Content-Disposition": `attachment; filename="${filename}"`,
         "Content-Type": mimeType,
         "User-Agent": USER_AGENT,
-        "Authorization": authToken
+        "Authorization": `Bearer ${authToken}`
       },
       body: file,
       cache: "no-store"
@@ -140,14 +235,14 @@ function createCF7Queries(config) {
 function createPostsMutations(fetcher) {
   const { wpMutate } = fetcher;
   async function createPost(input, authToken) {
-    return wpMutate("/wp/v2/posts", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/posts", input, "POST", authToken);
   }
   async function updatePost(id, input, authToken) {
-    return wpMutate(`/wp/v2/posts/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/posts/${id}`, input, "PATCH", authToken);
   }
   async function deletePost(id, authToken, force = false) {
     return wpMutate(
-      `/wp/v2/posts/${id}`,
+      `/wp-json/wp/v2/posts/${id}`,
       { force },
       "DELETE",
       authToken
@@ -160,14 +255,14 @@ function createPostsMutations(fetcher) {
 function createCommentsMutations(fetcher) {
   const { wpMutate } = fetcher;
   async function createComment(input, authToken) {
-    return wpMutate("/wp/v2/comments", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/comments", input, "POST", authToken);
   }
   async function updateComment(id, input, authToken) {
-    return wpMutate(`/wp/v2/comments/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/comments/${id}`, input, "PATCH", authToken);
   }
   async function deleteComment(id, authToken, force = false) {
     return wpMutate(
-      `/wp/v2/comments/${id}`,
+      `/wp-json/wp/v2/comments/${id}`,
       { force },
       "DELETE",
       authToken
@@ -180,14 +275,14 @@ function createCommentsMutations(fetcher) {
 function createPagesMutations(fetcher) {
   const { wpMutate } = fetcher;
   async function createPage(input, authToken) {
-    return wpMutate("/wp/v2/pages", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/pages", input, "POST", authToken);
   }
   async function updatePage(id, input, authToken) {
-    return wpMutate(`/wp/v2/pages/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/pages/${id}`, input, "PATCH", authToken);
   }
   async function deletePage(id, authToken, force = false) {
     return wpMutate(
-      `/wp/v2/pages/${id}`,
+      `/wp-json/wp/v2/pages/${id}`,
       { force },
       "DELETE",
       authToken
@@ -200,14 +295,14 @@ function createPagesMutations(fetcher) {
 function createCategoriesMutations(fetcher) {
   const { wpMutate } = fetcher;
   async function createCategory(input, authToken) {
-    return wpMutate("/wp/v2/categories", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/categories", input, "POST", authToken);
   }
   async function updateCategory(id, input, authToken) {
-    return wpMutate(`/wp/v2/categories/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/categories/${id}`, input, "PATCH", authToken);
   }
   async function deleteCategory(id, authToken, force = false) {
     return wpMutate(
-      `/wp/v2/categories/${id}`,
+      `/wp-json/wp/v2/categories/${id}`,
       { force },
       "DELETE",
       authToken
@@ -220,14 +315,14 @@ function createCategoriesMutations(fetcher) {
 function createTagsMutations(fetcher) {
   const { wpMutate } = fetcher;
   async function createTag(input, authToken) {
-    return wpMutate("/wp/v2/tags", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/tags", input, "POST", authToken);
   }
   async function updateTag(id, input, authToken) {
-    return wpMutate(`/wp/v2/tags/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/tags/${id}`, input, "PATCH", authToken);
   }
   async function deleteTag(id, authToken, force = false) {
     return wpMutate(
-      `/wp/v2/tags/${id}`,
+      `/wp-json/wp/v2/tags/${id}`,
       { force },
       "DELETE",
       authToken
@@ -240,14 +335,14 @@ function createTagsMutations(fetcher) {
 function createAuthorsMutations(fetcher) {
   const { wpMutate } = fetcher;
   async function createAuthor(input, authToken) {
-    return wpMutate("/wp/v2/users", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/users", input, "POST", authToken);
   }
   async function updateAuthor(id, input, authToken) {
-    return wpMutate(`/wp/v2/users/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/users/${id}`, input, "PATCH", authToken);
   }
   async function deleteAuthor(id, authToken, reassign) {
     return wpMutate(
-      `/wp/v2/users/${id}`,
+      `/wp-json/wp/v2/users/${id}`,
       { force: true, reassign },
       "DELETE",
       authToken
@@ -260,28 +355,28 @@ function createAuthorsMutations(fetcher) {
 function createMenusMutations(fetcher) {
   const { wpMutate } = fetcher;
   async function createMenu(input, authToken) {
-    return wpMutate("/wp/v2/menus", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/menus", input, "POST", authToken);
   }
   async function updateMenu(id, input, authToken) {
-    return wpMutate(`/wp/v2/menus/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/menus/${id}`, input, "PATCH", authToken);
   }
   async function deleteMenu(id, authToken) {
     return wpMutate(
-      `/wp/v2/menus/${id}`,
+      `/wp-json/wp/v2/menus/${id}`,
       {},
       "DELETE",
       authToken
     );
   }
   async function createMenuItem(input, authToken) {
-    return wpMutate("/wp/v2/menu-items", input, "POST", authToken);
+    return wpMutate("/wp-json/wp/v2/menu-items", input, "POST", authToken);
   }
   async function updateMenuItem(id, input, authToken) {
-    return wpMutate(`/wp/v2/menu-items/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/menu-items/${id}`, input, "PATCH", authToken);
   }
   async function deleteMenuItem(id, authToken, force = false) {
     return wpMutate(
-      `/wp/v2/menu-items/${id}`,
+      `/wp-json/wp/v2/menu-items/${id}`,
       { force },
       "DELETE",
       authToken
@@ -295,7 +390,7 @@ function createMediaMutations(fetcher) {
   const { wpMutate, wpUpload } = fetcher;
   async function uploadMedia(input, authToken) {
     const media = await wpUpload(
-      "/wp/v2/media",
+      "/wp-json/wp/v2/media",
       input.file,
       input.filename,
       input.mimeType,
@@ -303,7 +398,7 @@ function createMediaMutations(fetcher) {
     );
     if (input.title || input.caption || input.alt_text) {
       return wpMutate(
-        `/wp/v2/media/${media.id}`,
+        `/wp-json/wp/v2/media/${media.id}`,
         {
           ...input.title && { title: input.title },
           ...input.caption && { caption: input.caption },
@@ -316,11 +411,11 @@ function createMediaMutations(fetcher) {
     return media;
   }
   async function updateMedia(id, input, authToken) {
-    return wpMutate(`/wp/v2/media/${id}`, input, "PATCH", authToken);
+    return wpMutate(`/wp-json/wp/v2/media/${id}`, input, "PATCH", authToken);
   }
   async function deleteMedia(id, authToken, force = true) {
     return wpMutate(
-      `/wp/v2/media/${id}`,
+      `/wp-json/wp/v2/media/${id}`,
       { force },
       "DELETE",
       authToken
@@ -710,6 +805,42 @@ function withOmnibusVariation(variation) {
   };
 }
 
+// src/integrations/restApi/woocommerce/client/types.ts
+var WooCommerceError = class extends Error {
+  constructor(code, status, endpoint, message, upstreamCode, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
+    __publicField(this, "status", status);
+    __publicField(this, "endpoint", endpoint);
+    __publicField(this, "upstreamCode", upstreamCode);
+    this.name = "WooCommerceError";
+  }
+};
+
+// src/integrations/restApi/woocommerce/client/errorMap.ts
+var upstreamToErrorCode = {
+  woocommerce_rest_coupon_invalid_id: ErrorCode.WOO_COUPON_NOT_FOUND,
+  woocommerce_rest_product_invalid_id: ErrorCode.WOO_PRODUCT_NOT_FOUND,
+  woocommerce_rest_order_invalid_id: ErrorCode.WOO_ORDER_NOT_FOUND,
+  woocommerce_rest_customer_invalid_id: ErrorCode.WOO_CUSTOMER_NOT_FOUND,
+  woocommerce_rest_term_invalid: ErrorCode.WOO_CATEGORY_NOT_FOUND,
+  woocommerce_rest_review_invalid_id: ErrorCode.WOO_REVIEW_NOT_FOUND,
+  woocommerce_rest_webhook_invalid_id: ErrorCode.WOO_WEBHOOK_NOT_FOUND,
+  woocommerce_rest_shipping_zone_invalid_id: ErrorCode.WOO_SHIPPING_ZONE_NOT_FOUND
+};
+function resolveWooErrorCode(status, upstreamCode) {
+  if (status === 401) return ErrorCode.WOO_UNAUTHORIZED;
+  if (status === 403) return ErrorCode.WOO_FORBIDDEN;
+  if (status === 404) {
+    if (upstreamCode) {
+      const mapped = upstreamToErrorCode[upstreamCode];
+      if (mapped) return mapped;
+    }
+    return ErrorCode.WOO_NOT_FOUND;
+  }
+  return ErrorCode.WOO_REQUEST_FAILED;
+}
+
 // src/integrations/restApi/woocommerce/client/fetcher.ts
 var USER_AGENT2 = "NextWordpress WooCommerce Client";
 var DEFAULT_CACHE_TTL = 3600;
@@ -730,6 +861,18 @@ function createWooCommerceFetcher(config) {
     const base = typeof window !== "undefined" && config.clientURL ? config.clientURL : config.serverURL;
     return `${base}${path}?${toQueryString(withAuth(query))}`;
   }
+  async function throwWooError(response, url) {
+    const body = await response.json().catch(() => ({}));
+    const errorCode = resolveWooErrorCode(response.status, body.code);
+    throw new WooCommerceError(
+      errorCode,
+      response.status,
+      url,
+      resolveMessage(errorCode, config.errorMessages),
+      body.code,
+      body.message
+    );
+  }
   async function wcFetch(path, query, tags = ["woocommerce"], options) {
     const url = buildUrl2(path, query);
     const isMutation = options?.method && options.method !== "GET";
@@ -744,9 +887,7 @@ function createWooCommerceFetcher(config) {
       next: isMutation || noStore ? void 0 : { tags, revalidate: cacheTTL }
     });
     if (!response.ok) {
-      const body = await response.json().catch(() => ({}));
-      const detail = body.message ? ` \u2013 ${body.message}` : "";
-      throw new Error(`WooCommerce API ${response.status}: ${response.statusText}${detail} [${url}]`);
+      await throwWooError(response, url);
     }
     return response.json();
   }
@@ -765,7 +906,7 @@ function createWooCommerceFetcher(config) {
       next: { tags, revalidate: cacheTTL }
     });
     if (!response.ok) {
-      throw new Error(`WooCommerce API ${response.status}: ${response.statusText} [${url}]`);
+      await throwWooError(response, url);
     }
     return {
       data: await response.json(),
@@ -1962,8 +2103,9 @@ function createWooCommerceClient(config) {
 
 // src/integrations/wpGraphQL/client/types.ts
 var WPGraphQLError = class extends Error {
-  constructor(message, status, endpoint, gqlErrors) {
+  constructor(code, status, endpoint, message, gqlErrors) {
     super(message);
+    __publicField(this, "code", code);
     __publicField(this, "status", status);
     __publicField(this, "endpoint", endpoint);
     __publicField(this, "gqlErrors", gqlErrors);
@@ -1988,22 +2130,29 @@ function createWPGraphQLFetcher(config) {
     });
     if (!response.ok) {
       throw new WPGraphQLError(
-        `WPGraphQL request failed: ${response.statusText}`,
+        ErrorCode.GQL_REQUEST_FAILED,
         response.status,
-        url
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
       );
     }
     const parsed = await response.json();
     if (parsed.errors && parsed.errors.length > 0) {
       throw new WPGraphQLError(
-        parsed.errors[0].message,
+        ErrorCode.GQL_ERRORS_IN_RESPONSE,
         200,
         url,
+        resolveMessage(ErrorCode.GQL_ERRORS_IN_RESPONSE, config.errorMessages),
         parsed.errors
       );
     }
     if (parsed.data === void 0) {
-      throw new WPGraphQLError("No data returned from WPGraphQL", 200, url);
+      throw new WPGraphQLError(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
     }
     return parsed.data;
   }
@@ -2031,22 +2180,29 @@ function createWPGraphQLFetcher(config) {
     });
     if (!response.ok) {
       throw new WPGraphQLError(
-        `WPGraphQL mutation failed: ${response.statusText}`,
+        ErrorCode.GQL_REQUEST_FAILED,
         response.status,
-        url
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
       );
     }
     const parsed = await response.json();
     if (parsed.errors && parsed.errors.length > 0) {
       throw new WPGraphQLError(
-        parsed.errors[0].message,
+        ErrorCode.GQL_ERRORS_IN_RESPONSE,
         200,
         url,
+        resolveMessage(ErrorCode.GQL_ERRORS_IN_RESPONSE, config.errorMessages),
         parsed.errors
       );
     }
     if (parsed.data === void 0) {
-      throw new WPGraphQLError("No data returned from WPGraphQL mutation", 200, url);
+      throw new WPGraphQLError(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
     }
     return parsed.data;
   }
@@ -4029,14 +4185,20 @@ function createApplicationPasswordToken(username, appPassword) {
 
 // src/auth/types.ts
 var AuthenticationError = class extends Error {
-  constructor(message, status) {
-    super(message);
+  constructor(code, status, message, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
     __publicField(this, "status", status);
     this.name = "AuthenticationError";
   }
 };
 
 // src/auth/jwt.ts
+function resolveAuthErrorCode(status) {
+  if (status === 401) return ErrorCode.AUTH_CREDENTIALS_INVALID;
+  if (status === 403) return ErrorCode.AUTH_TOKEN_INVALID;
+  return ErrorCode.AUTH_JWT_FAILED;
+}
 async function authenticateJwt(config, credentials) {
   const url = `${resolveBaseUrl(config)}/wp-json/jwt-auth/v1/token`;
   const response = await fetch(url, {
@@ -4046,9 +4208,12 @@ async function authenticateJwt(config, credentials) {
     cache: "no-store"
   });
   if (!response.ok) {
+    const code = resolveAuthErrorCode(response.status);
     throw new AuthenticationError(
-      `JWT authentication failed: ${response.statusText}`,
-      response.status
+      code,
+      response.status,
+      resolveMessage(code, config.errorMessages),
+      response.statusText
     );
   }
   return response.json();
@@ -4064,7 +4229,10 @@ async function validateJwtToken(config, token) {
 }
 
 exports.AuthenticationError = AuthenticationError;
+exports.ErrorCode = ErrorCode;
 exports.WPGraphQLError = WPGraphQLError;
+exports.WooCommerceError = WooCommerceError;
+exports.WordPressAPIError = WordPressAPIError;
 exports.authenticateJwt = authenticateJwt;
 exports.buildACFFragment = buildACFFragment;
 exports.buildPageWithACFQuery = buildPageWithACFQuery;
@@ -4094,8 +4262,11 @@ exports.createWooCommerceFetcher = createWooCommerceFetcher;
 exports.createWordPressClient = createWordPressClient;
 exports.createWordPressMutationsClient = createWordPressMutationsClient;
 exports.createYoastQueries = createYoastQueries;
+exports.defaultMessages = defaultMessages;
+exports.defaultMessagesPl = defaultMessagesPl;
 exports.extractOmnibusData = extractOmnibusData;
 exports.resolveBaseUrl = resolveBaseUrl;
+exports.resolveMessage = resolveMessage;
 exports.validateJwtToken = validateJwtToken;
 exports.withOmnibus = withOmnibus;
 exports.withOmnibusVariation = withOmnibusVariation;