@szymonpiatek/nextwordpress 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -9,6 +9,199 @@ function resolveBaseUrl(config) {
   return typeof window === "undefined" ? config.serverURL : config.clientURL;
 }
 
+// src/integrations/restApi/core/mutations/posts/mutations.ts
+function createPostsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createPost(input, authToken) {
+    return wpMutate("/wp/v2/posts", input, "POST", authToken);
+  }
+  async function updatePost(id, input, authToken) {
+    return wpMutate(`/wp/v2/posts/${id}`, input, "PATCH", authToken);
+  }
+  async function deletePost(id, authToken, force = false) {
+    return wpMutate(
+      `/wp/v2/posts/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createPost, updatePost, deletePost };
+}
+
+// src/integrations/restApi/core/mutations/comments/mutations.ts
+function createCommentsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createComment(input, authToken) {
+    return wpMutate("/wp/v2/comments", input, "POST", authToken);
+  }
+  async function updateComment(id, input, authToken) {
+    return wpMutate(`/wp/v2/comments/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteComment(id, authToken, force = false) {
+    return wpMutate(
+      `/wp/v2/comments/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createComment, updateComment, deleteComment };
+}
+
+// src/integrations/restApi/core/mutations/pages/mutations.ts
+function createPagesMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createPage(input, authToken) {
+    return wpMutate("/wp/v2/pages", input, "POST", authToken);
+  }
+  async function updatePage(id, input, authToken) {
+    return wpMutate(`/wp/v2/pages/${id}`, input, "PATCH", authToken);
+  }
+  async function deletePage(id, authToken, force = false) {
+    return wpMutate(
+      `/wp/v2/pages/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createPage, updatePage, deletePage };
+}
+
+// src/integrations/restApi/core/mutations/categories/mutations.ts
+function createCategoriesMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createCategory(input, authToken) {
+    return wpMutate("/wp/v2/categories", input, "POST", authToken);
+  }
+  async function updateCategory(id, input, authToken) {
+    return wpMutate(`/wp/v2/categories/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteCategory(id, authToken, force = false) {
+    return wpMutate(
+      `/wp/v2/categories/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createCategory, updateCategory, deleteCategory };
+}
+
+// src/integrations/restApi/core/mutations/tags/mutations.ts
+function createTagsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createTag(input, authToken) {
+    return wpMutate("/wp/v2/tags", input, "POST", authToken);
+  }
+  async function updateTag(id, input, authToken) {
+    return wpMutate(`/wp/v2/tags/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteTag(id, authToken, force = false) {
+    return wpMutate(
+      `/wp/v2/tags/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createTag, updateTag, deleteTag };
+}
+
+// src/integrations/restApi/core/mutations/authors/mutations.ts
+function createAuthorsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createAuthor(input, authToken) {
+    return wpMutate("/wp/v2/users", input, "POST", authToken);
+  }
+  async function updateAuthor(id, input, authToken) {
+    return wpMutate(`/wp/v2/users/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteAuthor(id, authToken, reassign) {
+    return wpMutate(
+      `/wp/v2/users/${id}`,
+      { force: true, reassign },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createAuthor, updateAuthor, deleteAuthor };
+}
+
+// src/integrations/restApi/core/mutations/menus/mutations.ts
+function createMenusMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createMenu(input, authToken) {
+    return wpMutate("/wp/v2/menus", input, "POST", authToken);
+  }
+  async function updateMenu(id, input, authToken) {
+    return wpMutate(`/wp/v2/menus/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMenu(id, authToken) {
+    return wpMutate(
+      `/wp/v2/menus/${id}`,
+      {},
+      "DELETE",
+      authToken
+    );
+  }
+  async function createMenuItem(input, authToken) {
+    return wpMutate("/wp/v2/menu-items", input, "POST", authToken);
+  }
+  async function updateMenuItem(id, input, authToken) {
+    return wpMutate(`/wp/v2/menu-items/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMenuItem(id, authToken, force = false) {
+    return wpMutate(
+      `/wp/v2/menu-items/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createMenu, updateMenu, deleteMenu, createMenuItem, updateMenuItem, deleteMenuItem };
+}
+
+// src/integrations/restApi/core/mutations/media/mutations.ts
+function createMediaMutations(fetcher) {
+  const { wpMutate, wpUpload } = fetcher;
+  async function uploadMedia(input, authToken) {
+    const media = await wpUpload(
+      "/wp/v2/media",
+      input.file,
+      input.filename,
+      input.mimeType,
+      authToken
+    );
+    if (input.title || input.caption || input.alt_text) {
+      return wpMutate(
+        `/wp/v2/media/${media.id}`,
+        {
+          ...input.title && { title: input.title },
+          ...input.caption && { caption: input.caption },
+          ...input.alt_text && { alt_text: input.alt_text }
+        },
+        "PATCH",
+        authToken
+      );
+    }
+    return media;
+  }
+  async function updateMedia(id, input, authToken) {
+    return wpMutate(`/wp/v2/media/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMedia(id, authToken, force = true) {
+    return wpMutate(
+      `/wp/v2/media/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { uploadMedia, updateMedia, deleteMedia };
+}
+
 // src/integrations/restApi/core/client/types.ts
 var WordPressAPIError = class extends Error {
   constructor(message, status, endpoint) {
@@ -87,20 +280,54 @@ function createFetcher(config) {
       return empty;
     }
   }
-  async function wpMutate(path, body, method = "POST") {
+  async function wpMutate(path, body, method = "POST", authToken) {
     const url = buildUrl(config, path);
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT
+    };
+    if (authToken) {
+      headers["Authorization"] = authToken;
+    }
     const res = await doFetch(url, {
       method,
+      headers,
+      body: JSON.stringify(body),
+      cache: "no-store"
+    });
+    return await res.json();
+  }
+  async function wpUpload(path, file, filename, mimeType, authToken) {
+    const url = buildUrl(config, path);
+    const res = await doFetch(url, {
+      method: "POST",
       headers: {
-        "Content-Type": "application/json",
-        "User-Agent": USER_AGENT
+        "Content-Disposition": `attachment; filename="${filename}"`,
+        "Content-Type": mimeType,
+        "User-Agent": USER_AGENT,
+        "Authorization": authToken
       },
-      body: JSON.stringify(body),
+      body: file,
       cache: "no-store"
     });
     return await res.json();
   }
-  return { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful, wpMutate };
+  return { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful, wpMutate, wpUpload };
+}
+
+// src/integrations/restApi/core/mutations/index.ts
+function createWordPressMutationsClient(config) {
+  const fetcher = createFetcher(config);
+  return {
+    ...createPostsMutations(fetcher),
+    ...createCommentsMutations(fetcher),
+    ...createPagesMutations(fetcher),
+    ...createCategoriesMutations(fetcher),
+    ...createTagsMutations(fetcher),
+    ...createAuthorsMutations(fetcher),
+    ...createMenusMutations(fetcher),
+    ...createMediaMutations(fetcher)
+  };
 }
 
 // src/integrations/restApi/core/posts/queries.ts
@@ -331,6 +558,100 @@ function createPagesQueries(fetcher) {
   return { getAllPages, getPageById, getPageBySlug };
 }
 
+// src/integrations/restApi/core/menus/queries.ts
+function createMenusQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getMenus() {
+    return wpFetchGraceful("/wp-json/wp/v2/menus", [], void 0, ["wordpress", "menus"]);
+  }
+  async function getMenuById(id) {
+    return wpFetch(`/wp-json/wp/v2/menus/${id}`, void 0, ["wordpress", "menus", `menu-${id}`]);
+  }
+  async function getMenuBySlug(slug) {
+    const menus = await wpFetchGraceful("/wp-json/wp/v2/menus", [], { slug }, ["wordpress", "menus"]);
+    return menus[0];
+  }
+  async function getMenuItemsByMenuId(menuId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/menu-items",
+      [],
+      { menus: menuId, per_page: 100, orderby: "menu_order", order: "asc" },
+      ["wordpress", "menus", `menu-items-${menuId}`]
+    );
+  }
+  async function getMenuLocations() {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/menu-locations",
+      {},
+      void 0,
+      ["wordpress", "menus", "menu-locations"]
+    );
+  }
+  async function getMenuByLocation(location) {
+    const locations = await getMenuLocations();
+    const loc = locations[location];
+    if (!loc || !loc.menu) return void 0;
+    const [menu, items] = await Promise.all([
+      getMenuById(loc.menu),
+      getMenuItemsByMenuId(loc.menu)
+    ]);
+    return { menu, items };
+  }
+  return {
+    getMenus,
+    getMenuById,
+    getMenuBySlug,
+    getMenuItemsByMenuId,
+    getMenuLocations,
+    getMenuByLocation
+  };
+}
+
+// src/integrations/restApi/core/comments/queries.ts
+function createCommentsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful, wpFetchPaginatedGraceful, wpMutate } = fetcher;
+  async function getCommentsByPostId(postId, page = 1, perPage = 10) {
+    return wpFetchPaginatedGraceful(
+      "/wp-json/wp/v2/comments",
+      { post: postId, per_page: perPage, page, status: "approve" },
+      ["wordpress", "comments", `comments-post-${postId}`]
+    );
+  }
+  async function getAllCommentsByPostId(postId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/comments",
+      [],
+      { post: postId, per_page: 100, status: "approve" },
+      ["wordpress", "comments", `comments-post-${postId}`]
+    );
+  }
+  async function getCommentById(id) {
+    return wpFetch(`/wp-json/wp/v2/comments/${id}`, void 0, [
+      "wordpress",
+      "comments",
+      `comment-${id}`
+    ]);
+  }
+  async function getCommentReplies(parentId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/comments",
+      [],
+      { parent: parentId, per_page: 100, status: "approve" },
+      ["wordpress", "comments", `comments-parent-${parentId}`]
+    );
+  }
+  async function createComment(input) {
+    return wpMutate("/wp-json/wp/v2/comments", input, "POST");
+  }
+  return {
+    getCommentsByPostId,
+    getAllCommentsByPostId,
+    getCommentById,
+    getCommentReplies,
+    createComment
+  };
+}
+
 // src/integrations/restApi/core/index.ts
 function createWordPressClient(config) {
   const fetcher = createFetcher(config);
@@ -340,7 +661,9 @@ function createWordPressClient(config) {
     ...createTagsQueries(fetcher),
     ...createAuthorsQueries(fetcher),
     ...createMediaQueries(fetcher),
-    ...createPagesQueries(fetcher)
+    ...createPagesQueries(fetcher),
+    ...createMenusQueries(fetcher),
+    ...createCommentsQueries(fetcher)
   };
 }
 
