@szymonpiatek/nextwordpress 0.0.5 → 0.0.7

package/dist/hooks/index.js

@@ -1,9 +1,115 @@
+import { createContext, useState, useCallback, useEffect, useContext, useReducer } from 'react';
+import { jsx } from 'react/jsx-runtime';
 import useSWR2 from 'swr';
 
 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/shared/url.ts
+function resolveBaseUrl(config) {
+  return typeof window === "undefined" ? config.serverURL : config.clientURL;
+}
+
+// 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;
+}
+var AuthContext = createContext(null);
+var TOKEN_KEY = "nw_auth_token";
+var USER_KEY = "nw_auth_user";
+function AuthProvider({
+  config,
+  children
+}) {
+  const [user, setUser] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const clearStorage = useCallback(() => {
+    localStorage.removeItem(TOKEN_KEY);
+    localStorage.removeItem(USER_KEY);
+  }, []);
+  useEffect(() => {
+    const token = localStorage.getItem(TOKEN_KEY);
+    const storedUser = localStorage.getItem(USER_KEY);
+    if (!token || !storedUser) {
+      setIsLoading(false);
+      return;
+    }
+    validateJwtToken(config, token).then((valid) => {
+      if (valid) {
+        setUser(JSON.parse(storedUser));
+      } else {
+        clearStorage();
+      }
+    }).catch(() => clearStorage()).finally(() => setIsLoading(false));
+  }, []);
+  const login = async (credentials) => {
+    setError(null);
+    setIsLoading(true);
+    try {
+      const response = await authenticateJwt(config, credentials);
+      const authUser = {
+        token: response.token,
+        email: response.user_email,
+        nicename: response.user_nicename,
+        displayName: response.user_display_name
+      };
+      localStorage.setItem(TOKEN_KEY, response.token);
+      localStorage.setItem(USER_KEY, JSON.stringify(authUser));
+      setUser(authUser);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Authentication failed";
+      setError(message);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const logout = () => {
+    clearStorage();
+    setUser(null);
+    setError(null);
+  };
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value: { user, isLoggedIn: !!user, isLoading, error, login, logout }, children });
+}
+function useAuth() {
+  const ctx = useContext(AuthContext);
+  if (!ctx) throw new Error("useAuth must be used within an AuthProvider");
+  return ctx;
+}
+
 // src/integrations/restApi/core/client/types.ts
 var WordPressAPIError = class extends Error {
   constructor(message, status, endpoint) {
@@ -14,11 +120,6 @@ var WordPressAPIError = class extends Error {
   }
 };
 
-// src/shared/url.ts
-function resolveBaseUrl(config) {
-  return typeof window === "undefined" ? config.serverURL : config.clientURL;
-}
-
 // src/integrations/restApi/core/client/url.ts
 function buildUrl(config, path, query) {
   const base = resolveBaseUrl(config);
@@ -47,7 +148,7 @@ async function doFetch(url, init = {}) {
   return response;
 }
 function createFetcher(config) {
-  const cacheTtl = 300;
+  const cacheTtl = config.cacheTTL ?? 300;
   async function wpFetch(path, query, tags = ["wordpress"]) {
     const url = buildUrl(config, path, query);
     const res = await doFetch(url, {
@@ -250,7 +351,7 @@ function createPostsQueries(fetcher) {
   };
 }
 
-// src/hooks/usePosts.ts
+// src/hooks/core/usePosts.ts
 function usePosts(config, filter, swrOptions) {
   const key = ["wp-posts", config.clientURL, JSON.stringify(filter ?? null)];
   return useSWR2(
@@ -313,7 +414,8 @@ function createWooCommerceFetcher(config) {
     return { ...query, consumer_key: config.consumerKey, consumer_secret: config.consumerSecret };
   }
   function buildUrl2(path, query) {
-    return `${config.serverURL}${path}?${toQueryString(withAuth(query))}`;
+    const base = typeof window !== "undefined" && config.clientURL ? config.clientURL : config.serverURL;
+    return `${base}${path}?${toQueryString(withAuth(query))}`;
   }
   async function wcFetch(path, query, tags = ["woocommerce"], options) {
     const url = buildUrl2(path, query);
@@ -505,7 +607,7 @@ function createProductsQueries(fetcher) {
   };
 }
 
-// src/hooks/useProducts.ts
+// src/hooks/woocommerce/useProducts.ts
 function useProducts(config, filter, swrOptions) {
   const key = ["wc-products", config.serverURL, JSON.stringify(filter ?? null)];
   return useSWR2(
@@ -562,6 +664,258 @@ function useFeaturedProducts(config, limit = 10, swrOptions) {
   );
 }
 
+// src/integrations/restApi/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}`]
+    );
+  }
+  async function deleteOrder(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    createOrder,
+    getOrderById,
+    updateOrder,
+    getOrdersByCustomer,
+    deleteOrder
+  };
+}
+var STORAGE_KEY = "nw-cart";
+function isSame(a, b) {
+  return a.productId === b.productId && (a.variationId ?? 0) === (b.variationId ?? 0);
+}
+function cartReducer(state, action) {
+  switch (action.type) {
+    case "LOAD":
+      return { items: action.items };
+    case "ADD": {
+      const existing = state.items.find((i) => isSame(i, action.item));
+      if (existing) {
+        return {
+          items: state.items.map(
+            (i) => isSame(i, action.item) ? { ...i, quantity: i.quantity + action.item.quantity } : i
+          )
+        };
+      }
+      return { items: [...state.items, action.item] };
+    }
+    case "REMOVE":
+      return { items: state.items.filter((i) => !isSame(i, action)) };
+    case "UPDATE":
+      if (action.quantity <= 0) {
+        return { items: state.items.filter((i) => !isSame(i, action)) };
+      }
+      return {
+        items: state.items.map(
+          (i) => isSame(i, action) ? { ...i, quantity: action.quantity } : i
+        )
+      };
+    case "CLEAR":
+      return { items: [] };
+  }
+}
+var CartContext = createContext(null);
+function CartProvider({ children }) {
+  const [state, dispatch] = useReducer(cartReducer, { items: [] });
+  useEffect(() => {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) dispatch({ type: "LOAD", items: JSON.parse(stored) });
+    } catch {
+    }
+  }, []);
+  useEffect(() => {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(state.items));
+    } catch {
+    }
+  }, [state.items]);
+  const totalItems = state.items.reduce((sum, i) => sum + i.quantity, 0);
+  const subtotal = state.items.reduce((sum, i) => sum + parseFloat(i.price) * i.quantity, 0).toFixed(2);
+  function addItem(item, quantity = 1) {
+    dispatch({ type: "ADD", item: { ...item, quantity } });
+  }
+  function removeItem(productId, variationId) {
+    dispatch({ type: "REMOVE", productId, variationId });
+  }
+  function updateQuantity(productId, quantity, variationId) {
+    dispatch({ type: "UPDATE", productId, quantity, variationId });
+  }
+  function clearCart() {
+    dispatch({ type: "CLEAR" });
+  }
+  async function checkout(config, options = {}) {
+    if (state.items.length === 0) throw new Error("Cannot checkout with an empty cart");
+    const fetcher = createWooCommerceFetcher(config);
+    const input = {
+      status: "pending",
+      line_items: state.items.map((i) => ({
+        product_id: i.productId,
+        ...i.variationId !== void 0 ? { variation_id: i.variationId } : {},
+        quantity: i.quantity
+      })),
+      ...options.billing ? { billing: options.billing } : {},
+      ...options.shipping ? { shipping: options.shipping } : {},
+      ...options.paymentMethod ? { payment_method: options.paymentMethod } : {},
+      ...options.paymentMethodTitle ? { payment_method_title: options.paymentMethodTitle } : {},
+      ...options.customerNote ? { customer_note: options.customerNote } : {},
+      ...options.couponCodes ? { coupon_lines: options.couponCodes.map((code) => ({ code })) } : {}
+    };
+    const order = await createOrdersQueries(fetcher).createOrder(input);
+    dispatch({ type: "CLEAR" });
+    return order;
+  }
+  return /* @__PURE__ */ jsx(
+    CartContext.Provider,
+    {
+      value: { items: state.items, totalItems, subtotal, isEmpty: state.items.length === 0, addItem, removeItem, updateQuantity, clearCart, checkout },
+      children
+    }
+  );
+}
+function useCart() {
+  const ctx = useContext(CartContext);
+  if (!ctx) throw new Error("useCart must be used within a CartProvider");
+  return ctx;
+}
+
+// src/integrations/restApi/woocommerce/customers/queries.ts
+function createCustomersQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = 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) }
+    );
+  }
+  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,
+    updateCustomer,
+    deleteCustomer
+  };
+}
+var CustomerContext = createContext(null);
+function WooCommerceCustomerProvider({
+  config,
+  children
+}) {
+  const { user, isLoggedIn } = useAuth();
+  const [customer, setCustomer] = useState(null);
+  const [orders, setOrders] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [tick, setTick] = useState(0);
+  const fetchData = useCallback(async () => {
+    if (!isLoggedIn || !user?.email) {
+      setCustomer(null);
+      setOrders([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const fetcher = createWooCommerceFetcher(config);
+      const foundCustomer = await createCustomersQueries(fetcher).getCustomerByEmailNoCache(user.email);
+      if (!foundCustomer) {
+        setCustomer(null);
+        setOrders([]);
+        return;
+      }
+      const customerOrders = await createOrdersQueries(fetcher).getOrdersByCustomer(foundCustomer.id);
+      setCustomer(foundCustomer);
+      setOrders(customerOrders);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load customer data");
+    } finally {
+      setIsLoading(false);
+    }
+  }, [isLoggedIn, user?.email, config, tick]);
+  useEffect(() => {
+    void fetchData();
+  }, [fetchData]);
+  const updateCustomer = async (data) => {
+    if (!customer) throw new Error("No customer loaded");
+    const fetcher = createWooCommerceFetcher(config);
+    const updated = await createCustomersQueries(fetcher).updateCustomer(customer.id, data);
+    setCustomer(updated);
+    return updated;
+  };
+  const refetch = () => setTick((t) => t + 1);
+  return /* @__PURE__ */ jsx(CustomerContext.Provider, { value: { customer, orders, isLoading, error, updateCustomer, refetch }, children });
+}
+function useCustomer() {
+  const ctx = useContext(CustomerContext);
+  if (!ctx) throw new Error("useCustomer must be used within a WooCommerceCustomerProvider");
+  return ctx;
+}
+
 // src/integrations/wpGraphQL/client/types.ts
 var WPGraphQLError = class extends Error {
   constructor(message, status, endpoint, gqlErrors) {
@@ -575,9 +929,9 @@ var WPGraphQLError = class extends Error {
 
 // src/integrations/wpGraphQL/client/fetcher.ts
 var USER_AGENT3 = "NextWordpress WPGraphQL Client";
-var CACHE_TTL = 300;
 function createWPGraphQLFetcher(config) {
   const url = `${resolveBaseUrl(config)}/graphql`;
+  const cacheTTL = config.cacheTTL ?? 300;
   async function gqlFetch(document, variables, tags = ["wpgraphql"]) {
     const response = await fetch(url, {
       method: "POST",
@@ -586,7 +940,7 @@ function createWPGraphQLFetcher(config) {
         "User-Agent": USER_AGENT3
       },
       body: JSON.stringify({ query: document, variables }),
-      next: { tags, revalidate: CACHE_TTL }
+      next: { tags, revalidate: cacheTTL }
     });
     if (!response.ok) {
       throw new WPGraphQLError(
@@ -815,7 +1169,7 @@ function createPostsQueries2(fetcher) {
   };
 }
 
-// src/hooks/useWPGraphQL.ts
+// src/hooks/wpgraphql/useWPGraphQL.ts
 function useWPGraphQL(config, query, variables, tags, swrOptions) {
   const key = ["wpgraphql", config.clientURL, query, JSON.stringify(variables ?? null)];
   return useSWR2(
@@ -850,6 +1204,6 @@ function useGQLPostBySlug(config, slug, swrOptions) {
   );
 }
 
-export { useFeaturedProducts, useGQLPostBySlug, useGQLPosts, usePost, usePostBySlug, usePosts, usePostsPaginated, useProduct, useProductBySlug, useProducts, useProductsPaginated, useWPGraphQL };
+export { AuthProvider, CartProvider, WooCommerceCustomerProvider, cartReducer, useAuth, useCart, useCustomer, useFeaturedProducts, useGQLPostBySlug, useGQLPosts, usePost, usePostBySlug, usePosts, usePostsPaginated, useProduct, useProductBySlug, useProducts, useProductsPaginated, useWPGraphQL };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map