@cimplify/sdk 0.16.3 → 0.17.0

package/dist/chunk-G6KNFYJD.mjs

@@ -0,0 +1,687 @@
+import { CatalogueQueries, CartOperations, CheckoutService, OrderQueries, LinkService, AuthService, BusinessService, InventoryService, SchedulingService, LiteService, FxService, createElements } from './chunk-GFKBH7R2.mjs';
+import { CimplifyError, ErrorCode, enrichError } from './chunk-OVM5YWM5.mjs';
+
+// src/activity.ts
+var ActivityService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  trackProductView(productId, options = {}) {
+    const event = {
+      type: "product_view",
+      product_id: productId,
+      product_name: options.productName,
+      category_id: options.categoryId,
+      price: options.price,
+      page_path: options.pagePath ?? currentPath()
+    };
+    this.sendEvents([event]);
+  }
+  trackCategoryView(categoryId, options = {}) {
+    const event = {
+      type: "category_view",
+      category_id: categoryId,
+      category_name: options.categoryName,
+      page_path: options.pagePath ?? currentPath()
+    };
+    this.sendEvents([event]);
+  }
+  sendEvents(events) {
+    try {
+      this.client.post("/api/v1/activity/events", { events }).catch(() => {
+      });
+    } catch {
+    }
+  }
+};
+function currentPath() {
+  if (typeof window !== "undefined") {
+    return window.location.pathname;
+  }
+  return void 0;
+}
+
+// src/client.ts
+var ACCESS_TOKEN_STORAGE_KEY = "cimplify_access_token";
+var SESSION_TOKEN_STORAGE_KEY = "cimplify_session_token";
+var ORDER_TOKEN_PREFIX = "cimplify_ot_";
+var SESSION_TOKEN_HEADER = "x-session-token";
+var ORDER_TOKEN_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryable(error) {
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return true;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof CimplifyError) {
+    return error.retryable;
+  }
+  return false;
+}
+function toNetworkError(error, isTestMode) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return enrichError(
+      new CimplifyError(
+        ErrorCode.TIMEOUT,
+        "Request timed out. Please check your connection and try again.",
+        true
+      ),
+      { isTestMode }
+    );
+  }
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return enrichError(
+      new CimplifyError(
+        ErrorCode.NETWORK_ERROR,
+        "Network error. Please check your internet connection.",
+        true
+      ),
+      { isTestMode }
+    );
+  }
+  if (error instanceof CimplifyError) {
+    return enrichError(error, { isTestMode });
+  }
+  return enrichError(
+    new CimplifyError(
+      ErrorCode.UNKNOWN_ERROR,
+      error instanceof Error ? error.message : "An unknown error occurred",
+      false
+    ),
+    { isTestMode }
+  );
+}
+function deriveUrls() {
+  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    const protocol = window.location.protocol;
+    return {
+      baseUrl: `${protocol}//${hostname}:8082`,
+      linkApiUrl: `${protocol}//${hostname}:8080`
+    };
+  }
+  return {
+    baseUrl: "https://storefronts.cimplify.io",
+    linkApiUrl: "https://api.cimplify.io"
+  };
+}
+function normalizeUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return trimmed;
+  return trimmed.replace(/\/+$/, "");
+}
+function getEnvPublicKey() {
+  try {
+    const env = globalThis.process;
+    return env?.env.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || void 0;
+  } catch {
+    return void 0;
+  }
+}
+var CimplifyClient = class {
+  constructor(config = {}) {
+    this.accessToken = null;
+    this.sessionToken = null;
+    this.context = {};
+    this.businessId = null;
+    this.businessIdResolvePromise = null;
+    this.inflightRequests = /* @__PURE__ */ new Map();
+    this.publicKey = config.publicKey || getEnvPublicKey() || "";
+    const urls = deriveUrls();
+    this.baseUrl = config.baseUrl ? normalizeUrl(config.baseUrl) : urls.baseUrl;
+    this.linkApiUrl = config.linkApiUrl ? normalizeUrl(config.linkApiUrl) : urls.linkApiUrl;
+    this.credentials = config.credentials || "include";
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+    this.hooks = config.hooks ?? {};
+    this.accessToken = this.loadAccessToken();
+    this.sessionToken = this.loadSessionToken();
+    if (!this.publicKey && !config.suppressPublicKeyWarning) {
+      console.warn(
+        '[Cimplify] No public key found. Set NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY in your environment, or pass { publicKey: "pk_..." } to createCimplifyClient().'
+      );
+    }
+  }
+  buildUrl(base, path) {
+    const url = `${base}${path}`;
+    const locationId = this.context.location_id;
+    if (!locationId) return url;
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}location_id=${encodeURIComponent(locationId)}`;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getPublicKey() {
+    return this.publicKey;
+  }
+  isTestMode() {
+    return this.publicKey.trim().startsWith("pk_test_");
+  }
+  setAccessToken(token) {
+    const previous = this.accessToken;
+    this.accessToken = token;
+    this.saveAccessToken(token);
+    this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: token,
+      source: "manual"
+    });
+  }
+  clearSession() {
+    const previous = this.accessToken;
+    this.accessToken = null;
+    this.sessionToken = null;
+    this.saveAccessToken(null);
+    if (typeof window !== "undefined" && window.localStorage) {
+      localStorage.removeItem(SESSION_TOKEN_STORAGE_KEY);
+    }
+    this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: null,
+      source: "clear"
+    });
+  }
+  setOrderToken(orderId, token) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const entry = JSON.stringify({ token, storedAt: Date.now() });
+        localStorage.setItem(`${ORDER_TOKEN_PREFIX}${orderId}`, entry);
+      } catch {
+      }
+    }
+  }
+  getOrderToken(orderId) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const raw = localStorage.getItem(`${ORDER_TOKEN_PREFIX}${orderId}`);
+        if (!raw) return null;
+        const entry = JSON.parse(raw);
+        if (Date.now() - entry.storedAt > ORDER_TOKEN_TTL_MS) {
+          localStorage.removeItem(`${ORDER_TOKEN_PREFIX}${orderId}`);
+          return null;
+        }
+        return entry.token;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  clearOrderTokens() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(ORDER_TOKEN_PREFIX)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((k) => localStorage.removeItem(k));
+    }
+  }
+  setLocationId(locationId) {
+    if (locationId) {
+      this.context.location_id = locationId;
+    } else {
+      delete this.context.location_id;
+    }
+  }
+  getLocationId() {
+    return this.context.location_id ?? null;
+  }
+  setBusinessId(businessId) {
+    const normalized = businessId.trim();
+    if (!normalized) {
+      return;
+    }
+    this.businessId = normalized;
+  }
+  getBusinessId() {
+    return this.businessId;
+  }
+  async resolveBusinessId() {
+    if (this.businessId) {
+      return this.businessId;
+    }
+    if (this.businessIdResolvePromise) {
+      return this.businessIdResolvePromise;
+    }
+    this.businessIdResolvePromise = (async () => {
+      const result = await this.business.getInfo();
+      if (!result.ok || !result.value?.id) {
+        throw new CimplifyError(
+          ErrorCode.NOT_FOUND,
+          "Unable to resolve business ID from the current public key.",
+          true
+        );
+      }
+      this.businessId = result.value.id;
+      return result.value.id;
+    })();
+    try {
+      return await this.businessIdResolvePromise;
+    } finally {
+      this.businessIdResolvePromise = null;
+    }
+  }
+  loadAccessToken() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return localStorage.getItem(ACCESS_TOKEN_STORAGE_KEY);
+    }
+    return null;
+  }
+  saveAccessToken(token) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        if (token) {
+          localStorage.setItem(ACCESS_TOKEN_STORAGE_KEY, token);
+        } else {
+          localStorage.removeItem(ACCESS_TOKEN_STORAGE_KEY);
+        }
+      } catch {
+      }
+    }
+  }
+  loadSessionToken() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return localStorage.getItem(SESSION_TOKEN_STORAGE_KEY);
+    }
+    return null;
+  }
+  saveSessionToken(token) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        localStorage.setItem(SESSION_TOKEN_STORAGE_KEY, token);
+      } catch {
+      }
+    }
+  }
+  captureSessionToken(response) {
+    const token = response.headers.get(SESSION_TOKEN_HEADER);
+    if (token && token !== this.sessionToken) {
+      this.sessionToken = token;
+      this.saveSessionToken(token);
+    }
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const trimmedPublicKey = this.publicKey.trim();
+    if (trimmedPublicKey) {
+      headers["X-API-Key"] = trimmedPublicKey;
+    }
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    if (this.sessionToken) {
+      headers[SESSION_TOKEN_HEADER] = this.sessionToken;
+    }
+    return headers;
+  }
+  async resilientFetch(url, options) {
+    const method = options.method || "GET";
+    const path = url.replace(this.baseUrl, "").replace(this.linkApiUrl, "");
+    const startTime = Date.now();
+    let retryCount = 0;
+    const context = {
+      method,
+      path,
+      url,
+      body: options.body ? JSON.parse(options.body) : void 0,
+      startTime
+    };
+    this.hooks.onRequestStart?.(context);
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        this.captureSessionToken(response);
+        if (response.ok) {
+          this.hooks.onRequestSuccess?.({
+            ...context,
+            status: response.status,
+            durationMs: Date.now() - startTime
+          });
+          return response;
+        }
+        if (response.status === 429 && attempt < this.maxRetries) {
+          retryCount++;
+          const retryAfter = response.headers.get("Retry-After");
+          const delay = retryAfter ? Math.min(parseInt(retryAfter, 10) * 1e3, 3e4) || this.retryDelay * Math.pow(2, attempt) : this.retryDelay * Math.pow(2, attempt);
+          this.hooks.onRetry?.({
+            ...context,
+            attempt: retryCount,
+            delayMs: delay,
+            error: new Error(`Rate limited: ${response.status}`)
+          });
+          await sleep(delay);
+          continue;
+        }
+        if (response.status >= 400 && response.status < 500) {
+          this.hooks.onRequestError?.({
+            ...context,
+            error: new CimplifyError(
+              `HTTP_${response.status}`,
+              `Request failed with status ${response.status}`,
+              false
+            ),
+            status: response.status,
+            durationMs: Date.now() - startTime,
+            retryCount,
+            retryable: false
+          });
+          return response;
+        }
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          retryCount++;
+          const delay = this.retryDelay * Math.pow(2, attempt);
+          this.hooks.onRetry?.({
+            ...context,
+            attempt: retryCount,
+            delayMs: delay,
+            error: new Error(`Server error: ${response.status}`)
+          });
+          await sleep(delay);
+          continue;
+        }
+        this.hooks.onRequestError?.({
+          ...context,
+          error: new CimplifyError(
+            "SERVER_ERROR",
+            `Server error ${response.status} after ${retryCount} retries`,
+            false
+          ),
+          status: response.status,
+          durationMs: Date.now() - startTime,
+          retryCount,
+          retryable: false
+        });
+        return response;
+      } catch (error) {
+        lastError = error;
+        const networkError = toNetworkError(error, this.isTestMode());
+        const errorRetryable = isRetryable(error);
+        if (!errorRetryable || attempt >= this.maxRetries) {
+          this.hooks.onRequestError?.({
+            ...context,
+            error: networkError,
+            durationMs: Date.now() - startTime,
+            retryCount,
+            retryable: errorRetryable
+          });
+          throw networkError;
+        }
+        retryCount++;
+        const delay = this.retryDelay * Math.pow(2, attempt);
+        this.hooks.onRetry?.({
+          ...context,
+          attempt: retryCount,
+          delayMs: delay,
+          error: networkError
+        });
+        await sleep(delay);
+      }
+    }
+    const finalError = toNetworkError(lastError, this.isTestMode());
+    this.hooks.onRequestError?.({
+      ...context,
+      error: finalError,
+      durationMs: Date.now() - startTime,
+      retryCount,
+      retryable: false
+    });
+    throw finalError;
+  }
+  getDedupeKey(type, payload) {
+    return `${type}:${JSON.stringify(payload)}`;
+  }
+  async deduplicatedRequest(key, requestFn) {
+    const existing = this.inflightRequests.get(key);
+    if (existing) {
+      return existing;
+    }
+    const request = requestFn().finally(() => {
+      this.inflightRequests.delete(key);
+    });
+    this.inflightRequests.set(key, request);
+    return request;
+  }
+  async get(path) {
+    const key = this.getDedupeKey("get", path);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
+        method: "GET",
+        credentials: this.credentials,
+        headers: this.getHeaders()
+      });
+      return this.handleRestResponse(response);
+    });
+  }
+  async post(path, body) {
+    const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
+  async patch(path, body) {
+    const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
+      method: "PATCH",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
+  async delete(path) {
+    const response = await this.resilientFetch(this.buildUrl(this.baseUrl, path), {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    return this.handleRestResponse(response);
+  }
+  async linkGet(path) {
+    const key = this.getDedupeKey("linkGet", path);
+    return this.deduplicatedRequest(key, async () => {
+      const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+        method: "GET",
+        credentials: this.credentials,
+        headers: this.getHeaders()
+      });
+      return this.handleRestResponse(response);
+    });
+  }
+  async linkPost(path, body) {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
+  async linkDelete(path) {
+    const response = await this.resilientFetch(`${this.linkApiUrl}${path}`, {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    return this.handleRestResponse(response);
+  }
+  async handleRestResponse(response) {
+    const json = await response.json();
+    if (!response.ok) {
+      const errorCode = typeof json.error === "object" && json.error?.error_code || typeof json.error === "object" && json.error?.code || "API_ERROR";
+      const errorMessage = typeof json.error === "object" && json.error?.error_message || typeof json.error === "object" && json.error?.message || typeof json.error === "string" && json.error || typeof json.message === "string" && json.message || "An error occurred";
+      const retryable = typeof json.error === "object" && typeof json.error?.retryable === "boolean" ? json.error.retryable : false;
+      const error = enrichError(
+        new CimplifyError(
+          errorCode,
+          errorMessage,
+          retryable
+        ),
+        { isTestMode: this.isTestMode() }
+      );
+      if (response.status === 401 || error.code === ErrorCode.UNAUTHORIZED) {
+        console.warn(
+          "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
+        );
+      }
+      throw error;
+    }
+    if (json?.success === false || json?.error?.code || json?.error?.message) {
+      const error = enrichError(
+        new CimplifyError(
+          json.error?.code || "API_ERROR",
+          json.error?.message || "An error occurred",
+          json.error?.retryable || false
+        ),
+        { isTestMode: this.isTestMode() }
+      );
+      throw error;
+    }
+    if (json?.data !== void 0) {
+      return json.data;
+    }
+    return json;
+  }
+  get catalogue() {
+    if (!this._catalogue) {
+      this._catalogue = new CatalogueQueries(this);
+    }
+    return this._catalogue;
+  }
+  get cart() {
+    if (!this._cart) {
+      this._cart = new CartOperations(this);
+    }
+    return this._cart;
+  }
+  get checkout() {
+    if (!this._checkout) {
+      this._checkout = new CheckoutService(this);
+    }
+    return this._checkout;
+  }
+  get orders() {
+    if (!this._orders) {
+      this._orders = new OrderQueries(this);
+    }
+    return this._orders;
+  }
+  get link() {
+    if (!this._link) {
+      this._link = new LinkService(this);
+    }
+    return this._link;
+  }
+  get auth() {
+    if (!this._auth) {
+      this._auth = new AuthService(this);
+    }
+    return this._auth;
+  }
+  get business() {
+    if (!this._business) {
+      this._business = new BusinessService(this);
+    }
+    return this._business;
+  }
+  get inventory() {
+    if (!this._inventory) {
+      this._inventory = new InventoryService(this);
+    }
+    return this._inventory;
+  }
+  get scheduling() {
+    if (!this._scheduling) {
+      this._scheduling = new SchedulingService(this);
+    }
+    return this._scheduling;
+  }
+  get lite() {
+    if (!this._lite) {
+      this._lite = new LiteService(this);
+    }
+    return this._lite;
+  }
+  get fx() {
+    if (!this._fx) {
+      this._fx = new FxService(this);
+    }
+    return this._fx;
+  }
+  get activity() {
+    if (!this._activity) {
+      this._activity = new ActivityService(this);
+    }
+    return this._activity;
+  }
+  elements(businessId, options) {
+    if (businessId) {
+      this.setBusinessId(businessId);
+    }
+    return createElements(this, businessId ?? this.businessId ?? void 0, options);
+  }
+};
+function createCimplifyClient(config = {}) {
+  return new CimplifyClient(config);
+}
+
+// src/utils/variant.ts
+function stripProductPrefix(variantName, productName) {
+  if (!variantName || !productName) return variantName || productName;
+  const lower = variantName.toLowerCase().trim();
+  if (lower === "default" || lower === "standard") return productName;
+  if (lower.endsWith("-default") || lower.endsWith("-standard")) return productName;
+  if (variantName.startsWith(productName)) {
+    const rest = variantName.slice(productName.length);
+    const match = rest.match(/^\s*[-–—]\s*(.*)/);
+    if (match && match[1].length > 0) return match[1];
+  }
+  const lowerProduct = productName.toLowerCase().trim();
+  if (lower.startsWith(lowerProduct)) {
+    const rest = variantName.slice(productName.length);
+    const match = rest.match(/^\s*[-–—]\s*(.*)/);
+    if (match && match[1].length > 0) return match[1];
+  }
+  const lastDash = variantName.lastIndexOf("-");
+  if (lastDash > 0 && lastDash < variantName.length - 1) {
+    const prefix = variantName.slice(0, lastDash).trim();
+    const suffix = variantName.slice(lastDash + 1).trim();
+    if (suffix.length > 0 && prefix.length > suffix.length * 2) {
+      return suffix;
+    }
+  }
+  return variantName;
+}
+function getVariantDisplayName(variant, productName) {
+  if (variant.display_attributes?.length) {
+    return variant.display_attributes.map((a) => a.value_name).join(" / ");
+  }
+  if (variant.name) {
+    return productName ? stripProductPrefix(variant.name, productName) : variant.name;
+  }
+  return productName || (variant.is_default ? "Default" : "Option");
+}
+
+export { ActivityService, CimplifyClient, createCimplifyClient, getVariantDisplayName };