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

package/dist/index.js

@@ -6,8 +6,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/sdk-manager.ts
+import { cache } from "react";
 import {
-  StorefrontSDK
+  StorefrontSDK,
+  MemoryTokenStorage,
+  Environment
 } from "@commercengine/storefront-sdk";
 
 // src/token-storage.ts
@@ -116,7 +119,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);
@@ -139,7 +142,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);
@@ -155,88 +158,171 @@ 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.");
+  async getAccessToken() {
+    if (this.access) {
+      console.log(`\u{1F535} [BuildCache] Using instance token for key: ${this.cacheKey}`);
+      return this.access;
     }
-    if (!this.clientSDK) {
-      this.clientSDK = this.createClientSDK();
+    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;
     }
-    return this.clientSDK;
+    console.log(`\u{1F7E1} [BuildCache] No cached token found for key: ${this.cacheKey}`);
+    return null;
   }
-  /**
-   * Get SDK instance for server-side usage
-   */
-  getServerSDK(cookieStore) {
-    if (!this.config) {
-      throw new Error("SDK not initialized. Call initialize() first.");
-    }
-    return new StorefrontSDK({
-      ...this.config,
-      tokenStorage: new ServerTokenStorage(
-        cookieStore,
-        this.config.tokenStorageOptions
-      )
+  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
     });
   }
-  createClientSDK() {
-    if (!this.config) {
-      throw new Error("SDK not initialized. Call initialize() first.");
-    }
-    return new StorefrontSDK({
-      ...this.config,
-      tokenStorage: new ClientTokenStorage(this.config.tokenStorageOptions)
-    });
+  async getRefreshToken() {
+    return this.refresh;
   }
-  /**
-   * Check if SDK is initialized
-   */
-  isInitialized() {
-    return this.config !== null;
+  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
+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) {
-  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 StorefrontSDK({
+        ...config,
+        tokenStorage: createTokenStorage(
+          void 0,
+          config.tokenStorageOptions,
+          config
+        )
+      });
+    }
+    return clientSDK;
   }
