@szymonpiatek/nextwordpress 0.0.1

package/dist/index.cjs

@@ -0,0 +1,798 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/client/url/url.ts
+function resolveBaseUrl(config) {
+  return typeof window === "undefined" ? config.serverURL : config.clientURL;
+}
+function buildUrl(config, path, query) {
+  const base = resolveBaseUrl(config);
+  if (!query) return `${base}${path}`;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== null) {
+      params.set(key, String(value));
+    }
+  }
+  const qs = params.toString();
+  return qs ? `${base}${path}?${qs}` : `${base}${path}`;
+}
+
+// src/client/types/types.ts
+var WordPressAPIError = class extends Error {
+  constructor(message, status, endpoint) {
+    super(message);
+    __publicField(this, "status", status);
+    __publicField(this, "endpoint", endpoint);
+    this.name = "WordPressAPIError";
+  }
+};
+
+// src/client/fetcher/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 createFetcher(config) {
+  const cacheTtl = 300;
+  async function wpFetch(path, query, tags = ["wordpress"]) {
+    const url = buildUrl(config, path, query);
+    const res = await doFetch(url, {
+      headers: { "User-Agent": USER_AGENT },
+      next: { tags, revalidate: cacheTtl }
+    });
+    return await res.json();
+  }
+  async function wpFetchGraceful(path, fallback, query, tags = ["wordpress"]) {
+    try {
+      return await wpFetch(path, query, tags);
+    } catch {
+      console.warn(`WordPress fetch failed for ${path}`);
+      return fallback;
+    }
+  }
+  async function wpFetchPaginated(path, query, tags = ["wordpress"]) {
+    const url = buildUrl(config, path, query);
+    const res = await doFetch(url, {
+      headers: { "User-Agent": USER_AGENT },
+      next: { tags, revalidate: cacheTtl }
+    });
+    return {
+      data: await res.json(),
+      headers: {
+        total: parseInt(res.headers.get("X-WP-Total") ?? "0", 10),
+        totalPages: parseInt(res.headers.get("X-WP-TotalPages") ?? "0", 10)
+      }
+    };
+  }
+  async function wpFetchPaginatedGraceful(path, query, tags = ["wordpress"]) {
+    const empty = { data: [], headers: { total: 0, totalPages: 0 } };
+    try {
+      return await wpFetchPaginated(path, query, tags);
+    } catch {
+      console.warn(`WordPress paginated fetch failed for ${path}`);
+      return empty;
+    }
+  }
+  async function wpMutate(path, body, method = "POST") {
+    const url = buildUrl(config, path);
+    const res = await doFetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT
+      },
+      body: JSON.stringify(body),
+      cache: "no-store"
+    });
+    return await res.json();
+  }
+  return { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful, wpMutate };
+}
+
+// src/integrations/base/posts/queries.ts
+function createPostsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful } = fetcher;
+  async function getPostsPaginated(page = 1, perPage = 9, filterParams) {
+    const query = { _embed: true, per_page: perPage, page };
+    const cacheTags = ["wordpress", "posts", `posts-page-${page}`];
+    if (filterParams?.search) {
+      query.search = filterParams.search;
+      cacheTags.push("posts-search");
+    }
+    if (filterParams?.author) {
+      query.author = filterParams.author;
+      cacheTags.push(`posts-author-${filterParams.author}`);
+    }
+    if (filterParams?.tag) {
+      query.tags = filterParams.tag;
+      cacheTags.push(`posts-tag-${filterParams.tag}`);
+    }
+    if (filterParams?.category) {
+      query.categories = filterParams.category;
+      cacheTags.push(`posts-category-${filterParams.category}`);
+    }
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", query, cacheTags);
+  }
+  async function getRecentPosts(filterParams) {
+    const query = { _embed: true, per_page: 100 };
+    if (filterParams?.search) query.search = filterParams.search;
+    if (filterParams?.author) query.author = filterParams.author;
+    if (filterParams?.tag) query.tags = filterParams.tag;
+    if (filterParams?.category) query.categories = filterParams.category;
+    return wpFetchGraceful("/wp-json/wp/v2/posts", [], query, ["wordpress", "posts"]);
+  }
+  async function getPostById(id) {
+    return wpFetch(`/wp-json/wp/v2/posts/${id}`);
+  }
+  async function getPostBySlug(slug) {
+    const posts = await wpFetchGraceful("/wp-json/wp/v2/posts", [], { slug, _embed: true });
+    return posts[0];
+  }
+  async function getPostsByCategory(categoryId) {
+    return wpFetch("/wp-json/wp/v2/posts", { categories: categoryId });
+  }
+  async function getPostsByTag(tagId) {
+    return wpFetch("/wp-json/wp/v2/posts", { tags: tagId });
+  }
+  async function getPostsByAuthor(authorId) {
+    return wpFetch("/wp-json/wp/v2/posts", { author: authorId });
+  }
+  async function getPostsByCategoryPaginated(categoryId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      categories: categoryId
+    });
+  }
+  async function getPostsByTagPaginated(tagId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      tags: tagId
+    });
+  }
+  async function getPostsByAuthorPaginated(authorId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      author: authorId
+    });
+  }
+  async function getAllPostSlugs() {
+    try {
+      const allSlugs = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wpFetchPaginated(
+          "/wp-json/wp/v2/posts",
+          { per_page: 100, page, _fields: "slug" }
+        );
+        allSlugs.push(...response.data.map((post) => ({ slug: post.slug })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allSlugs;
+    } catch {
+      console.warn("WordPress unavailable, skipping static generation for posts");
+      return [];
+    }
+  }
+  async function getAllPostsForSitemap() {
+    try {
+      const allPosts = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wpFetchPaginated(
+          "/wp-json/wp/v2/posts",
+          { per_page: 100, page, _fields: "slug,modified" }
+        );
+        allPosts.push(...response.data.map((post) => ({ slug: post.slug, modified: post.modified })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allPosts;
+    } catch {
+      console.warn("WordPress unavailable, skipping sitemap generation");
+      return [];
+    }
+  }
+  return {
+    getPostsPaginated,
+    getRecentPosts,
+    getPostById,
+    getPostBySlug,
+    getPostsByCategory,
+    getPostsByTag,
+    getPostsByAuthor,
+    getPostsByCategoryPaginated,
+    getPostsByTagPaginated,
+    getPostsByAuthorPaginated,
+    getAllPostSlugs,
+    getAllPostsForSitemap
+  };
+}
+
+// src/integrations/base/categories/queries.ts
+function createCategoriesQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllCategories() {
+    return wpFetchGraceful("/wp-json/wp/v2/categories", [], { per_page: 100 }, [
+      "wordpress",
+      "categories"
+    ]);
+  }
+  async function getCategoryById(id) {
+    return wpFetch(`/wp-json/wp/v2/categories/${id}`);
+  }
+  async function getCategoryBySlug(slug) {
+    const categories = await wpFetch("/wp-json/wp/v2/categories", { slug });
+    return categories[0];
+  }
+  async function searchCategories(query) {
+    return wpFetchGraceful("/wp-json/wp/v2/categories", [], {
+      search: query,
+      per_page: 100
+    });
+  }
+  return { getAllCategories, getCategoryById, getCategoryBySlug, searchCategories };
+}
+
+// src/integrations/base/tags/queries.ts
+function createTagsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllTags() {
+    return wpFetchGraceful("/wp-json/wp/v2/tags", [], { per_page: 100 }, [
+      "wordpress",
+      "tags"
+    ]);
+  }
+  async function getTagById(id) {
+    return wpFetch(`/wp-json/wp/v2/tags/${id}`);
+  }
+  async function getTagBySlug(slug) {
+    const tags = await wpFetch("/wp-json/wp/v2/tags", { slug });
+    return tags[0];
+  }
+  async function getTagsByPost(postId) {
+    return wpFetch("/wp-json/wp/v2/tags", { post: postId });
+  }
+  async function searchTags(query) {
+    return wpFetchGraceful("/wp-json/wp/v2/tags", [], { search: query, per_page: 100 });
+  }
+  return { getAllTags, getTagById, getTagBySlug, getTagsByPost, searchTags };
+}
+
+// src/integrations/base/authors/queries.ts
+function createAuthorsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllAuthors() {
+    return wpFetchGraceful("/wp-json/wp/v2/users", [], { per_page: 100 }, [
+      "wordpress",
+      "authors"
+    ]);
+  }
+  async function getAuthorById(id) {
+    return wpFetch(`/wp-json/wp/v2/users/${id}`);
+  }
+  async function getAuthorBySlug(slug) {
+    const users = await wpFetch("/wp-json/wp/v2/users", { slug });
+    return users[0];
+  }
+  async function searchAuthors(query) {
+    return wpFetchGraceful("/wp-json/wp/v2/users", [], { search: query, per_page: 100 });
+  }
+  return { getAllAuthors, getAuthorById, getAuthorBySlug, searchAuthors };
+}
+
+// src/integrations/base/media/queries.ts
+function createMediaQueries(fetcher) {
+  const { wpFetch } = fetcher;
+  async function getFeaturedMediaById(id) {
+    return wpFetch(`/wp-json/wp/v2/media/${id}`);
+  }
+  return { getFeaturedMediaById };
+}
+
+// src/integrations/base/pages/queries.ts
+function createPagesQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllPages() {
+    return wpFetchGraceful("/wp-json/wp/v2/pages", [], { per_page: 100 }, [
+      "wordpress",
+      "pages"
+    ]);
+  }
+  async function getPageById(id) {
+    return wpFetch(`/wp-json/wp/v2/pages/${id}`);
+  }
+  async function getPageBySlug(slug) {
+    const pages = await wpFetchGraceful("/wp-json/wp/v2/pages", [], { slug });
+    return pages[0];
+  }
+  return { getAllPages, getPageById, getPageBySlug };
+}
+
+// src/integrations/base/index.ts
+function createWordPressClient(config) {
+  const fetcher = createFetcher(config);
+  return {
+    ...createPostsQueries(fetcher),
+    ...createCategoriesQueries(fetcher),
+    ...createTagsQueries(fetcher),
+    ...createAuthorsQueries(fetcher),
+    ...createMediaQueries(fetcher),
+    ...createPagesQueries(fetcher)
+  };
+}
+
+// src/integrations/woocommerce/omnibus/queries.ts
+var META_KEY_LOWEST_PRICE = "wpo_lowest_price";
+var META_KEY_PRICE_HISTORY = "_alg_wc_price_history";
+function extractMetaValue(meta_data, key) {
+  return meta_data.find((m) => m.key === key)?.value;
+}
+function parseHistory(raw) {
+  if (!raw || typeof raw !== "object") return [];
+  if (Array.isArray(raw)) {
+    return raw.filter((e) => e && typeof e.price === "string" && typeof e.date === "string").map((e) => ({ price: e.price, date: e.date }));
+  }
+  return Object.entries(raw).map(([date, price]) => ({ date, price })).sort((a, b) => a.date.localeCompare(b.date));
+}
+function extractOmnibusData(meta_data) {
+  const lowestPrice = extractMetaValue(meta_data, META_KEY_LOWEST_PRICE) ?? null;
+  const rawHistory = extractMetaValue(meta_data, META_KEY_PRICE_HISTORY);
+  const priceHistory = parseHistory(rawHistory);
+  return { lowestPrice, priceHistory };
+}
+function withOmnibus(product) {
+  return { ...product, omnibus: extractOmnibusData(product.meta_data) };
+}
+function withOmnibusVariation(variation) {
+  return {
+    ...variation,
+    omnibus: extractOmnibusData(variation.meta_data ?? [])
+  };
+}
+
+// src/integrations/woocommerce/client/fetcher.ts
+var USER_AGENT2 = "NextWordpress WooCommerce Client";
+var DEFAULT_CACHE_TTL = 3600;
+function toQueryString(params) {
+  const pairs = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return pairs.join("&");
+}
+function createWooCommerceFetcher(config) {
+  const cacheTTL = config.cacheTTL ?? DEFAULT_CACHE_TTL;
+  function withAuth(query) {
+    return { ...query, consumer_key: config.consumerKey, consumer_secret: config.consumerSecret };
+  }
+  function buildUrl2(path, query) {
+    return `${config.serverURL}${path}?${toQueryString(withAuth(query))}`;
+  }
+  async function wcFetch(path, query, tags = ["woocommerce"], options) {
+    const url = buildUrl2(path, query);
+    const isMutation = options?.method && options.method !== "GET";
+    const noStore = options?.cache === "no-store";
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "User-Agent": USER_AGENT2,
+        "Content-Type": "application/json",
+        ...options?.headers
+      },
+      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}]`);
+    }
+    return response.json();
+  }
+  async function wcFetchGraceful(path, fallback, query, tags = ["woocommerce"]) {
+    try {
+      return await wcFetch(path, query, tags);
+    } catch (err) {
+      console.warn(`WooCommerce fetch failed for ${path}`, err);
+      return fallback;
+    }
+  }
+  async function wcFetchPaginated(path, query, tags = ["woocommerce"]) {
+    const url = buildUrl2(path, query);
+    const response = await fetch(url, {
+      headers: { "User-Agent": USER_AGENT2 },
+      next: { tags, revalidate: cacheTTL }
+    });
+    if (!response.ok) {
+      throw new Error(`WooCommerce API ${response.status}: ${response.statusText} [${url}]`);
+    }
+    return {
+      data: await response.json(),
+      headers: {
+        total: parseInt(response.headers.get("X-WP-Total") ?? "0", 10),
+        totalPages: parseInt(response.headers.get("X-WP-TotalPages") ?? "0", 10)
+      }
+    };
+  }
+  async function wcFetchPaginatedGraceful(path, query, tags = ["woocommerce"]) {
+    const empty = { data: [], headers: { total: 0, totalPages: 0 } };
+    try {
+      return await wcFetchPaginated(path, query, tags);
+    } catch (err) {
+      console.warn(`WooCommerce paginated fetch failed for ${path}`, err);
+      return empty;
+    }
+  }
+  async function wcMutate(path, body, method = "POST") {
+    return wcFetch(path, void 0, ["woocommerce"], {
+      method,
+      body: JSON.stringify(body)
+    });
+  }
+  return { wcFetch, wcFetchGraceful, wcFetchPaginated, wcFetchPaginatedGraceful, wcMutate };
+}
+
+// src/integrations/woocommerce/products/queries.ts
+function buildProductQuery(base, filterParams) {
+  const query = { ...base };
+  if (!filterParams) return query;
+  if (filterParams.category !== void 0) query.category = filterParams.category;
+  if (filterParams.tag !== void 0) query.tag = filterParams.tag;
+  if (filterParams.featured !== void 0) query.featured = filterParams.featured;
+  if (filterParams.on_sale !== void 0) query.on_sale = filterParams.on_sale;
+  if (filterParams.min_price !== void 0) query.min_price = filterParams.min_price;
+  if (filterParams.max_price !== void 0) query.max_price = filterParams.max_price;
+  if (filterParams.search !== void 0) query.search = filterParams.search;
+  if (filterParams.orderby !== void 0) query.orderby = filterParams.orderby;
+  if (filterParams.order !== void 0) query.order = filterParams.order;
+  if (filterParams.stock_status !== void 0) query.stock_status = filterParams.stock_status;
+  if (filterParams.type !== void 0) query.type = filterParams.type;
+  return query;
+}
+function createProductsQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcFetchPaginated, wcFetchPaginatedGraceful } = fetcher;
+  async function getProducts(filterParams) {
+    const query = buildProductQuery({ per_page: 100, status: "publish" }, filterParams);
+    return wcFetchGraceful("/wp-json/wc/v3/products", [], query, [
+      "woocommerce",
+      "products"
+    ]);
+  }
+  async function getProductsPaginated(page = 1, perPage = 12, filterParams) {
+    const query = buildProductQuery({ per_page: perPage, page, status: "publish" }, filterParams);
+    const cacheTags = ["woocommerce", "products", `products-page-${page}`];
+    if (filterParams?.category) cacheTags.push(`products-category-${filterParams.category}`);
+    if (filterParams?.tag) cacheTags.push(`products-tag-${filterParams.tag}`);
+    if (filterParams?.search) cacheTags.push("products-search");
+    return wcFetchPaginatedGraceful("/wp-json/wc/v3/products", query, cacheTags);
+  }
+  async function getProductById(id) {
+    return wcFetch(`/wp-json/wc/v3/products/${id}`, void 0, [
+      "woocommerce",
+      "products",
+      `product-${id}`
+    ]);
+  }
+  async function getProductBySlug(slug) {
+    const products = await wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { slug },
+      ["woocommerce", "products", `product-slug-${slug}`]
+    );
+    return products[0];
+  }
+  async function getFeaturedProducts(limit = 10) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { featured: true, per_page: limit, status: "publish" },
+      ["woocommerce", "products", "featured"]
+    );
+  }
+  async function getOnSaleProducts(limit = 10) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { on_sale: true, per_page: limit, status: "publish" },
+      ["woocommerce", "products", "on-sale"]
+    );
+  }
+  async function getRelatedProducts(productId) {
+    const product = await getProductById(productId);
+    if (!product.related_ids.length) return [];
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { include: product.related_ids.join(","), per_page: 10, status: "publish" },
+      ["woocommerce", "products", `related-${productId}`]
+    );
+  }
+  async function getAllProductSlugs() {
+    try {
+      const allSlugs = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wcFetchPaginated("/wp-json/wc/v3/products", {
+          per_page: 100,
+          page,
+          status: "publish",
+          _fields: "slug"
+        });
+        allSlugs.push(...response.data.map((p) => ({ slug: p.slug })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allSlugs;
+    } catch {
+      console.warn("WooCommerce unavailable, skipping static generation for products");
+      return [];
+    }
+  }
+  async function getProductVariations(productId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/products/${productId}/variations`,
+      [],
+      { per_page: 100 },
+      ["woocommerce", "products", `product-${productId}`, "variations"]
+    );
+  }
+  async function getProductVariationById(productId, variationId) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/${productId}/variations/${variationId}`,
+      void 0,
+      ["woocommerce", "products", `product-${productId}`, `variation-${variationId}`]
+    );
+  }
+  return {
+    getProducts,
+    getProductsPaginated,
+    getProductById,
+    getProductBySlug,
+    getFeaturedProducts,
+    getOnSaleProducts,
+    getRelatedProducts,
+    getAllProductSlugs,
+    getProductVariations,
+    getProductVariationById
+  };
+}
+
+// src/integrations/woocommerce/categories/queries.ts
+function createCategoriesQueries2(fetcher) {
+  const { wcFetch, wcFetchGraceful } = fetcher;
+  async function getAllProductCategories() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/categories",
+      [],
+      { per_page: 100, hide_empty: false },
+      ["woocommerce", "product-categories"]
+    );
+  }
+  async function getProductCategoryById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/categories/${id}`,
+      void 0,
+      ["woocommerce", "product-categories", `product-category-${id}`]
+    );
+  }
+  async function getProductCategoryBySlug(slug) {
+    const categories = await wcFetchGraceful(
+      "/wp-json/wc/v3/products/categories",
+      [],
+      { slug },
+      ["woocommerce", "product-categories", `product-category-slug-${slug}`]
+    );
+    return categories[0];
+  }
+  async function getProductsByCategory(categoryId, limit = 100) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { category: categoryId, per_page: limit, status: "publish" },
+      ["woocommerce", "products", `products-category-${categoryId}`]
+    );
+  }
+  async function getProductsByCategorySlug(categorySlug) {
+    const category = await getProductCategoryBySlug(categorySlug);
+    if (!category) return [];
+    return getProductsByCategory(category.id);
+  }
+  return {
+    getAllProductCategories,
+    getProductCategoryById,
+    getProductCategoryBySlug,
+    getProductsByCategory,
+    getProductsByCategorySlug
+  };
+}
+
+// src/integrations/woocommerce/tags/queries.ts
+function createTagsQueries2(fetcher) {
+  const { wcFetch, wcFetchGraceful } = fetcher;
+  async function getAllProductTags() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/tags",
+      [],
+      { per_page: 100 },
+      ["woocommerce", "product-tags"]
+    );
+  }
+  async function getProductTagById(id) {
+    return wcFetch(`/wp-json/wc/v3/products/tags/${id}`, void 0, [
+      "woocommerce",
+      "product-tags",
+      `product-tag-${id}`
+    ]);
+  }
+  async function getProductsByTag(tagId, limit = 100) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { tag: tagId, per_page: limit },
+      ["woocommerce", "products", `products-tag-${tagId}`]
+    );
+  }
+  return {
+    getAllProductTags,
+    getProductTagById,
+    getProductsByTag
+  };
+}
+
+// src/integrations/woocommerce/orders/queries.ts
+function createOrdersQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function createOrder(input) {
+    return wcMutate("/wp-json/wc/v3/orders", input, "POST");
+  }
+  async function getOrderById(id) {
+    return wcFetch(`/wp-json/wc/v3/orders/${id}`, void 0, [
+      "woocommerce",
+      "orders",
+      `order-${id}`
+    ]);
+  }
+  async function updateOrder(id, data) {
+    return wcMutate(`/wp-json/wc/v3/orders/${id}`, data, "PUT");
+  }
+  async function getOrdersByCustomer(customerId) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/orders",
+      [],
+      { customer: customerId, per_page: 100 },
+      ["woocommerce", "orders", `orders-customer-${customerId}`]
+    );
+  }
+  return {
+    createOrder,
+    getOrderById,
+    updateOrder,
+    getOrdersByCustomer
+  };
+}
+
+// src/integrations/woocommerce/coupons/queries.ts
+function createCouponsQueries(fetcher) {
+  const { wcFetchGraceful } = fetcher;
+  async function getCouponByCode(code) {
+    const coupons = await wcFetchGraceful(
+      "/wp-json/wc/v3/coupons",
+      [],
+      { code },
+      ["woocommerce", "coupons"]
+    );
+    return coupons[0];
+  }
+  async function validateCoupon(code) {
+    const coupon = await getCouponByCode(code);
+    if (!coupon) return { valid: false, reason: "Coupon not found" };
+    if (coupon.date_expires) {
+      const expiry = new Date(coupon.date_expires);
+      if (expiry < /* @__PURE__ */ new Date()) return { valid: false, reason: "Coupon has expired", coupon };
+    }
+    if (coupon.usage_limit !== null && coupon.usage_count >= coupon.usage_limit) {
+      return { valid: false, reason: "Coupon usage limit reached", coupon };
+    }
+    return { valid: true, coupon };
+  }
+  return {
+    getCouponByCode,
+    validateCoupon
+  };
+}
+
+// src/integrations/woocommerce/customers/queries.ts
+function createCustomersQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful } = fetcher;
+  async function getCustomerById(id) {
+    return wcFetch(`/wp-json/wc/v3/customers/${id}`, void 0, [
+      "woocommerce",
+      "customers",
+      `customer-${id}`
+    ]);
+  }
+  async function getCustomerByEmail(email) {
+    const customers = await wcFetchGraceful(
+      "/wp-json/wc/v3/customers",
+      [],
+      { email },
+      ["woocommerce", "customers"]
+    );
+    return customers[0];
+  }
+  async function getCustomerByEmailNoCache(email) {
+    try {
+      const customers = await wcFetch(
+        "/wp-json/wc/v3/customers",
+        { email },
+        ["woocommerce", "customers"],
+        { cache: "no-store" }
+      );
+      return customers[0];
+    } catch {
+      return void 0;
+    }
+  }
+  async function createCustomer(data) {
+    return wcFetch(
+      "/wp-json/wc/v3/customers",
+      void 0,
+      ["woocommerce", "customers"],
+      { method: "POST", body: JSON.stringify(data) }
+    );
+  }
+  return {
+    getCustomerById,
+    getCustomerByEmail,
+    getCustomerByEmailNoCache,
+    createCustomer
+  };
+}
+
+// src/integrations/woocommerce/index.ts
+function createWooCommerceClient(config) {
+  const fetcher = createWooCommerceFetcher(config);
+  return {
+    ...createProductsQueries(fetcher),
+    ...createCategoriesQueries2(fetcher),
+    ...createTagsQueries2(fetcher),
+    ...createOrdersQueries(fetcher),
+    ...createCouponsQueries(fetcher),
+    ...createCustomersQueries(fetcher)
+  };
+}
+
+exports.buildUrl = buildUrl;
+exports.createFetcher = createFetcher;
+exports.createWooCommerceClient = createWooCommerceClient;
+exports.createWooCommerceFetcher = createWooCommerceFetcher;
+exports.createWordPressClient = createWordPressClient;
+exports.extractOmnibusData = extractOmnibusData;
+exports.resolveBaseUrl = resolveBaseUrl;
+exports.withOmnibus = withOmnibus;
+exports.withOmnibusVariation = withOmnibusVariation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map