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

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,28 +15,17 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ClientTokenStorage: () => ClientTokenStorage,
-  Environment: () => import_storefront_sdk2.Environment,
-  ServerTokenStorage: () => ServerTokenStorage,
-  StorefrontSDKInitializer: () => StorefrontSDKInitializer,
-  getStorefrontSDK: () => getStorefrontSDK
+  createStorefront: () => createStorefront
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/sdk-manager.ts
+var import_react = require("react");
 var import_storefront_sdk = require("@commercengine/storefront-sdk");
 
 // src/token-storage.ts
@@ -147,7 +134,7 @@ var ServerTokenStorage = class {
         secure: this.options.secure,
         sameSite: this.options.sameSite?.toLowerCase(),
         httpOnly: false
-        // Must be false for client-side access
+        // Allow client-side access for SDK flexibility
       });
     } catch (error) {
       console.warn(`Could not set access token on server:`, error);
@@ -170,7 +157,7 @@ var ServerTokenStorage = class {
         secure: this.options.secure,
         sameSite: this.options.sameSite?.toLowerCase(),
         httpOnly: false
-        // Must be false for client-side access
+        // Allow client-side access for SDK flexibility
       });
     } catch (error) {
       console.warn(`Could not set refresh token on server:`, error);
@@ -186,152 +173,254 @@ var ServerTokenStorage = class {
   }
 };
 