-  if (!cookieStore) {
+  if (cookieStore) {
+    return getServerSDKCached(cookieStore);
+  }
+  if (hasRequestContext()) {
     let autoDetectMessage = "";
     try {
       __require.resolve("next/headers");
@@ -245,7 +331,7 @@ function getStorefrontSDK(cookieStore) {
 \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)
+- Server Component in App Router (use: const sdk = getStorefrontSDK(cookies()))
 `;
     } catch {
       autoDetectMessage = `
@@ -266,7 +352,7 @@ import { cookies } from 'next/headers';
 // Server Actions & Route Handlers
 const sdk = getStorefrontSDK(await cookies());
 
-// API Routes (Next.js 12)
+// API Routes & Server Components (App Router)
 const sdk = getStorefrontSDK(cookies());
 
 \u274C Your current usage:
@@ -276,30 +362,19 @@ This is required for server-side token access.
     `.trim()
     );
   }
-  return manager.getServerSDK(cookieStore);
-}
-function initializeStorefrontSDK(config) {
-  const manager = NextJSSDKManager.getInstance();
-  manager.initialize(config);
+  return getBuildTimeSDK();
 }
 
-// src/init-client.ts
-import { useEffect } from "react";
-function StorefrontSDKInitializer({
-  config
-}) {
-  useEffect(() => {
-    initializeStorefrontSDK(config);
-  }, [config]);
-  return null;
+// src/storefront.ts
+function storefront(cookieStore) {
+  return getStorefrontSDK(cookieStore);
 }
 
 // src/index.ts
-import { Environment } from "@commercengine/storefront-sdk";
+export * from "@commercengine/storefront-sdk";
 export {
   ClientTokenStorage,
-  Environment,
   ServerTokenStorage,
-  StorefrontSDKInitializer,
-  getStorefrontSDK
+  getStorefrontSDK,
+  storefront
 };

package/dist/middleware.cjs

@@ -0,0 +1,66 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  ensureStorefrontTokens: () => ensureStorefrontTokens
+});
+module.exports = __toCommonJS(middleware_exports);
+
+// src/middleware-helper.ts
+async function ensureStorefrontTokens(reqCookies, resCookies, opts) {
+  const prefix = opts.cookiePrefix ?? "ce_";
+  const ACCESS = `${prefix}access_token`;
+  const existingAccess = reqCookies.get(ACCESS)?.value;
+  if (existingAccess) {
+    return false;
+  }
+  try {
+    const resp = await fetch(`${opts.baseUrl}/auth/anonymous`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...opts.apiKey ? { "X-Api-Key": opts.apiKey } : {}
+      }
+    });
+    if (!resp.ok) return false;
+    const data = await resp.json();
+    const content = data?.content;
+    if (!content?.access_token || !content?.refresh_token) return false;
+    const cookieDefaults = {
+      path: "/",
+      httpOnly: false,
+      sameSite: "lax",
+      secure: opts.cookieOptions?.secure ?? false,
+      maxAge: 30 * 24 * 60 * 60
+      // 30 days
+    };
+    const finalOpts = { ...cookieDefaults, ...opts.cookieOptions || {} };
+    resCookies.set(ACCESS, content.access_token, finalOpts);
+    resCookies.set(`${prefix}refresh_token`, content.refresh_token, finalOpts);
+    return true;
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureStorefrontTokens
+});

package/dist/middleware.d.cts

@@ -0,0 +1,38 @@
+/**
+ * Minimal cookie interface compatible with Next.js middleware cookies API.
+ */
+interface NextCookiesLike {
+    get: (name: string) => {
+        value: string;
+    } | undefined;
+    set: (name: string, value: string, options?: {
+        maxAge?: number;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        sameSite?: "strict" | "lax" | "none" | (string & {});
+        httpOnly?: boolean;
+    }) => any;
+}
+interface EnsureTokensOptions {
+    baseUrl: string;
+    apiKey?: string;
+    cookiePrefix?: string;
+    cookieOptions?: {
+        maxAge?: number;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        sameSite?: "strict" | "lax" | "none";
+        httpOnly?: boolean;
+    };
+}
+/**
+ * Pre-seed anonymous tokens in Next.js middleware when missing.
+ * Call this early to ensure SSR and client share the same session.
+ *
+ * Returns true if tokens were set on the response, false otherwise.
+ */
+declare function ensureStorefrontTokens(reqCookies: NextCookiesLike, resCookies: NextCookiesLike, opts: EnsureTokensOptions): Promise<boolean>;
+
+export { type EnsureTokensOptions, type NextCookiesLike, ensureStorefrontTokens };

package/dist/middleware.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Minimal cookie interface compatible with Next.js middleware cookies API.
+ */
+interface NextCookiesLike {
+    get: (name: string) => {
+        value: string;
+    } | undefined;
+    set: (name: string, value: string, options?: {
+        maxAge?: number;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        sameSite?: "strict" | "lax" | "none" | (string & {});
+        httpOnly?: boolean;
+    }) => any;
+}
+interface EnsureTokensOptions {
+    baseUrl: string;
+    apiKey?: string;
+    cookiePrefix?: string;
+    cookieOptions?: {
+        maxAge?: number;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        sameSite?: "strict" | "lax" | "none";
+        httpOnly?: boolean;
+    };
+}
+/**
+ * Pre-seed anonymous tokens in Next.js middleware when missing.
+ * Call this early to ensure SSR and client share the same session.
+ *
+ * Returns true if tokens were set on the response, false otherwise.
+ */
+declare function ensureStorefrontTokens(reqCookies: NextCookiesLike, resCookies: NextCookiesLike, opts: EnsureTokensOptions): Promise<boolean>;
+
+export { type EnsureTokensOptions, type NextCookiesLike, ensureStorefrontTokens };

package/dist/middleware.js

@@ -0,0 +1,39 @@
+// src/middleware-helper.ts
+async function ensureStorefrontTokens(reqCookies, resCookies, opts) {
+  const prefix = opts.cookiePrefix ?? "ce_";
+  const ACCESS = `${prefix}access_token`;
+  const existingAccess = reqCookies.get(ACCESS)?.value;
+  if (existingAccess) {
+    return false;
+  }
+  try {
+    const resp = await fetch(`${opts.baseUrl}/auth/anonymous`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...opts.apiKey ? { "X-Api-Key": opts.apiKey } : {}
+      }
+    });
+    if (!resp.ok) return false;
+    const data = await resp.json();
+    const content = data?.content;
+    if (!content?.access_token || !content?.refresh_token) return false;
+    const cookieDefaults = {
+      path: "/",
+      httpOnly: false,
+      sameSite: "lax",
+      secure: opts.cookieOptions?.secure ?? false,
+      maxAge: 30 * 24 * 60 * 60
+      // 30 days
+    };
+    const finalOpts = { ...cookieDefaults, ...opts.cookieOptions || {} };
+    resCookies.set(ACCESS, content.access_token, finalOpts);
+    resCookies.set(`${prefix}refresh_token`, content.refresh_token, finalOpts);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  ensureStorefrontTokens
+};

package/dist/server-D-pFrx8J.d.cts

@@ -0,0 +1,105 @@
+import { TokenStorage, StorefrontSDK, StorefrontSDKOptions } from '@commercengine/storefront-sdk';
+import './storefront.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) => {
+        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 with configuration (internal use)
+ * This should be called once in your app via StorefrontSDKInitializer
+ */
+declare function initializeStorefrontSDK(config: NextJSSDKConfig): void;
+
+export { ClientTokenStorage as C, type NextJSSDKConfig as N, ServerTokenStorage as S, type NextJSTokenStorageOptions as a, getStorefrontSDK as g, initializeStorefrontSDK as i };