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

package/dist/client.cjs

@@ -0,0 +1,405 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  ClientTokenStorage: () => ClientTokenStorage,
+  StorefrontSDKInitializer: () => StorefrontSDKInitializer,
+  getStorefrontSDK: () => getStorefrontSDK,
+  initializeStorefrontSDK: () => initializeStorefrontSDK
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/sdk-manager.ts
+var import_react = require("react");
+var import_storefront_sdk = require("@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) {
+      return this.access;
+    }
+    const cached = getCachedToken(this.cacheKey);
+    if (cached?.accessToken) {
+      this.access = cached.accessToken;
+      this.refresh = cached.refreshToken ?? null;
+      return this.access;
+    }
+    return null;
+  }
+  async setAccessToken(token) {
+    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
+function getConfig() {
+  const envStoreId = process.env.NEXT_PUBLIC_STORE_ID;
+  const envApiKey = process.env.NEXT_PUBLIC_API_KEY;
+  const envEnvironment = process.env.NEXT_PUBLIC_ENVIRONMENT;
+  const envBaseUrl = process.env.NEXT_PUBLIC_API_BASE_URL;
+  const envTimeout = process.env.NEXT_PUBLIC_API_TIMEOUT ? parseInt(process.env.NEXT_PUBLIC_API_TIMEOUT, 10) : void 0;
+  const envDebug = process.env.NEXT_PUBLIC_DEBUG_MODE === "true";
+  const envDefaultHeaders = {};
+  if (process.env.NEXT_PUBLIC_DEFAULT_CUSTOMER_GROUP_ID) {
+    envDefaultHeaders.customer_group_id = process.env.NEXT_PUBLIC_DEFAULT_CUSTOMER_GROUP_ID;
+  }
+  const storeId = globalStorefrontConfig?.storeId || envStoreId;
+  const apiKey = globalStorefrontConfig?.apiKey || envApiKey;
+  const environment = globalStorefrontConfig?.environment || (envEnvironment === "production" ? import_storefront_sdk.Environment.Production : import_storefront_sdk.Environment.Staging);
+  const baseUrl = globalStorefrontConfig?.baseUrl || envBaseUrl;
+  const timeout = globalStorefrontConfig?.timeout || envTimeout;
+  const debug = globalStorefrontConfig?.debug !== void 0 ? globalStorefrontConfig.debug : envDebug;
+  const defaultHeaders = {
+    ...envDefaultHeaders,
+    ...globalStorefrontConfig?.defaultHeaders
+  };
+  if (!storeId || !apiKey) {
+    throw new Error(
+      `StorefrontSDK configuration missing! Please set the following environment variables:
+
+NEXT_PUBLIC_STORE_ID=your-store-id
+NEXT_PUBLIC_API_KEY=your-api-key
+NEXT_PUBLIC_ENVIRONMENT=staging (or production)
+
+These variables are required for both client and server contexts to work.`
+    );
+  }
+  const config = {
+    storeId,
+    apiKey,
+    environment
+  };
+  if (baseUrl) config.baseUrl = baseUrl;
+  if (timeout) config.timeout = timeout;
+  if (debug) config.debug = debug;
+  const logger = globalStorefrontConfig?.logger;
+  const accessToken = globalStorefrontConfig?.accessToken;
+  const refreshToken = globalStorefrontConfig?.refreshToken;
+  const onTokensUpdated = globalStorefrontConfig?.onTokensUpdated;
+  const onTokensCleared = globalStorefrontConfig?.onTokensCleared;
+  const tokenStorageOptions = globalStorefrontConfig?.tokenStorageOptions;
+  if (logger) config.logger = logger;
+  if (accessToken) config.accessToken = accessToken;
+  if (refreshToken) config.refreshToken = refreshToken;
+  if (onTokensUpdated) config.onTokensUpdated = onTokensUpdated;
+  if (onTokensCleared) config.onTokensCleared = onTokensCleared;
+  if (Object.keys(defaultHeaders).length > 0) config.defaultHeaders = defaultHeaders;
+  if (tokenStorageOptions) config.tokenStorageOptions = tokenStorageOptions;
+  return config;
+}
+var globalStorefrontConfig = null;
+var clientSDK = null;
+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"}`;
+    return new BuildCachingMemoryTokenStorage(cacheKey);
+  }
+  return new import_storefront_sdk.MemoryTokenStorage();
+}
+var getServerSDKCached = (0, import_react.cache)((cookieStore) => {
+  const config = getConfig();
+  return new import_storefront_sdk.StorefrontSDK({
+    ...config,
+    tokenStorage: createTokenStorage(
+      cookieStore,
+      config.tokenStorageOptions,
+      config
+    )
+  });
+});
+var buildTimeSDK = null;
+function getBuildTimeSDK() {
+  const config = getConfig();
+  if (!buildTimeSDK) {
+    buildTimeSDK = new import_storefront_sdk.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 import_storefront_sdk.StorefrontSDK({
+        ...config,
+        tokenStorage: createTokenStorage(
+          void 0,
+          config.tokenStorageOptions,
+          config
+        )
+      });
+    }
+    return clientSDK;
+  }
+  if (cookieStore) {
+    return getServerSDKCached(cookieStore);
+  }
+  return getBuildTimeSDK();
+}
+function initializeStorefrontSDK() {
+  clientSDK = null;
+  buildTimeSDK = null;
+}
+
+// src/init-client.ts
+var import_react2 = require("react");
+async function bootstrapTokens() {
+  const sdk = getStorefrontSDK();
+  const accessToken = await sdk.getAccessToken();
+  if (!accessToken) {
+    await sdk.auth.getAnonymousToken();
+  }
+}
+function StorefrontSDKInitializer({ runtimeConfig } = {}) {
+  (0, import_react2.useEffect)(() => {
+    initializeStorefrontSDK();
+    bootstrapTokens().catch(console.error);
+  }, [runtimeConfig]);
+  return null;
+}
+
+// src/client.ts
+__reExport(client_exports, require("@commercengine/storefront-sdk"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClientTokenStorage,
+  StorefrontSDKInitializer,
+  getStorefrontSDK,
+  initializeStorefrontSDK,
+  ...require("@commercengine/storefront-sdk")
+});

