@commercengine/storefront-sdk-nextjs 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/client.js

@@ -0,0 +1,398 @@
+"use client";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/sdk-manager.ts
+import { cache } from "react";
+import {
+  StorefrontSDK,
+  MemoryTokenStorage,
+  Environment
+} from "@commercengine/storefront-sdk";
+
+// src/token-storage.ts
+var ClientTokenStorage = class {
+  constructor(options = {}) {
+    const prefix = options.prefix || "ce_";
+    this.accessTokenKey = `${prefix}access_token`;
+    this.refreshTokenKey = `${prefix}refresh_token`;
+    this.options = {
+      maxAge: options.maxAge || 30 * 24 * 60 * 60,
+      // 30 days default
+      path: options.path || "/",
+      domain: options.domain,
+      secure: options.secure ?? (typeof window !== "undefined" && window.location?.protocol === "https:"),
+      sameSite: options.sameSite || "Lax"
+    };
+  }
+  async getAccessToken() {
+    return this.getCookie(this.accessTokenKey);
+  }
+  async setAccessToken(token) {
+    this.setCookie(this.accessTokenKey, token);
+  }
+  async getRefreshToken() {
+    return this.getCookie(this.refreshTokenKey);
+  }
+  async setRefreshToken(token) {
+    this.setCookie(this.refreshTokenKey, token);
+  }
+  async clearTokens() {
+    this.deleteCookie(this.accessTokenKey);
+    this.deleteCookie(this.refreshTokenKey);
+  }
+  getCookie(name) {
+    if (typeof document === "undefined") return null;
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      const cookieValue = parts.pop()?.split(";").shift();
+      return cookieValue ? decodeURIComponent(cookieValue) : null;
+    }
+    return null;
+  }
+  setCookie(name, value) {
+    if (typeof document === "undefined") return;
+    const encodedValue = encodeURIComponent(value);
+    let cookieString = `${name}=${encodedValue}`;
+    if (this.options.maxAge) {
+      cookieString += `; Max-Age=${this.options.maxAge}`;
+    }
+    if (this.options.path) {
+      cookieString += `; Path=${this.options.path}`;
+    }
+    if (this.options.domain) {
+      cookieString += `; Domain=${this.options.domain}`;
+    }
+    if (this.options.secure) {
+      cookieString += `; Secure`;
+    }
+    if (this.options.sameSite) {
+      cookieString += `; SameSite=${this.options.sameSite}`;
+    }
+    document.cookie = cookieString;
+  }
+  deleteCookie(name) {
+    if (typeof document === "undefined") return;
+    let cookieString = `${name}=; Max-Age=0`;
+    if (this.options.path) {
+      cookieString += `; Path=${this.options.path}`;
+    }
+    if (this.options.domain) {
+      cookieString += `; Domain=${this.options.domain}`;
+    }
+    document.cookie = cookieString;
+  }
+};
+var ServerTokenStorage = class {
+  constructor(cookieStore, options = {}) {
+    const prefix = options.prefix || "ce_";
+    this.accessTokenKey = `${prefix}access_token`;
+    this.refreshTokenKey = `${prefix}refresh_token`;
+    this.cookieStore = cookieStore;
+    this.options = {
+      maxAge: options.maxAge || 30 * 24 * 60 * 60,
+      // 30 days default
+      path: options.path || "/",
+      domain: options.domain,
+      secure: options.secure ?? process.env.NODE_ENV === "production",
+      sameSite: options.sameSite || "Lax"
+    };
+  }
+  async getAccessToken() {
+    try {
+      return this.cookieStore.get(this.accessTokenKey)?.value || null;
+    } catch (error) {
+      console.warn(`Could not get access token from server cookies:`, error);
+      return null;
+    }
+  }
+  async setAccessToken(token) {
+    try {
+      this.cookieStore.set(this.accessTokenKey, token, {
+        maxAge: this.options.maxAge,
+        path: this.options.path,
+        domain: this.options.domain,
+        secure: this.options.secure,
+        sameSite: this.options.sameSite?.toLowerCase(),
+        httpOnly: false
+        // Allow client-side access for SDK flexibility
+      });
+    } catch (error) {
+      console.warn(`Could not set access token on server:`, error);
+    }
+  }
+  async getRefreshToken() {
+    try {
+      return this.cookieStore.get(this.refreshTokenKey)?.value || null;
+    } catch (error) {
+      console.warn(`Could not get refresh token from server cookies:`, error);
+      return null;
+    }
+  }
+  async setRefreshToken(token) {
+    try {
+      this.cookieStore.set(this.refreshTokenKey, token, {
+        maxAge: this.options.maxAge,
+        path: this.options.path,
+        domain: this.options.domain,
+        secure: this.options.secure,
+        sameSite: this.options.sameSite?.toLowerCase(),
+        httpOnly: false
+        // Allow client-side access for SDK flexibility
+      });
+    } catch (error) {
+      console.warn(`Could not set refresh token on server:`, error);
+    }
+  }
+  async clearTokens() {
+    try {
+      this.cookieStore.delete(this.accessTokenKey);
+      this.cookieStore.delete(this.refreshTokenKey);
+    } catch (error) {
+      console.warn(`Could not clear tokens on server:`, error);
+    }
+  }
+};
+
+// src/build-token-cache.ts
+var store = /* @__PURE__ */ new Map();
+function isExpired(token) {
+  if (!token) return true;
+  if (!token.expiresAt) return false;
+  return Date.now() > token.expiresAt - 3e4;
+}
+function getCachedToken(key) {
+  const token = store.get(key);
+  return isExpired(token) ? null : token;
+}
+function setCachedToken(key, token) {
+  const expiresAt = token.ttlSeconds != null ? Date.now() + token.ttlSeconds * 1e3 : void 0;
+  store.set(key, {
+    accessToken: token.accessToken,
+    refreshToken: token.refreshToken ?? null,
+    expiresAt
+  });
+}
+function clearCachedToken(key) {
+  store.delete(key);
+}
+
+// src/build-caching-memory-storage.ts
+var DEFAULT_TTL_SECONDS = 5 * 60;
+var BuildCachingMemoryTokenStorage = class {
+  constructor(cacheKey, ttlSeconds = DEFAULT_TTL_SECONDS) {
+    this.cacheKey = cacheKey;
+    this.ttlSeconds = ttlSeconds;
+    this.access = null;
+    this.refresh = null;
+  }
+  async getAccessToken() {
+    if (this.access) {
+      console.log(`\u{1F535} [BuildCache] Using instance token for key: ${this.cacheKey}`);
+      return this.access;
+    }
+    const cached = getCachedToken(this.cacheKey);
+    if (cached?.accessToken) {
+      console.log(`\u{1F7E2} [BuildCache] Using cached token for key: ${this.cacheKey}`);
+      this.access = cached.accessToken;
+      this.refresh = cached.refreshToken ?? null;
+      return this.access;
+    }
+    console.log(`\u{1F7E1} [BuildCache] No cached token found for key: ${this.cacheKey}`);
+    return null;
+  }
+  async setAccessToken(token) {
+    console.log(`\u{1F7E0} [BuildCache] Caching new access token for key: ${this.cacheKey}`);
+    this.access = token;
+    setCachedToken(this.cacheKey, {
+      accessToken: token,
+      refreshToken: this.refresh,
+      ttlSeconds: this.ttlSeconds
+    });
+  }
+  async getRefreshToken() {
+    return this.refresh;
+  }
+  async setRefreshToken(token) {
+    this.refresh = token;
+    setCachedToken(this.cacheKey, {
+      accessToken: this.access ?? "",
+      refreshToken: token,
+      ttlSeconds: this.ttlSeconds
+    });
+  }
+  async clearTokens() {
+    this.access = null;
+    this.refresh = null;
+    clearCachedToken(this.cacheKey);
+  }
+};
+
+// src/sdk-manager.ts
+var globalConfig = null;
+function getEnvConfig() {
+  return {
+    storeId: process.env.NEXT_PUBLIC_STORE_ID || "",
+    environment: process.env.NEXT_PUBLIC_ENVIRONMENT === "production" ? Environment.Production : Environment.Staging,
+    apiKey: process.env.NEXT_PUBLIC_API_KEY
+  };
+}
+function getConfig() {
+  if (globalConfig) {
+    return globalConfig;
+  }
+  return getEnvConfig();
+}
+var clientSDK = null;
+function hasRequestContext() {
+  try {
+    const { cookies } = __require("next/headers");
+    cookies();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createTokenStorage(cookieStore, options, config) {
+  if (typeof window !== "undefined") {
+    return new ClientTokenStorage(options);
+  }
+  if (cookieStore) {
+    return new ServerTokenStorage(cookieStore, options);
+  }
+  const shouldCache = process.env.NEXT_BUILD_CACHE_TOKENS === "true";
+  if (shouldCache && config) {
+    const cacheKey = `${config.storeId}:${config.environment || "production"}`;
+    console.log(`\u{1F680} [BuildCache] Using BuildCachingMemoryTokenStorage with key: ${cacheKey}`);
+    return new BuildCachingMemoryTokenStorage(cacheKey);
+  }
+  console.log(`\u{1F504} [Build] Using standard MemoryTokenStorage (caching disabled)`);
+  return new MemoryTokenStorage();
+}
+var getServerSDKCached = cache((cookieStore) => {
+  const config = getEnvConfig();
+  return new StorefrontSDK({
+    ...config,
+    tokenStorage: createTokenStorage(
+      cookieStore,
+      config.tokenStorageOptions,
+      config
+    )
+  });
+});
+var buildTimeSDK = null;
+function getBuildTimeSDK() {
+  const config = getEnvConfig();
+  if (!buildTimeSDK) {
+    buildTimeSDK = new StorefrontSDK({
+      ...config,
+      tokenStorage: createTokenStorage(
+        void 0,
+        config.tokenStorageOptions,
+        config
+      )
+    });
+  }
+  return buildTimeSDK;
+}
+function getStorefrontSDK(cookieStore) {
+  if (typeof window !== "undefined") {
+    if (cookieStore) {
+      console.warn(
+        "Cookie store passed in client environment - this will be ignored"
+      );
+    }
+    const config = getConfig();
+    if (!clientSDK) {
+      clientSDK = new StorefrontSDK({
+        ...config,
+        tokenStorage: createTokenStorage(
+          void 0,
+          config.tokenStorageOptions,
+          config
+        )
+      });
+    }
+    return clientSDK;
+  }
+  if (cookieStore) {
+    return getServerSDKCached(cookieStore);
+  }
+  if (hasRequestContext()) {
+    let autoDetectMessage = "";
+    try {
+      __require.resolve("next/headers");
+      autoDetectMessage = `
+
+\u{1F50D} Auto-detection attempted but failed. You may be in:
+- Server Action (use: const sdk = getStorefrontSDK(await cookies()))
+- API Route (use: const sdk = getStorefrontSDK(cookies()))
+- Server Component in App Router (use: const sdk = getStorefrontSDK(cookies()))
+`;
+    } catch {
+      autoDetectMessage = `
+
+\u{1F4A1} Make sure you have Next.js installed and are in a server context.
+`;
+    }
+    throw new Error(
+      `
+\u{1F6A8} Server Environment Detected!
+
+You're calling getStorefrontSDK() on the server without cookies.
+Please pass the Next.js cookie store:
+
+\u2705 Correct usage:
+import { cookies } from 'next/headers';
+
+// Server Actions & Route Handlers
+const sdk = getStorefrontSDK(await cookies());
+
+// API Routes & Server Components (App Router)
+const sdk = getStorefrontSDK(cookies());
+
+\u274C Your current usage:
+const sdk = getStorefrontSDK(); // Missing cookies!
+${autoDetectMessage}
+This is required for server-side token access.
+    `.trim()
+    );
+  }
+  return getBuildTimeSDK();
+}
+function initializeStorefrontSDK(config) {
+  globalConfig = config;
+  clientSDK = null;
+  buildTimeSDK = null;
+}
+
+// src/storefront.ts
+function storefront(cookieStore) {
+  return getStorefrontSDK(cookieStore);
+}
+
+// src/init-client.ts
+import { useEffect } from "react";
+function StorefrontSDKInitializer({
+  config
+}) {
+  useEffect(() => {
+    initializeStorefrontSDK(config);
+  }, [config]);
+  return null;
+}
+
+// src/client.ts
+export * from "@commercengine/storefront-sdk";
+export {
+  ClientTokenStorage,
+  StorefrontSDKInitializer,
+  getStorefrontSDK,
+  initializeStorefrontSDK,
+  storefront
+};