@commercengine/storefront-sdk 0.2.1 → 0.3.0

package/dist/lib/auth.js

@@ -10,38 +10,35 @@ class AuthClient extends client_1.StorefrontAPIClient {
     constructor(config, tokenStorage) {
         super(config);
         this.autoRefreshTimer = null;
-        // Use provided storage or default to memory storage
-        this.tokenStorage = tokenStorage || new MemoryTokenStorage();
-        // Try to initialize from storage
-        const storedToken = this.tokenStorage.getAccessToken();
-        if (storedToken) {
-            this.setToken(storedToken);
-            this.setupAutoRefresh();
-        }
+        this.tokenStorage = tokenStorage;
+        this.setupAutoRefresh();
     }
     // Override the setToken method to use storage
-    setToken(token) {
-        super.setToken(token); // Assuming this sets the token in the client
-        this.tokenStorage.setAccessToken(token);
+    async setToken(token) {
+        super.setToken(token); // Set token in client
+        await this.tokenStorage.setItem("access_token", token);
         // If we also have a refresh token, store it
-        if (this.tokenStorage.getRefreshToken()) {
+        const refreshToken = await this.tokenStorage.getItem("refresh_token");
+        if (refreshToken) {
             this.setupAutoRefresh();
         }
     }
     // Store refresh token separately
-    setRefreshToken(token) {
-        this.tokenStorage.setRefreshToken(token);
+    async setRefreshToken(token) {
+        await this.tokenStorage.setItem("refresh_token", token);
     }
     // Clear tokens from storage
-    clearToken() {
-        super.clearToken(); // Assuming this clears the token in the client
-        this.tokenStorage.clearTokens();
+    async clearToken() {
+        super.clearToken(); // Clear token in client
+        await this.tokenStorage.removeItem("access_token");
+        await this.tokenStorage.removeItem("refresh_token");
+        await this.tokenStorage.removeItem("user_data");
         this.clearAutoRefresh();
     }
     // Setup auto refresh based on token expiry
-    setupAutoRefresh() {
+    async setupAutoRefresh() {
         this.clearAutoRefresh();
-        const token = this.tokenStorage.getAccessToken();
+        const token = await this.tokenStorage.getItem("access_token");
         if (!token)
             return;
         const expiryTime = this.getTokenExpiry(token);
@@ -73,16 +70,16 @@ class AuthClient extends client_1.StorefrontAPIClient {
     }
     async handleTokenRefresh() {
         try {
-            const refreshToken = this.tokenStorage.getRefreshToken();
+            const refreshToken = await this.tokenStorage.getItem("refresh_token");
             if (!refreshToken)
                 return;
             const tokens = await this.refreshToken(refreshToken);
-            this.setToken(tokens.access_token);
-            this.setRefreshToken(tokens.refresh_token);
+            await this.setToken(tokens.access_token);
+            await this.setRefreshToken(tokens.refresh_token);
         }
         catch (error) {
             // If refresh fails, clear tokens
-            this.clearToken();
+            await this.clearToken();
         }
     }
     getTokenExpiry(token) {
@@ -117,47 +114,45 @@ class AuthClient extends client_1.StorefrontAPIClient {
         }
     }
     /**
-     * Get an anonymous user token
-     *
-     * @param options - Options for anonymous authentication
-     * @returns Promise with user info and tokens
+     * Store auth data including tokens and user info
+     */
+    async storeAuthData(accessToken, refreshToken, user) {
+        await this.setToken(accessToken);
+        await this.setRefreshToken(refreshToken);
+        if (user) {
+            await this.tokenStorage.setItem("user_data", JSON.stringify(user));
+        }
+    }
+    /**
+     * Get stored user data
+     * @returns Promise that resolves to the stored user data or null if none exists
+     */
+    async getStoredUser() {
+        const userData = await this.tokenStorage.getItem("user_data");
+        if (!userData)
+            return null;
+        try {
+            return JSON.parse(userData);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get anonymous token for guest users
      */
     async getAnonymousToken(options) {
         return this.executeWithTokenRefresh(async () => {
-            // If apiKey is provided in options, temporarily set it for this request only
-            const tempApiKey = options?.apiKey;
-            const hadExistingApiKey = !!this.config.apiKey;
-            const originalApiKey = this.config.apiKey;
-            try {
-                // Set temporary API key if provided
-                if (tempApiKey) {
-                    this.setApiKey(tempApiKey);
-                }
-                // Check if we have an API key set (either from constructor or from options)
-                if (!this.config.apiKey) {
-                    throw new Error("X-Api-Key is required for anonymous authentication");
-                }
-                const { data, error } = await this.client.POST("/auth/anonymous");
-                if (error) {
-                    this.handleError(error);
-                }
-                if (data?.content?.access_token && data?.content?.refresh_token) {
-                    this.setToken(data.content.access_token);
-                    this.setRefreshToken(data.content.refresh_token);
-                }
-                return data?.content;
-            }
-            finally {
-                // Restore the original API key state if we used a temporary one
-                if (tempApiKey) {
-                    if (hadExistingApiKey && originalApiKey) {
-                        this.setApiKey(originalApiKey);
-                    }
-                    else {
-                        this.clearApiKey();
-                    }
-                }
+            const { data, error } = await this.client.POST("/auth/anonymous", {
+                headers: options?.apiKey ? { "X-Api-Key": options.apiKey } : undefined,
+            });
+            if (error) {
+                this.handleError(error);
             }
+            const response = data?.content;
+            // Store tokens and user data
+            await this.storeAuthData(response.access_token, response.refresh_token, response.user);
+            return response;
         });
     }
     /**
@@ -207,22 +202,21 @@ class AuthClient extends client_1.StorefrontAPIClient {
     /**
      * Login with password
      *
-     * @param options - Login credentials
+     * @param credentials - Login credentials
      * @returns Promise with user info and tokens
      */
-    async loginWithPassword(options) {
+    async loginWithPassword(credentials) {
         return this.executeWithTokenRefresh(async () => {
             const { data, error } = await this.client.POST("/auth/login/password", {
-                body: options,
+                body: credentials,
             });
             if (error) {
                 this.handleError(error);
             }
-            if (data?.content?.access_token && data?.content?.refresh_token) {
-                this.setToken(data.content.access_token);
-                this.setRefreshToken(data.content.refresh_token);
-            }
-            return data?.content;
+            const response = data?.content;
+            // Store tokens and user ID
+            await this.storeAuthData(response.access_token, response.refresh_token, response.user);
+            return response;
         });
     }
     /**
@@ -246,8 +240,8 @@ class AuthClient extends client_1.StorefrontAPIClient {
                 this.handleError(error);
             }
             if (data?.content?.access_token && data?.content?.refresh_token) {
-                this.setToken(data.content.access_token);
-                this.setRefreshToken(data.content.refresh_token);
+                await this.setToken(data.content.access_token);
+                await this.setRefreshToken(data.content.refresh_token);
             }
             return data?.content;
         });
@@ -270,8 +264,8 @@ class AuthClient extends client_1.StorefrontAPIClient {
                 this.handleError(error);
             }
             if (data?.content?.access_token && data?.content?.refresh_token) {
-                this.setToken(data.content.access_token);
-                this.setRefreshToken(data.content.refresh_token);
+                await this.setToken(data.content.access_token);
+                await this.setRefreshToken(data.content.refresh_token);
             }
             return data?.content;
         });
@@ -291,33 +285,26 @@ class AuthClient extends client_1.StorefrontAPIClient {
                 this.handleError(error);
             }
             if (data?.content?.access_token && data?.content?.refresh_token) {
-                this.setToken(data.content.access_token);
-                this.setRefreshToken(data.content.refresh_token);
+                await this.setToken(data.content.access_token);
+                await this.setRefreshToken(data.content.refresh_token);
             }
             return data?.content;
         });
     }
     /**
-     * Refresh token
-     *
-     * @param refreshToken - Refresh token
-     * @returns Promise with new tokens
+     * Refresh the access token using a refresh token
      */
     async refreshToken(refreshToken) {
-        // Don't use executeWithTokenRefresh here to avoid infinite loop
         const { data, error } = await this.client.POST("/auth/refresh-token", {
-            body: {
-                refresh_token: refreshToken,
-            },
+            body: { refresh_token: refreshToken },
         });
         if (error) {
             this.handleError(error);
         }
-        if (data?.content?.access_token && data?.content?.refresh_token) {
-            this.setToken(data.content.access_token);
-            this.setRefreshToken(data.content.refresh_token);
-        }
-        return data?.content;
+        const response = data?.content;
+        // Store new tokens but don't update user ID as it hasn't changed
+        await this.storeAuthData(response.access_token, response.refresh_token);
+        return response;
     }
     /**
      * Logout
@@ -330,7 +317,7 @@ class AuthClient extends client_1.StorefrontAPIClient {
             if (error) {
                 this.handleError(error);
             }
-            this.clearToken();
+            await this.clearToken();
         });
     }
     /**
@@ -340,22 +327,28 @@ class AuthClient extends client_1.StorefrontAPIClient {
      * @returns Promise that resolves to true if token was refreshed, false otherwise
      */
     async attemptTokenRefresh() {
-        const refreshToken = this.tokenStorage.getRefreshToken();
+        const refreshToken = await this.tokenStorage.getItem("refresh_token");
         if (!refreshToken)
             return false;
         try {
+            // Get current user data before refresh
+            const userData = await this.getStoredUser();
             const tokens = await this.refreshToken(refreshToken);
             if (tokens.access_token) {
-                this.setToken(tokens.access_token);
+                await this.setToken(tokens.access_token);
             }
             if (tokens.refresh_token) {
-                this.setRefreshToken(tokens.refresh_token);
+                await this.setRefreshToken(tokens.refresh_token);
+            }
+            // Restore user data after refresh since it hasn't changed
+            if (userData) {
+                await this.tokenStorage.setItem("user_data", JSON.stringify(userData));
             }
             return true;
         }
         catch (error) {
             // If refresh fails, clear tokens
-            this.clearToken();
+            await this.clearToken();
             return false;
         }
     }
@@ -392,31 +385,51 @@ class MemoryTokenStorage {
         this.accessToken = null;
         this.refreshToken = null;
         this.cartId = null;
-    }
-    getAccessToken() {
-        return this.accessToken;
-    }
-    setAccessToken(token) {
-        this.accessToken = token;
-    }
-    getRefreshToken() {
-        return this.refreshToken;
-    }
-    setRefreshToken(token) {
-        this.refreshToken = token;
-    }
-    clearTokens() {
-        this.accessToken = null;
-        this.refreshToken = null;
+        this.userData = null;
+    }
+    getItem(key) {
+        if (key === "access_token")
+            return Promise.resolve(this.accessToken);
+        if (key === "refresh_token")
+            return Promise.resolve(this.refreshToken);
+        if (key === "cart_id")
+            return Promise.resolve(this.cartId);
+        if (key === "user_data")
+            return Promise.resolve(this.userData);
+        return Promise.resolve(null);
+    }
+    setItem(key, value) {
+        if (key === "access_token")
+            this.accessToken = value;
+        if (key === "refresh_token")
+            this.refreshToken = value;
+        if (key === "cart_id")
+            this.cartId = value;
+        if (key === "user_data")
+            this.userData = value;
+        return Promise.resolve();
+    }
+    removeItem(key) {
+        if (key === "access_token")
+            this.accessToken = null;
+        if (key === "refresh_token")
+            this.refreshToken = null;
+        if (key === "cart_id")
+            this.cartId = null;
+        if (key === "user_data")
+            this.userData = null;
+        return Promise.resolve();
     }
     getCartId() {
-        return this.cartId;
+        return Promise.resolve(this.cartId);
     }
     setCartId(cartId) {
         this.cartId = cartId;
+        return Promise.resolve();
     }
     clearCartId() {
         this.cartId = null;
+        return Promise.resolve();
     }
 }
 exports.MemoryTokenStorage = MemoryTokenStorage;
@@ -428,47 +441,51 @@ class BrowserTokenStorage {
         this.accessTokenKey = `${prefix}access_token`;
         this.refreshTokenKey = `${prefix}refresh_token`;
         this.cartIdKey = `${prefix}cart_id`;
-    }
-    getAccessToken() {
-        if (typeof localStorage === "undefined")
-            return null;
-        return localStorage.getItem(this.accessTokenKey);
-    }
-    setAccessToken(token) {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.setItem(this.accessTokenKey, token);
-    }
-    getRefreshToken() {
-        if (typeof localStorage === "undefined")
-            return null;
-        return localStorage.getItem(this.refreshTokenKey);
-    }
-    setRefreshToken(token) {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.setItem(this.refreshTokenKey, token);
-    }
-    clearTokens() {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.removeItem(this.accessTokenKey);
-        localStorage.removeItem(this.refreshTokenKey);
+        this.userDataKey = `${prefix}user_data`;
+    }
+    getItem(key) {
+        if (key === "access_token")
+            return Promise.resolve(localStorage.getItem(this.accessTokenKey));
+        if (key === "refresh_token")
+            return Promise.resolve(localStorage.getItem(this.refreshTokenKey));
+        if (key === "cart_id")
+            return Promise.resolve(localStorage.getItem(this.cartIdKey));
+        if (key === "user_data")
+            return Promise.resolve(localStorage.getItem(this.userDataKey));
+        return Promise.resolve(null);
+    }
+    setItem(key, value) {
+        if (key === "access_token")
+            localStorage.setItem(this.accessTokenKey, value);
+        if (key === "refresh_token")
+            localStorage.setItem(this.refreshTokenKey, value);
+        if (key === "cart_id")
+            localStorage.setItem(this.cartIdKey, value);
+        if (key === "user_data")
+            localStorage.setItem(this.userDataKey, value);
+        return Promise.resolve();
+    }
+    removeItem(key) {
+        if (key === "access_token")
+            localStorage.removeItem(this.accessTokenKey);
+        if (key === "refresh_token")
+            localStorage.removeItem(this.refreshTokenKey);
+        if (key === "cart_id")
+            localStorage.removeItem(this.cartIdKey);
+        if (key === "user_data")
+            localStorage.removeItem(this.userDataKey);
+        return Promise.resolve();
     }
     getCartId() {
-        if (typeof localStorage === "undefined")
-            return null;
-        return localStorage.getItem(this.cartIdKey);
+        return Promise.resolve(localStorage.getItem(this.cartIdKey));
     }
     setCartId(cartId) {
-        if (typeof localStorage === "undefined")
-            return;
         localStorage.setItem(this.cartIdKey, cartId);
+        return Promise.resolve();
     }
     clearCartId() {
-        if (typeof localStorage === "undefined")
-            return;
         localStorage.removeItem(this.cartIdKey);
+        return Promise.resolve();
     }
 }
 exports.BrowserTokenStorage = BrowserTokenStorage;
@@ -486,147 +503,85 @@ class CookieTokenStorage {
         this.accessTokenKey = `${prefix}access_token`;
         this.refreshTokenKey = `${prefix}refresh_token`;
         this.cartIdKey = `${prefix}cart_id`;
+        this.userDataKey = `${prefix}user_data`;
         this.cookieOptions = cookieOptions;
     }
     /**
-     * Get access token from cookies
-     * Works in both browser and Next.js server components
-     */
-    getAccessToken() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            return getCookieValue(this.accessTokenKey);
-        }
-        // Next.js server component - would need to be implemented by user
-        // with their specific cookie library
-        return null;
-    }
-    /**
-     * Set access token in cookies
-     * Works in browser environment
-     */
-    setAccessToken(token) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            setCookie(this.accessTokenKey, token, this.cookieOptions);
-        }
-        // Next.js - would need to be implemented by user
-        // with their specific cookie API
-    }
-    /**
-     * Get refresh token from cookies
+     * Get value from cookies
      * Works in both browser and Next.js server components
      */
-    getRefreshToken() {
+    getItem(key) {
         // Browser environment
         if (typeof document !== "undefined") {
-            return getCookieValue(this.refreshTokenKey);
+            if (key === "access_token")
+                return Promise.resolve(getCookieValue(this.accessTokenKey));
+            if (key === "refresh_token")
+                return Promise.resolve(getCookieValue(this.refreshTokenKey));
+            if (key === "cart_id")
+                return Promise.resolve(getCookieValue(this.cartIdKey));
+            if (key === "user_data")
+                return Promise.resolve(getCookieValue(this.userDataKey));
         }
         // Next.js server component - would need to be implemented by user
-        return null;
+        return Promise.resolve(null);
     }
     /**
-     * Set refresh token in cookies
+     * Set value in cookies
      * Works in browser environment
      */
-    setRefreshToken(token) {
+    setItem(key, value) {
         // Browser environment
         if (typeof document !== "undefined") {
-            setCookie(this.refreshTokenKey, token, this.cookieOptions);
+            if (key === "access_token")
+                setCookie(this.accessTokenKey, value, this.cookieOptions);
+            if (key === "refresh_token")
+                setCookie(this.refreshTokenKey, value, this.cookieOptions);
+            if (key === "cart_id")
+                setCookie(this.cartIdKey, value, this.cookieOptions);
+            if (key === "user_data")
+                setCookie(this.userDataKey, value, this.cookieOptions);
         }
         // Next.js - would need to be implemented by user
+        return Promise.resolve();
     }
     /**
-     * Clear all tokens from cookies
+     * Remove value from cookies
      */
-    clearTokens() {
+    removeItem(key) {
         // Browser environment
         if (typeof document !== "undefined") {
-            deleteCookie(this.accessTokenKey);
-            deleteCookie(this.refreshTokenKey);
+            if (key === "access_token")
+                deleteCookie(this.accessTokenKey);
+            if (key === "refresh_token")
+                deleteCookie(this.refreshTokenKey);
+            if (key === "cart_id")
+                deleteCookie(this.cartIdKey);
+            if (key === "user_data")
+                deleteCookie(this.userDataKey);
         }
         // Next.js - would need to be implemented by user
+        return Promise.resolve();
     }
     /**
      * Get cart ID from cookies
-     * Works in both browser and Next.js server components
      */
     getCartId() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            return getCookieValue(this.cartIdKey);
-        }
-        // Next.js server component - would need to be implemented by user
-        return null;
+        return this.getItem(this.cartIdKey);
     }
     /**
      * Set cart ID in cookies
-     * Works in browser environment
      */
     setCartId(cartId) {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            setCookie(this.cartIdKey, cartId, this.cookieOptions);
-        }
-        // Next.js - would need to be implemented by user
+        return this.setItem(this.cartIdKey, cartId);
     }
     /**
      * Clear cart ID from cookies
      */
     clearCartId() {
-        // Browser environment
-        if (typeof document !== "undefined") {
-            deleteCookie(this.cartIdKey);
-        }
-        // Next.js - would need to be implemented by user
+        return this.removeItem(this.cartIdKey);
     }
 }
 exports.CookieTokenStorage = CookieTokenStorage;
-/**
- * Helper function to get cookie value
- */
-function getCookieValue(name) {
-    if (typeof document === "undefined")
-        return null;
-    const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
-    return match ? decodeURIComponent(match[2]) : null;
-}
-/**
- * Helper function to set cookie
- */
-function setCookie(name, value, options = {}) {
-    if (typeof document === "undefined")
-        return;
-    const cookieOptions = {
-        path: "/",
-        ...options,
-    };
-    let cookie = `${name}=${encodeURIComponent(value)}`;
-    if (cookieOptions.maxAge) {
-        cookie += `; max-age=${cookieOptions.maxAge}`;
-    }
-    if (cookieOptions.domain) {
-        cookie += `; domain=${cookieOptions.domain}`;
-    }
-    if (cookieOptions.path) {
-        cookie += `; path=${cookieOptions.path}`;
-    }
-    if (cookieOptions.secure) {
-        cookie += "; secure";
-    }
-    if (cookieOptions.sameSite) {
-        cookie += `; samesite=${cookieOptions.sameSite}`;
-    }
-    document.cookie = cookie;
-}
-/**
- * Helper function to delete cookie
- */
-function deleteCookie(name, path = "/") {
-    if (typeof document === "undefined")
-        return;
-    document.cookie = `${name}=; path=${path}; expires=Thu, 01 Jan 1970 00:00:01 GMT`;
-}
 /**
  * Next.js specific cookie storage implementation
  * Works with the Next.js cookies API
@@ -636,128 +591,145 @@ class NextCookieTokenStorage {
         this.accessTokenKey = `${prefix}access_token`;
         this.refreshTokenKey = `${prefix}refresh_token`;
         this.cartIdKey = `${prefix}cart_id`;
+        this.userDataKey = `${prefix}user_data`;
         this.cookieStore = cookieStore;
     }
-    /**
-     * Get access token from Next.js cookies
-     */
-    getAccessToken() {
+    getItem(key) {
         try {
             // Assuming cookieStore.get method exists (like in next/headers)
-            const cookie = this.cookieStore.get(this.accessTokenKey);
-            return cookie ? cookie.value : null;
+            let cookieKey = "";
+            if (key === "access_token")
+                cookieKey = this.accessTokenKey;
+            if (key === "refresh_token")
+                cookieKey = this.refreshTokenKey;
+            if (key === "cart_id")
+                cookieKey = this.cartIdKey;
+            if (key === "user_data")
+                cookieKey = this.userDataKey;
+            if (!cookieKey)
+                return Promise.resolve(null);
+            const cookie = this.cookieStore.get(cookieKey);
+            return cookie ? Promise.resolve(cookie.value) : Promise.resolve(null);
         }
         catch (error) {
-            return null;
+            return Promise.resolve(null);
         }
     }
-    /**
-     * Set access token in Next.js cookies
-     */
-    setAccessToken(token) {
+    setItem(key, value) {
         try {
             // Assuming cookieStore.set method exists
-            this.cookieStore.set(this.accessTokenKey, token, {
+            let cookieKey = "";
+            if (key === "access_token")
+                cookieKey = this.accessTokenKey;
+            if (key === "refresh_token")
+                cookieKey = this.refreshTokenKey;
+            if (key === "cart_id")
+                cookieKey = this.cartIdKey;
+            if (key === "user_data")
+                cookieKey = this.userDataKey;
+            if (!cookieKey)
+                return Promise.resolve();
+            this.cookieStore.set(cookieKey, value, {
                 path: "/",
                 secure: process.env.NODE_ENV === "production",
                 httpOnly: true,
                 sameSite: "strict",
                 maxAge: 60 * 60 * 24 * 30, // 30 days
             });
+            return Promise.resolve();
         }
         catch (error) {
             // Silently fail - might be in an environment where cookies can't be set
+            return Promise.resolve();
         }
     }
-    /**
-     * Get refresh token from Next.js cookies
-     */
-    getRefreshToken() {
-        try {
-            // Assuming cookieStore.get method exists
-            const cookie = this.cookieStore.get(this.refreshTokenKey);
-            return cookie ? cookie.value : null;
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    /**
-     * Set refresh token in Next.js cookies
-     */
-    setRefreshToken(token) {
-        try {
-            // Assuming cookieStore.set method exists
-            this.cookieStore.set(this.refreshTokenKey, token, {
-                path: "/",
-                secure: process.env.NODE_ENV === "production",
-                httpOnly: true,
-                sameSite: "strict",
-                maxAge: 60 * 60 * 24 * 30, // 30 days
-            });
-        }
-        catch (error) {
-            // Silently fail
-        }
-    }
-    /**
-     * Clear all tokens from Next.js cookies
-     */
-    clearTokens() {
+    removeItem(key) {
         try {
             // Assuming cookieStore.delete method exists
-            this.cookieStore.delete(this.accessTokenKey);
-            this.cookieStore.delete(this.refreshTokenKey);
+            let cookieKey = "";
+            if (key === "access_token")
+                cookieKey = this.accessTokenKey;
+            if (key === "refresh_token")
+                cookieKey = this.refreshTokenKey;
+            if (key === "cart_id")
+                cookieKey = this.cartIdKey;
+            if (key === "user_data")
+                cookieKey = this.userDataKey;
+            if (!cookieKey)
+                return Promise.resolve();
+            this.cookieStore.delete(cookieKey);
+            return Promise.resolve();
         }
         catch (error) {
             // Silently fail
+            return Promise.resolve();
         }
     }
     /**
      * Get cart ID from Next.js cookies
      */
     getCartId() {
-        try {
-            // Assuming cookieStore.get method exists
-            const cookie = this.cookieStore.get(this.cartIdKey);
-            return cookie ? cookie.value : null;
-        }
-        catch (error) {
-            return null;
-        }
+        return this.getItem(this.cartIdKey);
     }
     /**
      * Set cart ID in Next.js cookies
      */
     setCartId(cartId) {
-        try {
-            // Assuming cookieStore.set method exists
-            this.cookieStore.set(this.cartIdKey, cartId, {
-                path: "/",
-                secure: process.env.NODE_ENV === "production",
-                httpOnly: true,
-                sameSite: "strict",
-                maxAge: 60 * 60 * 24 * 30, // 30 days
-            });
-        }
-        catch (error) {
-            // Silently fail
-        }
+        return this.setItem(this.cartIdKey, cartId);
     }
     /**
      * Clear cart ID from Next.js cookies
      */
     clearCartId() {
-        try {
-            // Assuming cookieStore.delete method exists
-            this.cookieStore.delete(this.cartIdKey);
-        }
-        catch (error) {
-            // Silently fail
-        }
+        return this.removeItem(this.cartIdKey);
     }
 }
 exports.NextCookieTokenStorage = NextCookieTokenStorage;
+/**
+ * Helper function to get cookie value
+ */
+function getCookieValue(name) {
+    if (typeof document === "undefined")
+        return null;
+    const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
+    return match ? decodeURIComponent(match[2]) : null;
+}
+/**
+ * Helper function to set cookie
+ */
+function setCookie(name, value, options = {}) {
+    if (typeof document === "undefined")
+        return;
+    const cookieOptions = {
+        path: "/",
+        ...options,
+    };
+    let cookie = `${name}=${encodeURIComponent(value)}`;
+    if (cookieOptions.maxAge) {
+        cookie += `; max-age=${cookieOptions.maxAge}`;
+    }
+    if (cookieOptions.domain) {
+        cookie += `; domain=${cookieOptions.domain}`;
+    }
+    if (cookieOptions.path) {
+        cookie += `; path=${cookieOptions.path}`;
+    }
+    if (cookieOptions.secure) {
+        cookie += "; secure";
+    }
+    if (cookieOptions.sameSite) {
+        cookie += `; samesite=${cookieOptions.sameSite}`;
+    }
+    document.cookie = cookie;
+}
+/**
+ * Helper function to delete cookie
+ */
+function deleteCookie(name, path = "/") {
+    if (typeof document === "undefined")
+        return;
+    document.cookie = `${name}=; path=${path}; expires=Thu, 01 Jan 1970 00:00:01 GMT`;
+}
 /**
  * Helper to create a token storage instance based on environment
  * Automatically selects the best storage method based on context