@@ -582,6 +905,25 @@ function createProductsQueries(fetcher) {
   };
 }
 
+// src/integrations/restApi/woocommerce/products/mutations.ts
+function createProductsMutations(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createProduct(input) {
+    return wcMutate("/wp-json/wc/v3/products", input, "POST");
+  }
+  async function updateProduct(id, input) {
+    return wcMutate(`/wp-json/wc/v3/products/${id}`, input, "PUT");
+  }
+  async function deleteProduct(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createProduct, updateProduct, deleteProduct };
+}
+
 // src/integrations/restApi/woocommerce/categories/queries.ts
 function createCategoriesQueries2(fetcher) {
   const { wcFetch, wcFetchGraceful } = fetcher;
@@ -631,6 +973,29 @@ function createCategoriesQueries2(fetcher) {
   };
 }
 
+// src/integrations/restApi/woocommerce/categories/mutations.ts
+function createCategoriesMutations2(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createProductCategory(input) {
+    return wcMutate("/wp-json/wc/v3/products/categories", input, "POST");
+  }
+  async function updateProductCategory(id, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/categories/${id}`,
+      input,
+      "PUT"
+    );
+  }
+  async function deleteProductCategory(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/categories/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createProductCategory, updateProductCategory, deleteProductCategory };
+}
+
 // src/integrations/restApi/woocommerce/tags/queries.ts
 function createTagsQueries2(fetcher) {
   const { wcFetch, wcFetchGraceful } = fetcher;
@@ -664,6 +1029,25 @@ function createTagsQueries2(fetcher) {
   };
 }
 
+// src/integrations/restApi/woocommerce/tags/mutations.ts
+function createTagsMutations2(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createProductTag(input) {
+    return wcMutate("/wp-json/wc/v3/products/tags", input, "POST");
+  }
+  async function updateProductTag(id, input) {
+    return wcMutate(`/wp-json/wc/v3/products/tags/${id}`, input, "PUT");
+  }
+  async function deleteProductTag(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/tags/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createProductTag, updateProductTag, deleteProductTag };
+}
+
 // src/integrations/restApi/woocommerce/orders/queries.ts
 function createOrdersQueries(fetcher) {
   const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
@@ -688,11 +1072,19 @@ function createOrdersQueries(fetcher) {
       ["woocommerce", "orders", `orders-customer-${customerId}`]
     );
   }
+  async function deleteOrder(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
   return {
     createOrder,
     getOrderById,
     updateOrder,
-    getOrdersByCustomer
+    getOrdersByCustomer,
+    deleteOrder
   };
 }
 
@@ -726,9 +1118,28 @@ function createCouponsQueries(fetcher) {
   };
 }
 
+// src/integrations/restApi/woocommerce/coupons/mutations.ts
+function createCouponsMutations(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createCoupon(input) {
+    return wcMutate("/wp-json/wc/v3/coupons", input, "POST");
+  }
+  async function updateCoupon(id, input) {
+    return wcMutate(`/wp-json/wc/v3/coupons/${id}`, input, "PUT");
+  }
+  async function deleteCoupon(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/coupons/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createCoupon, updateCoupon, deleteCoupon };
+}
+
 // src/integrations/restApi/woocommerce/customers/queries.ts
 function createCustomersQueries(fetcher) {
-  const { wcFetch, wcFetchGraceful } = fetcher;
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
   async function getCustomerById(id) {
     return wcFetch(`/wp-json/wc/v3/customers/${id}`, void 0, [
       "woocommerce",
@@ -766,11 +1177,23 @@ function createCustomersQueries(fetcher) {
       { method: "POST", body: JSON.stringify(data) }
     );
   }
+  async function updateCustomer(id, data) {
+    return wcMutate(`/wp-json/wc/v3/customers/${id}`, data, "PUT");
+  }
+  async function deleteCustomer(id, reassign) {
+    return wcMutate(
+      `/wp-json/wc/v3/customers/${id}`,
+      { force: true, ...reassign !== void 0 && { reassign } },
+      "DELETE"
+    );
+  }
   return {
     getCustomerById,
     getCustomerByEmail,
     getCustomerByEmailNoCache,
-    createCustomer
+    createCustomer,
+    updateCustomer,
+    deleteCustomer
   };
 }
 
@@ -779,10 +1202,14 @@ function createWooCommerceClient(config) {
   const fetcher = createWooCommerceFetcher(config);
   return {
     ...createProductsQueries(fetcher),
+    ...createProductsMutations(fetcher),
     ...createCategoriesQueries2(fetcher),
+    ...createCategoriesMutations2(fetcher),
     ...createTagsQueries2(fetcher),
+    ...createTagsMutations2(fetcher),
     ...createOrdersQueries(fetcher),
     ...createCouponsQueries(fetcher),
+    ...createCouponsMutations(fetcher),
     ...createCustomersQueries(fetcher)
   };
 }
@@ -842,7 +1269,42 @@ function createWPGraphQLFetcher(config) {
       return fallback;
     }
   }
-  return { gqlFetch, gqlFetchGraceful };
+  async function gqlMutate(document, variables, authToken) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT3
+    };
+    if (authToken) {
+      headers["Authorization"] = authToken;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: document, variables }),
+      cache: "no-store"
+    });
+    if (!response.ok) {
+      throw new WPGraphQLError(
+        `WPGraphQL mutation failed: ${response.statusText}`,
+        response.status,
+        url
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new WPGraphQLError(
+        parsed.errors[0].message,
+        200,
+        url,
+        parsed.errors
+      );
+    }
+    if (parsed.data === void 0) {
+      throw new WPGraphQLError("No data returned from WPGraphQL mutation", 200, url);
+    }
+    return parsed.data;
+  }
+  return { gqlFetch, gqlFetchGraceful, gqlMutate };
 }
 
 // src/integrations/wpGraphQL/core/posts/queries.ts
@@ -1262,136 +1724,839 @@ function createAuthorsQueries2(fetcher) {
   return { getAuthors, getAuthorBySlug };
 }
 
-// src/integrations/wpGraphQL/core/index.ts
-function createWPGraphQLCoreClient(config) {
-  const fetcher = createWPGraphQLFetcher(config);
-  return {
-    ...createPostsQueries2(fetcher),
-    ...createPagesQueries2(fetcher),
-    ...createCategoriesQueries3(fetcher),
-    ...createTagsQueries3(fetcher),
-    ...createAuthorsQueries2(fetcher)
-  };
-}
-
-// src/integrations/wpGraphQL/yoast/queries.ts
-var SEO_FIELDS = `
-  seo {
-    title
-    metaDesc
-    canonical
-    opengraphTitle
-    opengraphDescription
-    opengraphImage { sourceUrl altText }
-    twitterTitle
-    twitterDescription
-    twitterImage { sourceUrl }
-    schema { raw }
-  }
-`;
-var POST_FIELDS_WITH_SEO = `
+// src/integrations/wpGraphQL/core/menus/queries.ts
+var MENU_ITEM_FIELDS = `
   id
   databaseId
-  slug
-  title
-  content
-  excerpt
-  date
-  modified
-  status
-  uri
-  author {
-    node {
-      databaseId
-      name
-      slug
-      avatar { url }
-    }
-  }
-  featuredImage {
+  label
+  url
+  parentId
+  order
+  target
+  cssClasses
+  description
+  connectedNode {
     node {
-      sourceUrl
-      altText
-      mediaDetails { width height }
+      __typename
+      ... on Page { id databaseId slug }
+      ... on Post { id databaseId slug }
+      ... on Category { id databaseId slug }
+      ... on Tag { id databaseId slug }
     }
   }
-  categories {
-    nodes { databaseId name slug }
-  }
-  tags {
-    nodes { databaseId name slug }
-  }
-  ${SEO_FIELDS}
 `;
-var PAGE_FIELDS_WITH_SEO = `
+var MENU_FIELDS = `
   id
   databaseId
+  name
   slug
-  title
-  content
-  date
-  modified
-  status
-  uri
-  featuredImage {
-    node {
-      sourceUrl
-      altText
-      mediaDetails { width height }
+  locations
+  menuItems(first: 100) {
+    nodes { ${MENU_ITEM_FIELDS} }
+  }
+`;
+var GQL_GET_MENUS = `
+  query GetMenus {
+    menus(first: 100) {
+      nodes { ${MENU_FIELDS} }
     }
   }
-  ${SEO_FIELDS}
 `;
-var GQL_GET_POST_WITH_SEO = `
-  query GetPostWithSEO($slug: ID!) {
-    post(id: $slug, idType: SLUG) { ${POST_FIELDS_WITH_SEO} }
+var GQL_GET_MENU_BY_ID = `
+  query GetMenuById($id: ID!) {
+    menu(id: $id, idType: DATABASE_ID) { ${MENU_FIELDS} }
   }
 `;
-var GQL_GET_PAGE_WITH_SEO = `
-  query GetPageWithSEO($slug: ID!) {
-    page(id: $slug, idType: SLUG) { ${PAGE_FIELDS_WITH_SEO} }
+var GQL_GET_MENU_BY_SLUG = `
+  query GetMenuBySlug($id: ID!) {
+    menu(id: $id, idType: SLUG) { ${MENU_FIELDS} }
   }
 `;
-var GQL_GET_PAGE_WITH_SEO_BY_URI = `
-  query GetPageWithSEOByUri($uri: ID!) {
-    page(id: $uri, idType: URI) { ${PAGE_FIELDS_WITH_SEO} }
+var GQL_GET_MENUS_BY_LOCATION = `
+  query GetMenusByLocation($location: MenuLocationEnum!) {
+    menus(where: { location: $location }, first: 1) {
+      nodes { ${MENU_FIELDS} }
+    }
   }
 `;
-function createYoastQueries(fetcher) {
-  const { gqlFetchGraceful } = fetcher;
-  async function getPostWithSEO(slug) {
+function createMenusQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getMenus() {
     const data = await gqlFetchGraceful(
-      GQL_GET_POST_WITH_SEO,
-      { post: null },
-      { slug },
-      ["wpgraphql", "gql-posts", "gql-yoast", `gql-post-${slug}`]
+      GQL_GET_MENUS,
+      { menus: { nodes: [] } },
+      void 0,
+      ["wpgraphql", "gql-menus"]
     );
-    return data.post;
+    return data.menus.nodes;
   }
-  async function getPageWithSEO(slug) {
+  async function getMenuById(id) {
     const data = await gqlFetchGraceful(
-      GQL_GET_PAGE_WITH_SEO,
-      { page: null },
-      { slug },
-      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-${slug}`]
+      GQL_GET_MENU_BY_ID,
+      { menu: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-menus", `gql-menu-${id}`]
     );
-    return data.page;
+    return data.menu;
   }
-  async function getPageWithSEOByUri(uri) {
+  async function getMenuBySlug(slug) {
     const data = await gqlFetchGraceful(
-      GQL_GET_PAGE_WITH_SEO_BY_URI,
-      { page: null },
-      { uri },
-      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-uri-${uri.replace(/\//g, "-")}`]
+      GQL_GET_MENU_BY_SLUG,
+      { menu: null },
+      { id: slug },
+      ["wpgraphql", "gql-menus", `gql-menu-${slug}`]
     );
-    return data.page;
+    return data.menu;
   }
-  return { getPostWithSEO, getPageWithSEO, getPageWithSEOByUri };
+  async function getMenuByLocation(location) {
+    const data = await gqlFetch(
+      GQL_GET_MENUS_BY_LOCATION,
+      { location: location.toUpperCase() },
+      ["wpgraphql", "gql-menus", `gql-menu-location-${location}`]
+    );
+    return data.menus.nodes[0] ?? null;
+  }
+  async function getMenuItems(menuSlug) {
+    const menu = await getMenuBySlug(menuSlug);
+    return menu?.menuItems?.nodes ?? [];
+  }
+  return {
+    getMenus,
+    getMenuById,
+    getMenuBySlug,
+    getMenuByLocation,
+    getMenuItems
+  };
 }
 
-// src/integrations/wpGraphQL/acf/helpers.ts
-var BASE_POST_FIELDS = `
-  id databaseId slug title content excerpt date modified status uri
+// src/integrations/wpGraphQL/core/comments/queries.ts
+var COMMENT_AUTHOR_FIELDS = `
+  name
+  url
+  avatar { url width height }
+`;
+var COMMENT_FIELDS = `
+  id
+  databaseId
+  content(format: RENDERED)
+  date
+  parentId
+  status
+  author { node { ${COMMENT_AUTHOR_FIELDS} } }
+`;
+var GQL_GET_COMMENTS_BY_POST = `
+  query GetCommentsByPost($contentId: ID!, $first: Int, $after: String) {
+    comments(
+      first: $first
+      after: $after
+      where: { contentId: $contentId, status: "approve", parent: 0 }
+    ) {
+      nodes {
+        ${COMMENT_FIELDS}
+        replies(first: 100) {
+          nodes { ${COMMENT_FIELDS} }
+        }
+      }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+var GQL_GET_ALL_COMMENTS_BY_POST = `
+  query GetAllCommentsByPost($contentId: ID!) {
+    comments(
+      first: 100
+      where: { contentId: $contentId, status: "approve" }
+    ) {
+      nodes { ${COMMENT_FIELDS} }
+    }
+  }
+`;
+var GQL_GET_COMMENT_BY_ID = `
+  query GetCommentById($id: ID!) {
+    comment(id: $id, idType: DATABASE_ID) { ${COMMENT_FIELDS} }
+  }
+`;
+function createCommentsQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCommentsByPostId(postId, first = 10, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COMMENTS_BY_POST,
+      { comments: { nodes: [], pageInfo: { hasNextPage: false } } },
+      { contentId: String(postId), first, after },
+      ["wpgraphql", "gql-comments", `gql-comments-post-${postId}`]
+    );
+    return data.comments;
+  }
+  async function getAllCommentsByPostId(postId) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ALL_COMMENTS_BY_POST,
+      { comments: { nodes: [] } },
+      { contentId: String(postId) },
+      ["wpgraphql", "gql-comments", `gql-comments-post-${postId}`]
+    );
+    return data.comments.nodes;
+  }
+  async function getCommentById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COMMENT_BY_ID,
+      { comment: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-comments", `gql-comment-${id}`]
+    );
+    return data.comment;
+  }
+  return {
+    getCommentsByPostId,
+    getAllCommentsByPostId,
+    getCommentById
+  };
+}
+
+// src/integrations/wpGraphQL/core/media/queries.ts
+var DEFAULT_FIRST6 = 10;
+var MEDIA_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  date
+  sourceUrl
+  altText
+  caption
+  description
+  mediaType
+  mimeType
+  uri
+  mediaDetails {
+    width
+    height
+    file
+    sizes { name width height mimeType sourceUrl }
+  }
+`;
+var GQL_GET_MEDIA_ITEMS = `
+  query GetMediaItems($first: Int, $after: String) {
+    mediaItems(first: $first, after: $after) {
+      nodes { ${MEDIA_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_MEDIA_ITEM_BY_ID = `
+  query GetMediaItemById($id: ID!) {
+    mediaItem(id: $id, idType: DATABASE_ID) { ${MEDIA_FIELDS} }
+  }
+`;
+var GQL_GET_MEDIA_ITEM_BY_SLUG = `
+  query GetMediaItemBySlug($id: ID!) {
+    mediaItem(id: $id, idType: SLUG) { ${MEDIA_FIELDS} }
+  }
+`;
+function createMediaQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getMediaItems(first = DEFAULT_FIRST6, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MEDIA_ITEMS,
+      { mediaItems: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-media"]
+    );
+    return data.mediaItems;
+  }
+  async function getMediaItemById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MEDIA_ITEM_BY_ID,
+      { mediaItem: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-media", `gql-media-${id}`]
+    );
+    return data.mediaItem;
+  }
+  async function getMediaItemBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MEDIA_ITEM_BY_SLUG,
+      { mediaItem: null },
+      { id: slug },
+      ["wpgraphql", "gql-media", `gql-media-${slug}`]
+    );
+    return data.mediaItem;
+  }
+  return { getMediaItems, getMediaItemById, getMediaItemBySlug };
+}
+
+// src/integrations/wpGraphQL/core/mutations/posts/mutations.ts
+var MUTATED_POST_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  status
+`;
+var GQL_CREATE_POST = `
+  mutation CreatePost($input: CreatePostInput!) {
+    createPost(input: $input) {
+      post { ${MUTATED_POST_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_POST = `
+  mutation UpdatePost($input: UpdatePostInput!) {
+    updatePost(input: $input) {
+      post { ${MUTATED_POST_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_POST = `
+  mutation DeletePost($input: DeletePostInput!) {
+    deletePost(input: $input) {
+      deletedId
+      post { ${MUTATED_POST_FIELDS} }
+    }
+  }
+`;
+function createPostsMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createPost(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_POST,
+      { input },
+      authToken
+    );
+    return data.createPost.post;
+  }
+  async function updatePost(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_POST,
+      { input },
+      authToken
+    );
+    return data.updatePost.post;
+  }
+  async function deletePost(id, authToken, forceDelete = false) {
+    const data = await gqlMutate(
+      GQL_DELETE_POST,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deletePost;
+  }
+  return { createPost, updatePost, deletePost };
+}
+
+// src/integrations/wpGraphQL/core/mutations/comments/mutations.ts
+var MUTATED_COMMENT_FIELDS = `
+  id
+  databaseId
+  content(format: RENDERED)
+  date
+  status
+  parentId
+  author { node { name url } }
+`;
+var GQL_CREATE_COMMENT = `
+  mutation CreateComment($input: CreateCommentInput!) {
+    createComment(input: $input) {
+      success
+      comment { ${MUTATED_COMMENT_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_COMMENT = `
+  mutation UpdateComment($input: UpdateCommentInput!) {
+    updateComment(input: $input) {
+      comment { ${MUTATED_COMMENT_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_COMMENT = `
+  mutation DeleteComment($input: DeleteCommentInput!) {
+    deleteComment(input: $input) {
+      deletedId
+      comment { ${MUTATED_COMMENT_FIELDS} }
+    }
+  }
+`;
+function createCommentsMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createComment(input, authToken) {
+    const gqlInput = {
+      commentOn: input.postId,
+      content: input.content
+    };
+    if (input.authorName) gqlInput["author"] = input.authorName;
+    if (input.authorEmail) gqlInput["authorEmail"] = input.authorEmail;
+    if (input.authorUrl) gqlInput["authorUrl"] = input.authorUrl;
+    if (input.parentId) gqlInput["parent"] = input.parentId;
+    const data = await gqlMutate(
+      GQL_CREATE_COMMENT,
+      { input: gqlInput },
+      authToken
+    );
+    return data.createComment;
+  }
+  async function updateComment(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_COMMENT,
+      { input },
+      authToken
+    );
+    return data.updateComment.comment;
+  }
+  async function deleteComment(id, authToken, forceDelete = false) {
+    const data = await gqlMutate(
+      GQL_DELETE_COMMENT,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deleteComment;
+  }
+  return { createComment, updateComment, deleteComment };
+}
+
+// src/integrations/wpGraphQL/core/mutations/pages/mutations.ts
+var MUTATED_PAGE_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  status
+  uri
+`;
+var GQL_CREATE_PAGE = `
+  mutation CreatePage($input: CreatePageInput!) {
+    createPage(input: $input) {
+      page { ${MUTATED_PAGE_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_PAGE = `
+  mutation UpdatePage($input: UpdatePageInput!) {
+    updatePage(input: $input) {
+      page { ${MUTATED_PAGE_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_PAGE = `
+  mutation DeletePage($input: DeletePageInput!) {
+    deletePage(input: $input) {
+      deletedId
+      page { ${MUTATED_PAGE_FIELDS} }
+    }
+  }
+`;
+function createPagesMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createPage(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_PAGE,
+      { input },
+      authToken
+    );
+    return data.createPage.page;
+  }
+  async function updatePage(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_PAGE,
+      { input },
+      authToken
+    );
+    return data.updatePage.page;
+  }
+  async function deletePage(id, authToken, forceDelete = false) {
+    const data = await gqlMutate(
+      GQL_DELETE_PAGE,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deletePage;
+  }
+  return { createPage, updatePage, deletePage };
+}
+
+// src/integrations/wpGraphQL/core/mutations/categories/mutations.ts
+var MUTATED_CATEGORY_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+`;
+var GQL_CREATE_CATEGORY = `
+  mutation CreateCategory($input: CreateCategoryInput!) {
+    createCategory(input: $input) {
+      category { ${MUTATED_CATEGORY_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_CATEGORY = `
+  mutation UpdateCategory($input: UpdateCategoryInput!) {
+    updateCategory(input: $input) {
+      category { ${MUTATED_CATEGORY_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_CATEGORY = `
+  mutation DeleteCategory($input: DeleteCategoryInput!) {
+    deleteCategory(input: $input) {
+      deletedId
+      category { ${MUTATED_CATEGORY_FIELDS} }
+    }
+  }
+`;
+function createCategoriesMutations3(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createCategory(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_CATEGORY,
+      { input },
+      authToken
+    );
+    return data.createCategory.category;
+  }
+  async function updateCategory(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_CATEGORY,
+      { input },
+      authToken
+    );
+    return data.updateCategory.category;
+  }
+  async function deleteCategory(id, authToken) {
+    const data = await gqlMutate(
+      GQL_DELETE_CATEGORY,
+      { input: { id } },
+      authToken
+    );
+    return data.deleteCategory;
+  }
+  return { createCategory, updateCategory, deleteCategory };
+}
+
+// src/integrations/wpGraphQL/core/mutations/tags/mutations.ts
+var MUTATED_TAG_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+`;
+var GQL_CREATE_TAG = `
+  mutation CreateTag($input: CreateTagInput!) {
+    createTag(input: $input) {
+      tag { ${MUTATED_TAG_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_TAG = `
+  mutation UpdateTag($input: UpdateTagInput!) {
+    updateTag(input: $input) {
+      tag { ${MUTATED_TAG_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_TAG = `
+  mutation DeleteTag($input: DeleteTagInput!) {
+    deleteTag(input: $input) {
+      deletedId
+      tag { ${MUTATED_TAG_FIELDS} }
+    }
+  }
+`;
+function createTagsMutations3(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createTag(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_TAG,
+      { input },
+      authToken
+    );
+    return data.createTag.tag;
+  }
+  async function updateTag(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_TAG,
+      { input },
+      authToken
+    );
+    return data.updateTag.tag;
+  }
+  async function deleteTag(id, authToken) {
+    const data = await gqlMutate(
+      GQL_DELETE_TAG,
+      { input: { id } },
+      authToken
+    );
+    return data.deleteTag;
+  }
+  return { createTag, updateTag, deleteTag };
+}
+
+// src/integrations/wpGraphQL/core/mutations/authors/mutations.ts
+var MUTATED_USER_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  email
+`;
+var GQL_REGISTER_USER = `
+  mutation RegisterUser($input: RegisterUserInput!) {
+    registerUser(input: $input) {
+      user { ${MUTATED_USER_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_USER = `
+  mutation UpdateUser($input: UpdateUserInput!) {
+    updateUser(input: $input) {
+      user { ${MUTATED_USER_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_USER = `
+  mutation DeleteUser($input: DeleteUserInput!) {
+    deleteUser(input: $input) {
+      deletedId
+      user { ${MUTATED_USER_FIELDS} }
+    }
+  }
+`;
+function createAuthorsMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function registerUser(input, authToken) {
+    const data = await gqlMutate(
+      GQL_REGISTER_USER,
+      { input },
+      authToken
+    );
+    return data.registerUser.user;
+  }
+  async function updateUser(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_USER,
+      { input },
+      authToken
+    );
+    return data.updateUser.user;
+  }
+  async function deleteUser(id, authToken, reassignPosts) {
+    const input = { id };
+    if (reassignPosts) input["reassignId"] = reassignPosts;
+    const data = await gqlMutate(
+      GQL_DELETE_USER,
+      { input },
+      authToken
+    );
+    return data.deleteUser;
+  }
+  return { registerUser, updateUser, deleteUser };
+}
+
+// src/integrations/wpGraphQL/core/mutations/media/mutations.ts
+var MUTATED_MEDIA_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  sourceUrl
+  altText
+`;
+var GQL_CREATE_MEDIA_ITEM = `
+  mutation CreateMediaItem($input: CreateMediaItemInput!) {
+    createMediaItem(input: $input) {
+      mediaItem { ${MUTATED_MEDIA_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_MEDIA_ITEM = `
+  mutation UpdateMediaItem($input: UpdateMediaItemInput!) {
+    updateMediaItem(input: $input) {
+      mediaItem { ${MUTATED_MEDIA_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_MEDIA_ITEM = `
+  mutation DeleteMediaItem($input: DeleteMediaItemInput!) {
+    deleteMediaItem(input: $input) {
+      deletedId
+      mediaItem { ${MUTATED_MEDIA_FIELDS} }
+    }
+  }
+`;
+function createMediaMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createMediaItem(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_MEDIA_ITEM,
+      { input },
+      authToken
+    );
+    return data.createMediaItem.mediaItem;
+  }
+  async function updateMediaItem(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_MEDIA_ITEM,
+      { input },
+      authToken
+    );
+    return data.updateMediaItem.mediaItem;
+  }
+  async function deleteMediaItem(id, authToken, forceDelete = true) {
+    const data = await gqlMutate(
+      GQL_DELETE_MEDIA_ITEM,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deleteMediaItem;
+  }
+  return { createMediaItem, updateMediaItem, deleteMediaItem };
+}
+
+// src/integrations/wpGraphQL/core/mutations/index.ts
+function createWPGraphQLMutationsClient(config) {
+  const fetcher = createWPGraphQLFetcher(config);
+  return {
+    ...createPostsMutations2(fetcher),
+    ...createCommentsMutations2(fetcher),
+    ...createPagesMutations2(fetcher),
+    ...createCategoriesMutations3(fetcher),
+    ...createTagsMutations3(fetcher),
+    ...createAuthorsMutations2(fetcher),
+    ...createMediaMutations2(fetcher)
+  };
+}
+
+// src/integrations/wpGraphQL/core/index.ts
+function createWPGraphQLCoreClient(config) {
+  const fetcher = createWPGraphQLFetcher(config);
+  return {
+    ...createPostsQueries2(fetcher),
+    ...createPagesQueries2(fetcher),
+    ...createCategoriesQueries3(fetcher),
+    ...createTagsQueries3(fetcher),
+    ...createAuthorsQueries2(fetcher),
+    ...createMenusQueries2(fetcher),
+    ...createCommentsQueries2(fetcher),
+    ...createMediaQueries2(fetcher)
+  };
+}
+
+// src/integrations/wpGraphQL/yoast/queries.ts
+var SEO_FIELDS = `
+  seo {
+    title
+    metaDesc
+    canonical
+    opengraphTitle
+    opengraphDescription
+    opengraphImage { sourceUrl altText }
+    twitterTitle
+    twitterDescription
+    twitterImage { sourceUrl }
+    schema { raw }
+  }
+`;
+var POST_FIELDS_WITH_SEO = `
+  id
+  databaseId
+  slug
+  title
+  content
+  excerpt
+  date
+  modified
+  status
+  uri
+  author {
+    node {
+      databaseId
+      name
+      slug
+      avatar { url }
+    }
+  }
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  categories {
+    nodes { databaseId name slug }
+  }
+  tags {
+    nodes { databaseId name slug }
+  }
+  ${SEO_FIELDS}
+`;
+var PAGE_FIELDS_WITH_SEO = `
+  id
+  databaseId
+  slug
+  title
+  content
+  date
+  modified
+  status
+  uri
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  ${SEO_FIELDS}
+`;
+var GQL_GET_POST_WITH_SEO = `
+  query GetPostWithSEO($slug: ID!) {
+    post(id: $slug, idType: SLUG) { ${POST_FIELDS_WITH_SEO} }
+  }
+`;
+var GQL_GET_PAGE_WITH_SEO = `
+  query GetPageWithSEO($slug: ID!) {
+    page(id: $slug, idType: SLUG) { ${PAGE_FIELDS_WITH_SEO} }
+  }
+`;
+var GQL_GET_PAGE_WITH_SEO_BY_URI = `
+  query GetPageWithSEOByUri($uri: ID!) {
+    page(id: $uri, idType: URI) { ${PAGE_FIELDS_WITH_SEO} }
+  }
+`;
+function createYoastQueries(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getPostWithSEO(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_POST_WITH_SEO,
+      { post: null },
+      { slug },
+      ["wpgraphql", "gql-posts", "gql-yoast", `gql-post-${slug}`]
+    );
+    return data.post;
+  }
+  async function getPageWithSEO(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_WITH_SEO,
+      { page: null },
+      { slug },
+      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-${slug}`]
+    );
+    return data.page;
+  }
+  async function getPageWithSEOByUri(uri) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_WITH_SEO_BY_URI,
+      { page: null },
+      { uri },
+      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-uri-${uri.replace(/\//g, "-")}`]
+    );
+    return data.page;
+  }
+  return { getPostWithSEO, getPageWithSEO, getPageWithSEOByUri };
+}
+
+// src/integrations/wpGraphQL/acf/helpers.ts
+var BASE_POST_FIELDS = `
+  id databaseId slug title content excerpt date modified status uri
   author { node { databaseId name slug avatar { url } } }
   featuredImage { node { sourceUrl altText mediaDetails { width height } } }
   categories { nodes { databaseId name slug } }
@@ -1439,29 +2604,38 @@ function buildPostsWithACFQuery(fieldGroupName, fields) {
 }
 
 // src/integrations/wpGraphQL/woocommerce/products/queries.ts
-var DEFAULT_FIRST6 = 10;
+var DEFAULT_FIRST7 = 10;
 var BATCH_FIRST3 = 100;
 var PRODUCT_FIELDS = `
   id
   databaseId
   slug
   name
+  status
   description
   shortDescription
-  sku
-  price
-  regularPrice
-  salePrice
-  onSale
-  stockStatus
-  stockQuantity
-  manageStock
   type
+  onSale
   featuredImage { node { sourceUrl altText } }
   galleryImages { nodes { sourceUrl altText } }
   productCategories { nodes { databaseId name slug } }
   productTags { nodes { databaseId name slug } }
+  ... on SimpleProduct {
+    sku
+    price
+    regularPrice
+    salePrice
+    stockStatus
+    stockQuantity
+    manageStock
+  }
   ... on VariableProduct {
+    price
+    regularPrice
+    salePrice
+    stockStatus
+    stockQuantity
+    manageStock
     variations {
       nodes {
         id
@@ -1508,7 +2682,7 @@ var GQL_GET_ALL_PRODUCT_SLUGS = `
 `;
 function createProductsQueries2(fetcher) {
   const { gqlFetch, gqlFetchGraceful } = fetcher;
-  async function getProducts(first = DEFAULT_FIRST6, after, filter) {
+  async function getProducts(first = DEFAULT_FIRST7, after, filter) {
     const where = {};
     if (filter?.search) where["search"] = filter.search;
     if (filter?.onSale !== void 0) where["onSale"] = filter.onSale;
@@ -1544,11 +2718,11 @@ function createProductsQueries2(fetcher) {
     );
     return data.product;
   }
-  async function getFeaturedProducts(first = DEFAULT_FIRST6) {
+  async function getFeaturedProducts(first = DEFAULT_FIRST7) {
     const connection = await getProducts(first, void 0, { featured: true });
     return connection.nodes;
   }
-  async function getOnSaleProducts(first = DEFAULT_FIRST6) {
+  async function getOnSaleProducts(first = DEFAULT_FIRST7) {
     const connection = await getProducts(first, void 0, { onSale: true });
     return connection.nodes;
   }
@@ -1580,7 +2754,7 @@ function createProductsQueries2(fetcher) {
 }
 
 // src/integrations/wpGraphQL/woocommerce/orders/queries.ts
-var DEFAULT_FIRST7 = 10;
+var DEFAULT_FIRST8 = 10;
 var ADDRESS_FIELDS = `
   firstName lastName address1 address2 city postcode country email phone
 `;
@@ -1633,7 +2807,7 @@ function createOrdersQueries2(fetcher) {
     );
     return data.order;
   }
-  async function getMyOrders(first = DEFAULT_FIRST7, after) {
+  async function getMyOrders(first = DEFAULT_FIRST8, after) {
     const data = await gqlFetchGraceful(
       GQL_GET_MY_ORDERS,
       { orders: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
@@ -1692,18 +2866,211 @@ function createCustomersQueries2(fetcher) {
   return { getCustomer, getCustomerById };
 }
 
+// src/integrations/wpGraphQL/woocommerce/categories/queries.ts
+var DEFAULT_FIRST9 = 100;
+var CATEGORY_FIELDS2 = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+  parent { node { id databaseId name slug } }
+  image { sourceUrl altText }
+`;
+var GQL_GET_PRODUCT_CATEGORIES = `
+  query GetProductCategories($first: Int, $after: String) {
+    productCategories(first: $first, after: $after) {
+      nodes { ${CATEGORY_FIELDS2} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PRODUCT_CATEGORY_BY_SLUG = `
+  query GetProductCategoryBySlug($id: ID!) {
+    productCategory(id: $id, idType: SLUG) { ${CATEGORY_FIELDS2} }
+  }
+`;
+var GQL_GET_PRODUCT_CATEGORY_BY_ID = `
+  query GetProductCategoryById($id: ID!) {
+    productCategory(id: $id, idType: DATABASE_ID) { ${CATEGORY_FIELDS2} }
+  }
+`;
+function createCategoriesQueries4(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getProductCategories(first = DEFAULT_FIRST9, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_CATEGORIES,
+      { productCategories: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-product-categories"]
+    );
+    return data.productCategories;
+  }
+  async function getProductCategoryBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_CATEGORY_BY_SLUG,
+      { productCategory: null },
+      { id: slug },
+      ["wpgraphql", "gql-product-categories", `gql-product-category-${slug}`]
+    );
+    return data.productCategory;
+  }
+  async function getProductCategoryById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_CATEGORY_BY_ID,
+      { productCategory: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-product-categories", `gql-product-category-${id}`]
+    );
+    return data.productCategory;
+  }
+  return { getProductCategories, getProductCategoryBySlug, getProductCategoryById };
+}
+
+// src/integrations/wpGraphQL/woocommerce/tags/queries.ts
+var DEFAULT_FIRST10 = 100;
+var TAG_FIELDS2 = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+`;
+var GQL_GET_PRODUCT_TAGS = `
+  query GetProductTags($first: Int, $after: String) {
+    productTags(first: $first, after: $after) {
+      nodes { ${TAG_FIELDS2} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PRODUCT_TAG_BY_SLUG = `
+  query GetProductTagBySlug($id: ID!) {
+    productTag(id: $id, idType: SLUG) { ${TAG_FIELDS2} }
+  }
+`;
+var GQL_GET_PRODUCT_TAG_BY_ID = `
+  query GetProductTagById($id: ID!) {
+    productTag(id: $id, idType: DATABASE_ID) { ${TAG_FIELDS2} }
+  }
+`;
+function createTagsQueries4(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getProductTags(first = DEFAULT_FIRST10, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_TAGS,
+      { productTags: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-product-tags"]
+    );
+    return data.productTags;
+  }
+  async function getProductTagBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_TAG_BY_SLUG,
+      { productTag: null },
+      { id: slug },
+      ["wpgraphql", "gql-product-tags", `gql-product-tag-${slug}`]
+    );
+    return data.productTag;
+  }
+  async function getProductTagById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_TAG_BY_ID,
+      { productTag: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-product-tags", `gql-product-tag-${id}`]
+    );
+    return data.productTag;
+  }
+  return { getProductTags, getProductTagBySlug, getProductTagById };
+}
+
+// src/integrations/wpGraphQL/woocommerce/coupons/queries.ts
+var DEFAULT_FIRST11 = 100;
+var COUPON_FIELDS = `
+  id
+  databaseId
+  code
+  discountType
+  amount
+  dateExpiry
+  usageCount
+  usageLimit
+  usageLimitPerUser
+  individualUse
+  freeShipping
+  minimumAmount
+  maximumAmount
+  description
+`;
+var GQL_GET_COUPONS = `
+  query GetCoupons($first: Int, $after: String) {
+    coupons(first: $first, after: $after) {
+      nodes { ${COUPON_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_COUPON_BY_CODE = `
+  query GetCouponByCode($id: ID!) {
+    coupon(id: $id, idType: CODE) { ${COUPON_FIELDS} }
+  }
+`;
+var GQL_GET_COUPON_BY_ID = `
+  query GetCouponById($id: ID!) {
+    coupon(id: $id, idType: DATABASE_ID) { ${COUPON_FIELDS} }
+  }
+`;
+function createCouponsQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCoupons(first = DEFAULT_FIRST11, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COUPONS,
+      { coupons: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-coupons"]
+    );
+    return data.coupons;
+  }
+  async function getCouponByCode(code) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COUPON_BY_CODE,
+      { coupon: null },
+      { id: code },
+      ["wpgraphql", "gql-coupons", `gql-coupon-${code}`]
+    );
+    return data.coupon;
+  }
+  async function getCouponById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COUPON_BY_ID,
+      { coupon: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-coupons", `gql-coupon-${id}`]
+    );
+    return data.coupon;
+  }
+  return { getCoupons, getCouponByCode, getCouponById };
+}
+
 // src/integrations/wpGraphQL/woocommerce/index.ts
 function createWPGraphQLWooCommerceClient(config) {
   const fetcher = createWPGraphQLFetcher(config);
   return {
     ...createProductsQueries2(fetcher),
     ...createOrdersQueries2(fetcher),
-    ...createCustomersQueries2(fetcher)
+    ...createCustomersQueries2(fetcher),
+    ...createCategoriesQueries4(fetcher),
+    ...createTagsQueries4(fetcher),
+    ...createCouponsQueries2(fetcher)
   };
 }
 
 // src/integrations/wpGraphQL/cpt/queries.ts
-var DEFAULT_FIRST8 = 10;
+var DEFAULT_FIRST12 = 10;
 var BATCH_FIRST4 = 100;
 var BASE_CPT_FIELDS = `
   id databaseId slug title date modified status uri
@@ -1732,7 +3099,7 @@ function createCPTQueries(fetcher, typeName, singularTypeName, extraFields) {
       }
     }
   `;
-  async function getItems(first = DEFAULT_FIRST8, after) {
+  async function getItems(first = DEFAULT_FIRST12, after) {
     const data = await gqlFetchGraceful(
       GQL_GET_ITEMS,
       { [typeName]: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
@@ -1772,22 +3139,130 @@ function createCPTQueries(fetcher, typeName, singularTypeName, extraFields) {
   return { getItems, getItemBySlug, getAllSlugs };
 }
 
+// src/nextjs/revalidation.ts
+var ACTION_TAG_MAP = {
+  save_post: ["wordpress", "posts"],
+  save_post_post: ["wordpress", "posts"],
+  save_post_page: ["wordpress", "pages"],
+  delete_post: ["wordpress", "posts", "pages"],
+  created_term: ["wordpress", "categories", "tags"],
+  edited_term: ["wordpress", "categories", "tags"],
+  delete_term: ["wordpress", "categories", "tags"],
+  wp_update_nav_menu: ["wordpress", "menus"],
+  woocommerce_product_updated: ["woocommerce", "products"],
+  woocommerce_new_product: ["woocommerce", "products"],
+  woocommerce_delete_product: ["woocommerce", "products"],
+  woocommerce_new_order: ["woocommerce", "orders"],
+  woocommerce_order_status_changed: ["woocommerce", "orders"],
+  woocommerce_update_order: ["woocommerce", "orders"],
+  woocommerce_product_category_updated: ["woocommerce", "categories"],
+  woocommerce_product_tag_updated: ["woocommerce", "tags"]
+};
+function extractSecret(request) {
+  const auth = request.headers.get("Authorization");
+  if (auth?.startsWith("Bearer ")) return auth.slice(7);
+  return new URL(request.url).searchParams.get("secret");
+}
+function createRevalidationHandler(config, revalidateTag) {
+  return async function handler(request) {
+    if (extractSecret(request) !== config.secret) {
+      return Response.json({ revalidated: false, tags: [], message: "Unauthorized" }, { status: 401 });
+    }
+    let payload;
+    try {
+      payload = await request.json();
+    } catch {
+      return Response.json({ revalidated: false, tags: [], message: "Invalid JSON body" }, { status: 400 });
+    }
+    const { action } = payload;
+    const matched = ACTION_TAG_MAP[action];
+    if (!matched) {
+      return Response.json(
+        { revalidated: false, tags: [], message: `Unknown action: ${action}` },
+        { status: 400 }
+      );
+    }
+    const tags = [...new Set(matched)];
+    for (const tag of tags) {
+      revalidateTag(tag);
+    }
+    return Response.json({ revalidated: true, tags });
+  };
+}
+
+// src/auth/applicationPassword.ts
+function createApplicationPasswordToken(username, appPassword) {
+  const encoded = Buffer.from(`${username}:${appPassword}`).toString("base64");
+  return `Basic ${encoded}`;
+}
+
+// src/auth/types.ts
+var AuthenticationError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    __publicField(this, "status", status);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/auth/jwt.ts
+async function authenticateJwt(config, credentials) {
+  const url = `${resolveBaseUrl(config)}/wp-json/jwt-auth/v1/token`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(credentials),
+    cache: "no-store"
+  });
+  if (!response.ok) {
+    throw new AuthenticationError(
+      `JWT authentication failed: ${response.statusText}`,
+      response.status
+    );
+  }
+  return response.json();
+}
+async function validateJwtToken(config, token) {
+  const url = `${resolveBaseUrl(config)}/wp-json/jwt-auth/v1/token/validate`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    cache: "no-store"
+  });
+  return response.ok;
+}
+
+exports.AuthenticationError = AuthenticationError;
 exports.WPGraphQLError = WPGraphQLError;
+exports.authenticateJwt = authenticateJwt;
 exports.buildACFFragment = buildACFFragment;
 exports.buildPageWithACFQuery = buildPageWithACFQuery;
 exports.buildPostWithACFQuery = buildPostWithACFQuery;
 exports.buildPostsWithACFQuery = buildPostsWithACFQuery;
+exports.createApplicationPasswordToken = createApplicationPasswordToken;
+exports.createAuthorsMutations = createAuthorsMutations;
 exports.createCPTQueries = createCPTQueries;
+exports.createCategoriesMutations = createCategoriesMutations;
+exports.createCommentsMutations = createCommentsMutations;
+exports.createMediaMutations = createMediaMutations;
+exports.createMenusMutations = createMenusMutations;
+exports.createPagesMutations = createPagesMutations;
+exports.createPostsMutations = createPostsMutations;
+exports.createRevalidationHandler = createRevalidationHandler;
+exports.createTagsMutations = createTagsMutations;
 exports.createWPGraphQLClient = createWPGraphQLCoreClient;
 exports.createWPGraphQLCoreClient = createWPGraphQLCoreClient;
 exports.createWPGraphQLFetcher = createWPGraphQLFetcher;
+exports.createWPGraphQLMutationsClient = createWPGraphQLMutationsClient;
 exports.createWPGraphQLWooCommerceClient = createWPGraphQLWooCommerceClient;
 exports.createWooCommerceClient = createWooCommerceClient;
 exports.createWooCommerceFetcher = createWooCommerceFetcher;
 exports.createWordPressClient = createWordPressClient;
+exports.createWordPressMutationsClient = createWordPressMutationsClient;
 exports.createYoastQueries = createYoastQueries;
 exports.extractOmnibusData = extractOmnibusData;
 exports.resolveBaseUrl = resolveBaseUrl;
+exports.validateJwtToken = validateJwtToken;
 exports.withOmnibus = withOmnibus;
 exports.withOmnibusVariation = withOmnibusVariation;
 //# sourceMappingURL=index.cjs.map