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

package/dist/index.d.ts

@@ -1,107 +1,42 @@
-import { TokenStorage, StorefrontSDK, StorefrontSDKOptions } from '@commercengine/storefront-sdk';
+import { StorefrontSDK } from '@commercengine/storefront-sdk';
 export * from '@commercengine/storefront-sdk';
-export { StorefrontSDK, StorefrontSDKOptions } from '@commercengine/storefront-sdk';
-export { default as storefront } from './storefront.js';
+export { AuthClient, BrowserTokenStorage, CartClient, CatalogClient, CookieTokenStorage, CustomerClient, Environment, HelpersClient, MemoryTokenStorage, OrderClient, ResponseUtils, ShippingClient, StoreConfigClient, StorefrontAPIClient, StorefrontSDK, TokenStorage } from '@commercengine/storefront-sdk';
+import { S as StorefrontRuntimeConfig } from './server-CwxgXezP.js';
 
-/**
- * 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 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 with configuration (internal use)
- * This should be called once in your app via StorefrontSDKInitializer
+ * ```typescript
+ * // lib/storefront.ts
+ * import { createStorefront } from "@commercengine/storefront-sdk-nextjs";
+ *
+ * export const storefront = createStorefront({
+ *   debug: true,
+ *   logger: (msg, ...args) => console.log('[DEBUG]', msg, ...args)
+ * });
+ * ```
+ *
+ * @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 initializeStorefrontSDK(config: NextJSSDKConfig): void;
+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, getStorefrontSDK, initializeStorefrontSDK as i };
+export { StorefrontRuntimeConfig, createStorefront };

package/dist/index.js

@@ -1,9 +1,23 @@
-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/index.ts
+import { StorefrontSDK as StorefrontSDK2, Environment as Environment2 } from "@commercengine/storefront-sdk";
+import {
+  StorefrontAPIClient,
+  AuthClient,
+  CartClient,
+  CatalogClient,
+  CustomerClient,
+  HelpersClient,
+  ShippingClient,
+  OrderClient,
+  StoreConfigClient,
+  ResponseUtils
+} from "@commercengine/storefront-sdk";
+import {
+  TokenStorage,
+  MemoryTokenStorage as MemoryTokenStorage2,
+  BrowserTokenStorage,
+  CookieTokenStorage
+} from "@commercengine/storefront-sdk";
 
 // src/sdk-manager.ts
 import { cache } from "react";
@@ -192,21 +206,17 @@ var BuildCachingMemoryTokenStorage = class {
   }
   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,
@@ -233,30 +243,63 @@ var BuildCachingMemoryTokenStorage = class {
 };
 
 // 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;
+  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;
   }
-  return getEnvConfig();
-}
-var clientSDK = null;
-function hasRequestContext() {
-  try {
-    const { cookies } = __require("next/headers");
-    cookies();
-    return true;
-  } catch {
-    return false;
+  const storeId = globalStorefrontConfig?.storeId || envStoreId;
+  const apiKey = globalStorefrontConfig?.apiKey || envApiKey;
+  const environment = globalStorefrontConfig?.environment || (envEnvironment === "production" ? Environment.Production : 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);
@@ -267,14 +310,12 @@ function createTokenStorage(cookieStore, options, config) {
   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();
+  const config = getConfig();
   return new StorefrontSDK({
     ...config,
     tokenStorage: createTokenStorage(
@@ -286,7 +327,7 @@ var getServerSDKCached = cache((cookieStore) => {
 });
 var buildTimeSDK = null;
 function getBuildTimeSDK() {
-  const config = getEnvConfig();
+  const config = getConfig();
   if (!buildTimeSDK) {
     buildTimeSDK = new StorefrontSDK({
       ...config,
@@ -322,59 +363,78 @@ function getStorefrontSDK(cookieStore) {
   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 = `
+  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 & 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()
+      [
+        "\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 getBuildTimeSDK();
+  return storefront;
 }
-
-// src/storefront.ts
-function storefront(cookieStore) {
-  return getStorefrontSDK(cookieStore);
-}
-
-// src/index.ts
-export * from "@commercengine/storefront-sdk";
 export {
-  ClientTokenStorage,
-  ServerTokenStorage,
-  getStorefrontSDK,
-  storefront
+  AuthClient,
+  BrowserTokenStorage,
+  CartClient,
+  CatalogClient,
+  CookieTokenStorage,
+  CustomerClient,
+  Environment2 as Environment,
+  HelpersClient,
+  MemoryTokenStorage2 as MemoryTokenStorage,
+  OrderClient,
+  ResponseUtils,
+  ShippingClient,
+  StoreConfigClient,
+  StorefrontAPIClient,
+  StorefrontSDK2 as StorefrontSDK,
+  TokenStorage,
+  createStorefront
 };

package/dist/server-ByBPoXJG.d.cts

@@ -0,0 +1,182 @@
+import { TokenStorage, StorefrontSDK, Environment, SupportedDefaultHeaders, DebugLoggerFn, 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;
+}
+type NextCookieStore$2 = {
+    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$2, 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;
+}
+/**
+ * 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$1 = {
+    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$1): StorefrontSDK;
+declare function getStorefrontSDK(cookieStore: NextCookieStore$1, requestConfig?: StorefrontRuntimeConfig): StorefrontSDK;
+/**
+ * Set global storefront configuration that applies to all SDK instances
+ * This gets bundled into both client and server contexts automatically
+ */
+declare function setGlobalStorefrontConfig(config: StorefrontRuntimeConfig | null): void;
+/**
+ * Get the current global storefront configuration
+ */
+declare function getGlobalStorefrontConfig(): StorefrontRuntimeConfig | null;
+/**
+ * Initialize the SDK (internal use)
+ * This should be called once in your app via StorefrontSDKInitializer
+ */
+declare function initializeStorefrontSDK(): void;
+
+/**
+ * Universal storefront SDK export
+ *
+ * This provides a simple unified interface that works in all Next.js contexts:
+ * - Client components: automatically uses client token storage
+ * - Server components: requires cookies() to be passed
+ * - SSG/ISR: automatically uses memory storage with optional build caching
+ *
+ * Usage:
+ * ```typescript
+ * // Client-side
+ * import { storefront } from '@commercengine/storefront-sdk-nextjs/storefront'
+ * const products = await storefront().catalog.listProducts()
+ *
+ * // Server-side
+ * import { storefront } from '@commercengine/storefront-sdk-nextjs/storefront'
+ * import { cookies } from 'next/headers'
+ * const products = await storefront(cookies()).catalog.listProducts()
+ * ```
+ */
+
+type NextCookieStore = {
+    get: (name: string) => {
+        value: string;
+    } | undefined;
+    set: (name: string, value: string, options?: any) => void;
+    delete: (name: string) => void;
+};
+/**
+ * Universal storefront SDK accessor
+ *
+ * @param cookieStore - Next.js cookie store (required on server-side)
+ * @param config - Optional per-request configuration overrides
+ * @returns StorefrontSDK instance configured for the current environment
+ */
+declare function storefront(): StorefrontSDK;
+declare function storefront(cookieStore: NextCookieStore): StorefrontSDK;
+declare function storefront(config: StorefrontRuntimeConfig): StorefrontSDK;
+declare function storefront(cookieStore: NextCookieStore, config: StorefrontRuntimeConfig): StorefrontSDK;
+
+export { ClientTokenStorage as C, type NextJSSDKConfig as N, type StorefrontRuntimeConfig as S, getGlobalStorefrontConfig as a, storefront as b, ServerTokenStorage as c, type NextJSTokenStorageOptions as d, getStorefrontSDK as g, initializeStorefrontSDK as i, setGlobalStorefrontConfig as s };