-// src/sdk-manager.ts
-var NextJSSDKManager = class _NextJSSDKManager {
-  constructor() {
-    this.clientSDK = null;
-    this.config = null;
-  }
-  static getInstance() {
-    if (!_NextJSSDKManager.instance) {
-      _NextJSSDKManager.instance = new _NextJSSDKManager();
-    }
-    return _NextJSSDKManager.instance;
-  }
-  /**
-   * Initialize the SDK with configuration (should be called once)
-   */
-  initialize(config) {
-    this.config = config;
-    if (typeof window !== "undefined" && !this.clientSDK) {
-      this.clientSDK = this.createClientSDK();
-    }
+// 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;
   }
-  /**
-   * Get SDK instance for client-side usage
-   */
-  getClientSDK() {
-    if (!this.config) {
-      throw new Error("SDK not initialized. Call initialize() first.");
-    }
-    if (!this.clientSDK) {
-      this.clientSDK = this.createClientSDK();
+  async getAccessToken() {
+    if (this.access) {
+      return this.access;
     }
-    return this.clientSDK;
-  }
-  /**
-   * Get SDK instance for server-side usage
-   */
-  getServerSDK(cookieStore) {
-    if (!this.config) {
-      throw new Error("SDK not initialized. Call initialize() first.");
+    const cached = getCachedToken(this.cacheKey);
+    if (cached?.accessToken) {
+      this.access = cached.accessToken;
+      this.refresh = cached.refreshToken ?? null;
+      return this.access;
     }
-    return new import_storefront_sdk.StorefrontSDK({
-      ...this.config,
-      tokenStorage: new ServerTokenStorage(
-        cookieStore,
-        this.config.tokenStorageOptions
-      )
-    });
+    return null;
   }
-  createClientSDK() {
-    if (!this.config) {
-      throw new Error("SDK not initialized. Call initialize() first.");
-    }
-    return new import_storefront_sdk.StorefrontSDK({
-      ...this.config,
-      tokenStorage: new ClientTokenStorage(this.config.tokenStorageOptions)
+  async setAccessToken(token) {
+    this.access = token;
+    setCachedToken(this.cacheKey, {
+      accessToken: token,
+      refreshToken: this.refresh,
+      ttlSeconds: this.ttlSeconds
     });
   }
-  /**
-   * Check if SDK is initialized
-   */
-  isInitialized() {
-    return this.config !== null;
+  async getRefreshToken() {
+    return this.refresh;
+  }
+  async setRefreshToken(token) {
+    this.refresh = token;
+    setCachedToken(this.cacheKey, {
+      accessToken: this.access ?? "",
+      refreshToken: token,
+      ttlSeconds: this.ttlSeconds
+    });
   }
-  /**
-   * Reset the SDK (useful for testing)
-   */
-  reset() {
-    this.clientSDK = null;
-    this.config = null;
+  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) {
-  const manager = NextJSSDKManager.getInstance();
   if (typeof window !== "undefined") {
     if (cookieStore) {
       console.warn(
         "Cookie store passed in client environment - this will be ignored"
       );
     }
-    return manager.getClientSDK();
+    const config = getConfig();
+    if (!clientSDK) {
+      clientSDK = new import_storefront_sdk.StorefrontSDK({
+        ...config,
+        tokenStorage: createTokenStorage(
+          void 0,
+          config.tokenStorageOptions,
+          config
+        )
+      });
+    }
+    return clientSDK;
   }
-  if (!cookieStore) {
-    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()))
-- Middleware (token access limited)
-`;
-    } catch {
-      autoDetectMessage = `
+  if (cookieStore) {
+    return getServerSDKCached(cookieStore);
+  }
+  return getBuildTimeSDK();
+}
+function setGlobalStorefrontConfig(config) {
+  globalStorefrontConfig = config;
+  clientSDK = null;
+  buildTimeSDK = null;
+}
 
-\u{1F4A1} Make sure you have Next.js installed and are in a server context.
-`;
+// src/create-storefront.ts
+function createStorefront(config) {
+  if (config) {
+    setGlobalStorefrontConfig(config);
+  }
+  function storefront(cookieStoreOrOptions, options) {
+    if (typeof window !== "undefined") {
+      return getStorefrontSDK();
+    }
+    let cookieStore;
+    let isRootLayout = false;
+    if (cookieStoreOrOptions) {
+      if ("isRootLayout" in cookieStoreOrOptions) {
+        isRootLayout = cookieStoreOrOptions.isRootLayout;
+      } else {
+        cookieStore = cookieStoreOrOptions;
+        isRootLayout = options?.isRootLayout || false;
+      }
+    }
+    if (cookieStore) {
+      return getStorefrontSDK(cookieStore);
+    }
+    if (process.env.NEXT_IS_BUILD === "true" || process.env.NEXT_BUILD_CACHE_TOKENS === "true") {
+      return getStorefrontSDK();
+    }
+    if (isRootLayout) {
+      return getStorefrontSDK();
     }
     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 (Next.js 12)
-const sdk = getStorefrontSDK(cookies());
-
-\u274C Your current usage:
-const sdk = getStorefrontSDK(); // Missing cookies!
-${autoDetectMessage}
-This is required for server-side token access.
-    `.trim()
+      [
+        "\u{1F6A8} Server context requires cookies for user continuity!",
+        "",
+        "You're calling storefront() on the server without cookies.",
+        "This breaks user session continuity and analytics tracking.",
+        "",
+        "\u2705 Correct usage:",
+        "  import { cookies } from 'next/headers'",
+        "  const sdk = storefront(cookies())",
+        "",
+        "\u{1F4CD} Root Layout exception:",
+        "  const sdk = storefront({ isRootLayout: true })",
+        "",
+        "This is required to maintain consistent user identity across requests."
+      ].join("\n")
     );
   }
-  return manager.getServerSDK(cookieStore);
-}
-function initializeStorefrontSDK(config) {
-  const manager = NextJSSDKManager.getInstance();
-  manager.initialize(config);
-}
-
-// src/init-client.ts
-var import_react = require("react");
-function StorefrontSDKInitializer({
-  config
-}) {
-  (0, import_react.useEffect)(() => {
-    initializeStorefrontSDK(config);
-  }, [config]);
-  return null;
+  return storefront;
 }
-
-// src/index.ts
-var import_storefront_sdk2 = require("@commercengine/storefront-sdk");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ClientTokenStorage,
-  Environment,
-  ServerTokenStorage,
-  StorefrontSDKInitializer,
-  getStorefrontSDK
+  createStorefront
 });

package/dist/index.d.cts

@@ -1,116 +1,41 @@
-import { TokenStorage, StorefrontSDK, StorefrontSDKOptions } from '@commercengine/storefront-sdk';
-export { Environment, StorefrontSDK, StorefrontSDKOptions } from '@commercengine/storefront-sdk';
+import { StorefrontSDK } from '@commercengine/storefront-sdk';
+export { StorefrontSDK } from '@commercengine/storefront-sdk';
+import { S as StorefrontRuntimeConfig } from './server-CwxgXezP.cjs';
 
-/**
- * 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;
-}
-type NextCookieStore$1 = {
-    get: (name: string) => {
-        value: string;
-    } | undefined;
-    set: (name: string, value: string, options?: any) => void;
-    delete: (name: string) => void;
-};
-/**
- * Server-side token storage that uses Next.js cookies API
- */
-declare class ServerTokenStorage implements TokenStorage {
-    private accessTokenKey;
-    private refreshTokenKey;
-    private options;
-    private cookieStore;
-    constructor(cookieStore: NextCookieStore$1, options?: NextJSTokenStorageOptions);
-    getAccessToken(): Promise<string | null>;
-    setAccessToken(token: string): Promise<void>;
-    getRefreshToken(): Promise<string | null>;
-    setRefreshToken(token: string): Promise<void>;
-    clearTokens(): Promise<void>;
-}
-
-/**
- * Configuration for the NextJS SDK wrapper
- */
-interface NextJSSDKConfig extends Omit<StorefrontSDKOptions, "tokenStorage"> {
-    /**
-     * Token storage configuration options
-     */
-    tokenStorageOptions?: NextJSTokenStorageOptions;
-}
 type NextCookieStore = {
     get: (name: string) => {
+        name: string;
         value: string;
     } | undefined;
-    set: (name: string, value: string, options?: any) => void;
+    set: (name: string, value: string, opts?: Record<string, unknown>) => void;
     delete: (name: string) => void;
 };
 /**
- * Smart SDK getter that automatically detects environment
+ * Creates a configured storefront function that works universally across all Next.js contexts
  *
  * Usage:
- * - Client-side: getStorefrontSDK()
- * - Server-side: getStorefrontSDK(await cookies())
- */
-declare function getStorefrontSDK(): StorefrontSDK;
-declare function getStorefrontSDK(cookieStore: NextCookieStore): StorefrontSDK;
-
-interface StorefrontSDKInitializerProps {
-    config: NextJSSDKConfig;
-}
-/**
- * Client-side initialization component
- * Use this in your root layout to initialize the SDK once
+ * ```typescript
+ * // lib/storefront.ts
+ * import { createStorefront } from "@commercengine/storefront-sdk-nextjs";
  *
- * The core SDK middleware now automatically handles everything:
- * - Creates anonymous tokens automatically on first API request (if no tokens exist)
- * - Token state assessment and cleanup on first request per page load
- * - Expired token refresh with automatic anonymous fallback
- * - Graceful handling of partial token states
+ * export const storefront = createStorefront({
+ *   debug: true,
+ *   logger: (msg, ...args) => console.log('[DEBUG]', msg, ...args)
+ * });
+ * ```
  *
- * No manual token creation needed - just make API calls and everything works!
+ * @param config Optional configuration for advanced options (defaults to empty if not provided)
+ * @returns A storefront function that works in all Next.js contexts
  */
-declare function StorefrontSDKInitializer({ config, }: StorefrontSDKInitializerProps): null;
+declare function createStorefront(config?: StorefrontRuntimeConfig): {
+    (): StorefrontSDK;
+    (cookieStore: NextCookieStore): StorefrontSDK;
+    (options: {
+        isRootLayout: true;
+    }): StorefrontSDK;
+    (cookieStore: NextCookieStore, options: {
+        isRootLayout?: boolean;
+    }): StorefrontSDK;
+};
 
-export { ClientTokenStorage, type NextJSSDKConfig, type NextJSTokenStorageOptions, ServerTokenStorage, StorefrontSDKInitializer, getStorefrontSDK };
+export { StorefrontRuntimeConfig, createStorefront };