@behio/storefront-sdk 0.1.0

package/dist/chunk-3OJEEMLI.mjs

@@ -0,0 +1,609 @@
+// src/types.ts
+var ProductSort = {
+  PRICE_ASC: "price_asc",
+  PRICE_DESC: "price_desc",
+  NAME_ASC: "name_asc",
+  NAME_DESC: "name_desc",
+  NEWEST: "newest",
+  FEATURED: "featured"
+};
+var OrderStatuses = {
+  PENDING: "PENDING",
+  CONFIRMED: "CONFIRMED",
+  PROCESSING: "PROCESSING",
+  SHIPPED: "SHIPPED",
+  DELIVERED: "DELIVERED",
+  CANCELLED: "CANCELLED",
+  REFUNDED: "REFUNDED"
+};
+var PaymentStatuses = {
+  UNPAID: "UNPAID",
+  PAID: "PAID",
+  PARTIALLY_REFUNDED: "PARTIALLY_REFUNDED",
+  REFUNDED: "REFUNDED"
+};
+var FulfillmentStatuses = {
+  UNFULFILLED: "UNFULFILLED",
+  PARTIALLY_FULFILLED: "PARTIALLY_FULFILLED",
+  FULFILLED: "FULFILLED"
+};
+var AddressTypes = {
+  SHIPPING: "SHIPPING",
+  BILLING: "BILLING"
+};
+var BehioApiError = class _BehioApiError extends Error {
+  constructor(status, body, message) {
+    super(message || `API Error ${status}`);
+    this.name = "BehioApiError";
+    this.status = status;
+    this.body = body;
+    this.code = _BehioApiError.resolveCode(status, body);
+    this.isRetryable = status >= 500 || status === 429;
+  }
+  static resolveCode(status, body) {
+    if (status === 401) return "UNAUTHORIZED";
+    if (status === 403) return "FORBIDDEN";
+    if (status === 404) return "NOT_FOUND";
+    if (status === 409) return "EMAIL_ALREADY_EXISTS";
+    if (status === 429) return "RATE_LIMITED";
+    if (status >= 500) return "INTERNAL_ERROR";
+    const msg = (body?.message || "").toLowerCase();
+    if (msg.includes("invalid") && msg.includes("password")) return "INVALID_CREDENTIALS";
+    if (msg.includes("invalid") && msg.includes("email")) return "INVALID_CREDENTIALS";
+    if (msg.includes("cart") && msg.includes("empty")) return "CART_EMPTY";
+    if (msg.includes("product") && msg.includes("not found")) return "PRODUCT_NOT_FOUND";
+    if (msg.includes("discount") && msg.includes("expired")) return "DISCOUNT_EXPIRED";
+    if (msg.includes("discount") && msg.includes("invalid")) return "INVALID_DISCOUNT";
+    if (msg.includes("token") && msg.includes("expired")) return "TOKEN_EXPIRED";
+    if (msg.includes("cancel")) return "ORDER_NOT_CANCELLABLE";
+    if (status === 400) return "VALIDATION_ERROR";
+    return "UNKNOWN";
+  }
+  /** Check if this is a specific error type */
+  is(code) {
+    return this.code === code;
+  }
+};
+var BehioNetworkError = class extends Error {
+  constructor(message, isTimeout = false) {
+    super(message);
+    this.isRetryable = true;
+    this.name = "BehioNetworkError";
+    this.code = isTimeout ? "TIMEOUT" : "NETWORK_ERROR";
+  }
+};
+
+// src/client.ts
+var BehioStorefront = class {
+  constructor(config) {
+    // Token refresh lock
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    // Event emitter
+    this.listeners = /* @__PURE__ */ new Map();
+    // Interceptors
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+    // Rate limit tracking
+    this.rateLimitRemaining = null;
+    this.rateLimitReset = null;
+    this.baseUrl = (config.baseUrl || "https://api.behio.com").replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.defaultLocale = config.locale;
+    this.defaultCurrency = config.currency;
+    this.fetchFn = config.fetch || globalThis.fetch;
+    this.timeout = config.timeout ?? 3e4;
+    this.retries = config.retries ?? 1;
+    this.retryDelay = config.retryDelay ?? 1e3;
+    this.catalog = new CatalogModule(this);
+    this.auth = new AuthModule(this);
+    this.cart = new CartModule(this);
+    this.checkout = new CheckoutModule(this);
+    this.orders = new OrdersModule(this);
+    this.customer = new CustomerModule(this);
+    this.pages = new PagesModule(this);
+  }
+  // --- Public methods ---
+  /** Get basic shop info */
+  async getShopInfo() {
+    return this.request("GET", "/shop");
+  }
+  /** Set auth tokens (e.g. from localStorage) */
+  setTokens(tokens) {
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken;
+  }
+  /** Clear auth tokens */
+  clearTokens() {
+    this.accessToken = void 0;
+    this.refreshToken = void 0;
+  }
+  /** Get current access token */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /** Get current refresh token */
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  /** Set cart session token (e.g. from cookie) */
+  setCartSession(token) {
+    this.cartSession = token;
+  }
+  /** Get cart session token */
+  getCartSession() {
+    return this.cartSession;
+  }
+  /** Clear cart session */
+  clearCartSession() {
+    this.cartSession = void 0;
+  }
+  // --- Event emitter ---
+  /** Subscribe to SDK events. Returns an unsubscribe function. */
+  on(event, handler) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(handler);
+    return () => {
+      this.listeners.get(event)?.delete(handler);
+    };
+  }
+  /** @internal Emit an event (fire-and-forget, handler errors are swallowed) */
+  emit(event, data) {
+    this.listeners.get(event)?.forEach((fn) => {
+      try {
+        fn(data);
+      } catch {
+      }
+    });
+  }
+  // --- Interceptors ---
+  /** Add a request interceptor. Returns an unsubscribe function. */
+  addRequestInterceptor(fn) {
+    this.requestInterceptors.push(fn);
+    return () => {
+      this.requestInterceptors = this.requestInterceptors.filter((f) => f !== fn);
+    };
+  }
+  /** Add a response interceptor. Returns an unsubscribe function. */
+  addResponseInterceptor(fn) {
+    this.responseInterceptors.push(fn);
+    return () => {
+      this.responseInterceptors = this.responseInterceptors.filter((f) => f !== fn);
+    };
+  }
+  // --- Rate limit ---
+  /** Get current rate limit info from latest response headers */
+  getRateLimitInfo() {
+    return { remaining: this.rateLimitRemaining, reset: this.rateLimitReset };
+  }
+  // --- Token refresh ---
+  async handleTokenRefresh() {
+    if (this.isRefreshing) {
+      if (this.refreshPromise) await this.refreshPromise;
+      return;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        await this.auth.refresh();
+        this.emit("auth:token-refresh");
+      } catch {
+        this.clearTokens();
+        this.emit("auth:token-refresh-failed");
+        throw new BehioApiError(401, null, "Token refresh failed");
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  // --- Internal fetch ---
+  /** @internal */
+  async request(method, path, options) {
+    const url = new URL(`${this.baseUrl}/storefront/v1${path}`);
+    if (options?.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0 && value !== null && value !== "") {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    if (this.defaultLocale && !url.searchParams.has("locale")) {
+      url.searchParams.set("locale", this.defaultLocale);
+    }
+    if (this.defaultCurrency && !url.searchParams.has("currency")) {
+      url.searchParams.set("currency", this.defaultCurrency);
+    }
+    const headers = {
+      "X-Api-Key": this.apiKey,
+      "Content-Type": "application/json"
+    };
+    if (this.accessToken && options?.auth !== false) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    if (this.cartSession) {
+      headers["X-Cart-Session"] = this.cartSession;
+    }
+    const bodyStr = options?.body ? JSON.stringify(options.body) : void 0;
+    let interceptedConfig = {
+      url: url.toString(),
+      method,
+      headers,
+      body: bodyStr
+    };
+    for (const interceptor of this.requestInterceptors) {
+      interceptedConfig = await interceptor(interceptedConfig);
+    }
+    this.emit("request", { method, path });
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          clearTimeout(timeoutId);
+          throw new BehioNetworkError("Request aborted", false);
+        }
+        options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+      let res;
+      try {
+        res = await this.fetchFn(interceptedConfig.url, {
+          method: interceptedConfig.method,
+          headers: interceptedConfig.headers,
+          body: interceptedConfig.body,
+          signal: controller.signal
+        });
+      } catch (err) {
+        clearTimeout(timeoutId);
+        const isAbort = err instanceof DOMException && err.name === "AbortError";
+        const networkErr = new BehioNetworkError(
+          isAbort ? "Request timed out" : err.message || "Network error",
+          isAbort
+        );
+        this.emit("error", networkErr);
+        if (attempt < this.retries) {
+          await new Promise((r) => setTimeout(r, this.retryDelay * (attempt + 1)));
+          continue;
+        }
+        throw networkErr;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      const remaining = res.headers.get("X-RateLimit-Remaining");
+      const reset = res.headers.get("X-RateLimit-Reset");
+      if (remaining) this.rateLimitRemaining = parseInt(remaining, 10);
+      if (reset) this.rateLimitReset = parseInt(reset, 10);
+      if (this.rateLimitRemaining !== null && this.rateLimitRemaining <= 5) {
+        this.emit("rate-limit-warning", { remaining: this.rateLimitRemaining, reset: this.rateLimitReset });
+      }
+      this.emit("response", { method, path, status: res.status });
+      if (!res.ok) {
+        const body = await res.json().catch(() => null);
+        const apiError = new BehioApiError(res.status, body, body?.message || `API Error ${res.status}`);
+        if (res.status === 401 && this.refreshToken && options?.auth !== false && !options?._isRetryAfterRefresh) {
+          try {
+            await this.handleTokenRefresh();
+            return this.request(method, path, { ...options, _isRetryAfterRefresh: true });
+          } catch {
+            this.emit("error", apiError);
+            throw apiError;
+          }
+        }
+        this.emit("error", apiError);
+        if (attempt < this.retries && apiError.isRetryable) {
+          await new Promise((r) => setTimeout(r, this.retryDelay * (attempt + 1)));
+          continue;
+        }
+        throw apiError;
+      }
+      const responseData = res.status === 204 ? null : await res.json();
+      for (const interceptor of this.responseInterceptors) {
+        try {
+          await interceptor({ status: res.status, data: responseData, headers: res.headers });
+        } catch {
+        }
+      }
+      return responseData;
+    }
+    throw new BehioNetworkError("Request failed after retries");
+  }
+};
+var CatalogModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List products with filtering, pagination, search */
+  async getProducts(query) {
+    const q = {};
+    if (query) {
+      if (query.page) q.page = query.page;
+      if (query.limit) q.limit = query.limit;
+      if (query.category) q.category = query.category;
+      if (query.label) q.label = query.label;
+      if (query.priceMin) q.priceMin = query.priceMin;
+      if (query.priceMax) q.priceMax = query.priceMax;
+      if (query.currency) q.currency = query.currency;
+      if (query.locale) q.locale = query.locale;
+      if (query.sort) q.sort = query.sort;
+      if (query.inStock !== void 0) q.inStock = query.inStock;
+      if (query.search) q.search = query.search;
+      if (query.customFields) q.customFields = JSON.stringify(query.customFields);
+    }
+    return this.client.request("GET", "/catalog/products", { query: q });
+  }
+  /** Get product detail by slug */
+  async getProduct(slug, options) {
+    return this.client.request("GET", `/catalog/products/${slug}`, {
+      query: { locale: options?.locale, currency: options?.currency }
+    });
+  }
+  /** Get category tree */
+  async getCategories(locale) {
+    const res = await this.client.request("GET", "/catalog/categories", { query: { locale } });
+    return { categories: res.categories || res.items || [] };
+  }
+  /** Get category detail by slug */
+  async getCategory(slug, locale) {
+    return this.client.request("GET", `/catalog/categories/${slug}`, { query: { locale } });
+  }
+  /** Get products in a category */
+  async getCategoryProducts(slug, query) {
+    const q = {};
+    if (query) {
+      if (query.page) q.page = query.page;
+      if (query.limit) q.limit = query.limit;
+      if (query.sort) q.sort = query.sort;
+      if (query.locale) q.locale = query.locale;
+      if (query.currency) q.currency = query.currency;
+    }
+    return this.client.request("GET", `/catalog/categories/${slug}/products`, { query: q });
+  }
+  /** Get all labels */
+  async getLabels(locale) {
+    const res = await this.client.request("GET", "/catalog/labels", { query: { locale } });
+    return { labels: res.labels || res.items || [] };
+  }
+  /** Get featured products */
+  async getFeatured(options) {
+    return this.client.request("GET", "/catalog/featured", {
+      query: { locale: options?.locale, currency: options?.currency }
+    });
+  }
+  /** Get available filter fields for dynamic filter UI */
+  async getFilters() {
+    return this.client.request("GET", "/catalog/filters");
+  }
+  /** Search products */
+  async search(query, options) {
+    return this.getProducts({ search: query, ...options });
+  }
+};
+var AuthModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Register a new customer */
+  async register(input) {
+    const tokens = await this.client.request("POST", "/auth/register", {
+      body: input,
+      auth: false
+    });
+    this.client.setTokens(tokens);
+    this.client.emit("auth:login", { email: input.email });
+    return tokens;
+  }
+  /** Login with email and password */
+  async login(input) {
+    const tokens = await this.client.request("POST", "/auth/login", {
+      body: input,
+      auth: false
+    });
+    this.client.setTokens(tokens);
+    this.client.emit("auth:login", { email: input.email });
+    return tokens;
+  }
+  /** Refresh access token using refresh token */
+  async refresh(refreshToken) {
+    const token = refreshToken || this.client.getRefreshToken();
+    if (!token) throw new Error("No refresh token available");
+    const tokens = await this.client.request("POST", "/auth/refresh", {
+      body: { refreshToken: token },
+      auth: false
+    });
+    this.client.setTokens(tokens);
+    return tokens;
+  }
+  /** Logout (invalidate refresh token) */
+  async logout(refreshToken) {
+    const token = refreshToken || this.client.getRefreshToken();
+    const result = await this.client.request("POST", "/auth/logout", {
+      body: { refreshToken: token }
+    });
+    this.client.clearTokens();
+    this.client.emit("auth:logout");
+    return result;
+  }
+  /** Request password reset email */
+  async forgotPassword(email) {
+    return this.client.request("POST", "/auth/forgot-password", {
+      body: { email },
+      auth: false
+    });
+  }
+  /** Reset password with token */
+  async resetPassword(token, newPassword) {
+    return this.client.request("POST", "/auth/reset-password", {
+      body: { token, newPassword },
+      auth: false
+    });
+  }
+  /** Verify email with token */
+  async verifyEmail(token) {
+    return this.client.request("POST", "/auth/verify-email", {
+      body: { token },
+      auth: false
+    });
+  }
+  /** Check if user is logged in (has access token) */
+  isLoggedIn() {
+    return !!this.client.getAccessToken();
+  }
+};
+var CartModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get current cart */
+  async get() {
+    return this.client.request("GET", "/cart");
+  }
+  /** Add item to cart */
+  async addItem(input) {
+    const result = await this.client.request("POST", "/cart/items", {
+      body: { whItemId: input.productId, quantity: input.quantity }
+    });
+    if (result.newSessionToken) {
+      this.client.setCartSession(result.newSessionToken);
+    }
+    this.client.emit("cart:updated", result);
+    return result;
+  }
+  /** Update item quantity */
+  async updateQuantity(itemId, quantity) {
+    const result = await this.client.request("PATCH", `/cart/items/${itemId}`, {
+      body: { quantity }
+    });
+    this.client.emit("cart:updated", result);
+    return result;
+  }
+  /** Remove item from cart */
+  async removeItem(itemId) {
+    const result = await this.client.request("DELETE", `/cart/items/${itemId}`);
+    this.client.emit("cart:updated", result);
+    return result;
+  }
+  /** Clear entire cart */
+  async clear() {
+    const result = await this.client.request("DELETE", "/cart");
+    this.client.emit("cart:cleared");
+    return result;
+  }
+  /** Merge anonymous cart into authenticated customer cart */
+  async merge() {
+    const result = await this.client.request("POST", "/cart/merge");
+    this.client.emit("cart:updated", result);
+    return result;
+  }
+  /** Apply discount code */
+  async applyDiscount(code) {
+    const result = await this.client.request("POST", "/cart/discount", {
+      body: { code }
+    });
+    this.client.emit("cart:updated", result);
+    return result;
+  }
+  /** Remove discount code */
+  async removeDiscount() {
+    const result = await this.client.request("DELETE", "/cart/discount");
+    this.client.emit("cart:updated", result);
+    return result;
+  }
+};
+var CheckoutModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create order from cart */
+  async createOrder(input) {
+    const result = await this.client.request("POST", "/checkout", {
+      body: input
+    });
+    this.client.clearCartSession();
+    this.client.emit("order:created", result);
+    this.client.emit("cart:cleared");
+    return result;
+  }
+};
+var OrdersModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List customer orders (requires auth) */
+  async list(options) {
+    return this.client.request("GET", "/orders", {
+      query: { page: options?.page, limit: options?.limit }
+    });
+  }
+  /** Get order detail (requires auth) */
+  async get(orderNumber) {
+    return this.client.request("GET", `/orders/${orderNumber}`);
+  }
+  /** Cancel a PENDING order (requires auth) */
+  async cancel(orderNumber) {
+    return this.client.request("POST", `/orders/${orderNumber}/cancel`);
+  }
+  /** Track order by tracking token (no auth required) */
+  async track(trackingToken) {
+    return this.client.request("GET", `/orders/track/${trackingToken}`, { auth: false });
+  }
+};
+var CustomerModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get customer profile */
+  async getProfile() {
+    return this.client.request("GET", "/customer/profile");
+  }
+  /** Update customer profile */
+  async updateProfile(data) {
+    return this.client.request("PATCH", "/customer/profile", { body: data });
+  }
+  /** Change password */
+  async changePassword(currentPassword, newPassword) {
+    return this.client.request("PUT", "/customer/password", {
+      body: { currentPassword, newPassword }
+    });
+  }
+  /** List addresses */
+  async getAddresses() {
+    return this.client.request("GET", "/customer/addresses");
+  }
+  /** Create address */
+  async createAddress(address) {
+    return this.client.request("POST", "/customer/addresses", { body: address });
+  }
+  /** Update address */
+  async updateAddress(addressId, data) {
+    return this.client.request("PATCH", `/customer/addresses/${addressId}`, { body: data });
+  }
+  /** Delete address */
+  async deleteAddress(addressId) {
+    return this.client.request("DELETE", `/customer/addresses/${addressId}`);
+  }
+};
+var PagesModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List CMS pages */
+  async list(locale) {
+    return this.client.request("GET", "/pages", { query: { locale } });
+  }
+  /** Get page by slug */
+  async get(slug, locale) {
+    return this.client.request("GET", `/pages/${slug}`, { query: { locale } });
+  }
+};
+
+export {
+  ProductSort,
+  OrderStatuses,
+  PaymentStatuses,
+  FulfillmentStatuses,
+  AddressTypes,
+  BehioApiError,
+  BehioNetworkError,
+  BehioStorefront
+};