package/dist/client.d.cts

@@ -0,0 +1,121 @@
+import { TokenStorage, StorefrontSDK, StorefrontSDKOptions, Environment, SupportedDefaultHeaders, DebugLoggerFn } from '@commercengine/storefront-sdk';
+export * from '@commercengine/storefront-sdk';
+export { StorefrontSDK, StorefrontSDKOptions } from '@commercengine/storefront-sdk';
+
+/**
+ * Configuration options for NextJSTokenStorage
+ */
+interface NextJSTokenStorageOptions {
+    /**
+     * Prefix for cookie names (default: "ce_")
+     */
+    prefix?: string;
+    /**
+     * Maximum age of cookies in seconds (default: 30 days)
+     */
+    maxAge?: number;
+    /**
+     * Cookie path (default: "/")
+     */
+    path?: string;
+    /**
+     * Cookie domain (default: current domain)
+     */
+    domain?: string;
+    /**
+     * Whether cookies should be secure (default: auto-detect based on environment)
+     */
+    secure?: boolean;
+    /**
+     * SameSite cookie attribute (default: "Lax")
+     */
+    sameSite?: "Strict" | "Lax" | "None";
+}
+/**
+ * Client-side token storage that uses document.cookie
+ */
+declare class ClientTokenStorage implements TokenStorage {
+    private accessTokenKey;
+    private refreshTokenKey;
+    private options;
+    constructor(options?: NextJSTokenStorageOptions);
+    getAccessToken(): Promise<string | null>;
+    setAccessToken(token: string): Promise<void>;
+    getRefreshToken(): Promise<string | null>;
+    setRefreshToken(token: string): Promise<void>;
+    clearTokens(): Promise<void>;
+    private getCookie;
+    private setCookie;
+    private deleteCookie;
+}
+
+/**
+ * Configuration for the NextJS SDK wrapper
+ */
+interface NextJSSDKConfig extends Omit<StorefrontSDKOptions, "tokenStorage"> {
+    /**
+     * Token storage configuration options
+     */
+    tokenStorageOptions?: NextJSTokenStorageOptions;
+}
+/**
+ * Runtime configuration overrides that can be passed to storefront() function
+ * These override environment variables for that specific request
+ */
+interface StorefrontRuntimeConfig {
+    /**
+     * Override environment variables
+     */
+    storeId?: string;
+    apiKey?: string;
+    environment?: Environment;
+    baseUrl?: string;
+    timeout?: number;
+    debug?: boolean;
+    /**
+     * Advanced options not available via environment variables
+     */
+    accessToken?: string;
+    refreshToken?: string;
+    defaultHeaders?: SupportedDefaultHeaders;
+    logger?: DebugLoggerFn;
+    onTokensUpdated?: (accessToken: string, refreshToken: string) => void;
+    onTokensCleared?: () => void;
+    /**
+     * Token storage configuration
+     */
+    tokenStorageOptions?: NextJSTokenStorageOptions;
+}
+type NextCookieStore = {
+    get: (name: string) => {
+        value: string;
+    } | undefined;
+    set: (name: string, value: string, options?: any) => void;
+    delete: (name: string) => void;
+};
+/**
+ * Smart SDK getter that automatically detects environment
+ *
+ * Usage:
+ * - Client-side: getStorefrontSDK()
+ * - Server-side with request context: getStorefrontSDK(await cookies())
+ * - SSG/ISR (no request context): getStorefrontSDK() (uses memory storage)
+ */
+declare function getStorefrontSDK(): StorefrontSDK;
+declare function getStorefrontSDK(cookieStore: NextCookieStore): StorefrontSDK;
+/**
+ * Initialize the SDK (internal use)
+ * This should be called once in your app via StorefrontSDKInitializer
+ */
+declare function initializeStorefrontSDK(): void;
+
+interface StorefrontSDKInitializerProps {
+    /**
+     * Optional runtime configuration overrides for client-side API calls
+     * These settings will apply to all client-side storefront() calls
+     */
+    runtimeConfig?: StorefrontRuntimeConfig;
+}
+declare function StorefrontSDKInitializer({ runtimeConfig }?: StorefrontSDKInitializerProps): null;
+
+export { ClientTokenStorage, type NextJSSDKConfig, type NextJSTokenStorageOptions, StorefrontSDKInitializer, getStorefrontSDK, initializeStorefrontSDK };

package/dist/client.d.ts

@@ -0,0 +1,121 @@
+import { TokenStorage, StorefrontSDK, StorefrontSDKOptions, Environment, SupportedDefaultHeaders, DebugLoggerFn } from '@commercengine/storefront-sdk';
+export * from '@commercengine/storefront-sdk';
+export { StorefrontSDK, StorefrontSDKOptions } from '@commercengine/storefront-sdk';
+
+/**
+ * Configuration options for NextJSTokenStorage
+ */
+interface NextJSTokenStorageOptions {
+    /**
+     * Prefix for cookie names (default: "ce_")
+     */
+    prefix?: string;
+    /**
+     * Maximum age of cookies in seconds (default: 30 days)
+     */
+    maxAge?: number;
+    /**
+     * Cookie path (default: "/")
+     */
+    path?: string;
+    /**
+     * Cookie domain (default: current domain)
+     */
+    domain?: string;
+    /**
+     * Whether cookies should be secure (default: auto-detect based on environment)
+     */
+    secure?: boolean;
+    /**
+     * SameSite cookie attribute (default: "Lax")
+     */
+    sameSite?: "Strict" | "Lax" | "None";
+}
+/**
+ * Client-side token storage that uses document.cookie
+ */
+declare class ClientTokenStorage implements TokenStorage {
+    private accessTokenKey;
+    private refreshTokenKey;
+    private options;
+    constructor(options?: NextJSTokenStorageOptions);
+    getAccessToken(): Promise<string | null>;
+    setAccessToken(token: string): Promise<void>;
+    getRefreshToken(): Promise<string | null>;
+    setRefreshToken(token: string): Promise<void>;
+    clearTokens(): Promise<void>;
+    private getCookie;
+    private setCookie;
+    private deleteCookie;
+}
+
+/**
+ * Configuration for the NextJS SDK wrapper
+ */
+interface NextJSSDKConfig extends Omit<StorefrontSDKOptions, "tokenStorage"> {
+    /**
+     * Token storage configuration options
+     */
+    tokenStorageOptions?: NextJSTokenStorageOptions;
+}
+/**
+ * Runtime configuration overrides that can be passed to storefront() function
+ * These override environment variables for that specific request
+ */
+interface StorefrontRuntimeConfig {
+    /**
+     * Override environment variables
+     */
+    storeId?: string;
+    apiKey?: string;
+    environment?: Environment;
+    baseUrl?: string;
+    timeout?: number;
+    debug?: boolean;
+    /**
+     * Advanced options not available via environment variables
+     */
+    accessToken?: string;
+    refreshToken?: string;
+    defaultHeaders?: SupportedDefaultHeaders;
+    logger?: DebugLoggerFn;
+    onTokensUpdated?: (accessToken: string, refreshToken: string) => void;
+    onTokensCleared?: () => void;
+    /**
+     * Token storage configuration
+     */
+    tokenStorageOptions?: NextJSTokenStorageOptions;
+}
+type NextCookieStore = {
+    get: (name: string) => {
+        value: string;
+    } | undefined;
+    set: (name: string, value: string, options?: any) => void;
+    delete: (name: string) => void;
+};
+/**
+ * Smart SDK getter that automatically detects environment
+ *
+ * Usage:
+ * - Client-side: getStorefrontSDK()
+ * - Server-side with request context: getStorefrontSDK(await cookies())
+ * - SSG/ISR (no request context): getStorefrontSDK() (uses memory storage)
+ */
+declare function getStorefrontSDK(): StorefrontSDK;
+declare function getStorefrontSDK(cookieStore: NextCookieStore): StorefrontSDK;
+/**
+ * Initialize the SDK (internal use)
+ * This should be called once in your app via StorefrontSDKInitializer
+ */
+declare function initializeStorefrontSDK(): void;
+
+interface StorefrontSDKInitializerProps {
+    /**
+     * Optional runtime configuration overrides for client-side API calls
+     * These settings will apply to all client-side storefront() calls
+     */
+    runtimeConfig?: StorefrontRuntimeConfig;
+}
+declare function StorefrontSDKInitializer({ runtimeConfig }?: StorefrontSDKInitializerProps): null;
+
+export { ClientTokenStorage, type NextJSSDKConfig, type NextJSTokenStorageOptions, StorefrontSDKInitializer, getStorefrontSDK, initializeStorefrontSDK };