@commercengine/storefront-sdk 0.1.3 → 0.2.1

package/dist/index.d.ts

@@ -53,12 +53,32 @@ export declare class StorefrontSDK {
      * Client for authentication-related endpoints
      */
     readonly auth: AuthClient;
+    /**
+     * The client storage instance used by this SDK
+     */
+    private readonly clientStorage;
     /**
      * Create a new StorefrontSDK instance
      *
      * @param options - Configuration options for the SDK
      */
     constructor(options: StorefrontSDKOptions);
+    /**
+     * Get the current cart ID if one is stored
+     *
+     * @returns The current cart ID or null if none exists
+     */
+    getCartId(): string | null;
+    /**
+     * Set a specific cart ID to use
+     *
+     * @param cartId - The cart ID to use
+     */
+    setCartId(cartId: string): void;
+    /**
+     * Clear the current cart ID
+     */
+    clearCartId(): void;
     /**
      * Set the authentication token for all clients
      *

package/dist/index.js

@@ -20,6 +20,8 @@ class StorefrontSDK {
      * @param options - Configuration options for the SDK
      */
     constructor(options) {
+        // Set up client storage
+        this.clientStorage = options.tokenStorage || new auth_1.MemoryTokenStorage();
         // Convert options to internal config format
         const config = {
             storeId: options.storeId,
@@ -31,7 +33,31 @@ class StorefrontSDK {
         };
         this.catalog = new catalog_1.CatalogClient(config);
         this.cart = new cart_1.CartClient(config);
-        this.auth = new auth_1.AuthClient(config, options.tokenStorage);
+        this.auth = new auth_1.AuthClient(config, this.clientStorage);
+        // Set client storage for cart management
+        this.cart.setClientStorage(this.clientStorage);
+    }
+    /**
+     * Get the current cart ID if one is stored
+     *
+     * @returns The current cart ID or null if none exists
+     */
+    getCartId() {
+        return this.cart.getCartId();
+    }
+    /**
+     * Set a specific cart ID to use
+     *
+     * @param cartId - The cart ID to use
+     */
+    setCartId(cartId) {
+        this.cart.setCartId(cartId);
+    }
+    /**
+     * Clear the current cart ID
+     */
+    clearCartId() {
+        this.cart.clearCartId();
     }
     /**
      * Set the authentication token for all clients

package/dist/lib/auth.d.ts

@@ -148,46 +148,59 @@ export declare class AuthClient extends StorefrontAPIClient {
     executeWithTokenRefresh<T>(requestFn: () => Promise<T>): Promise<T>;
 }
 /**
- * Interface for token storage implementations
+ * Interface for client storage implementations (tokens and cart ID)
  */
-export interface TokenStorage {
+export interface ClientStorage {
     getAccessToken(): string | null;
     setAccessToken(token: string): void;
     getRefreshToken(): string | null;
     setRefreshToken(token: string): void;
     clearTokens(): void;
+    getCartId(): string | null;
+    setCartId(cartId: string): void;
+    clearCartId(): void;
 }
+export type TokenStorage = ClientStorage;
 /**
- * Default in-memory implementation of token storage
+ * Default in-memory implementation of client storage
  */
-export declare class MemoryTokenStorage implements TokenStorage {
+export declare class MemoryTokenStorage implements ClientStorage {
     private accessToken;
     private refreshToken;
+    private cartId;
     getAccessToken(): string | null;
     setAccessToken(token: string): void;
     getRefreshToken(): string | null;
     setRefreshToken(token: string): void;
     clearTokens(): void;
+    getCartId(): string | null;
+    setCartId(cartId: string): void;
+    clearCartId(): void;
 }
 /**
  * Browser storage implementation using localStorage
  */
-export declare class BrowserTokenStorage implements TokenStorage {
+export declare class BrowserTokenStorage implements ClientStorage {
     private accessTokenKey;
     private refreshTokenKey;
+    private cartIdKey;
     constructor(prefix?: string);
     getAccessToken(): string | null;
     setAccessToken(token: string): void;
     getRefreshToken(): string | null;
     setRefreshToken(token: string): void;
     clearTokens(): void;
+    getCartId(): string | null;
+    setCartId(cartId: string): void;
+    clearCartId(): void;
 }
 /**
  * Cookie-based token storage for browser or server environments
  */
-export declare class CookieTokenStorage implements TokenStorage {
+export declare class CookieTokenStorage implements ClientStorage {
     private accessTokenKey;
     private refreshTokenKey;
+    private cartIdKey;
     private cookieOptions;
     constructor(prefix?: string, cookieOptions?: {
         path: string;
@@ -220,14 +233,29 @@ export declare class CookieTokenStorage implements TokenStorage {
      * Clear all tokens from cookies
      */
     clearTokens(): void;
+    /**
+     * Get cart ID from cookies
+     * Works in both browser and Next.js server components
+     */
+    getCartId(): string | null;
+    /**
+     * Set cart ID in cookies
+     * Works in browser environment
+     */
+    setCartId(cartId: string): void;
+    /**
+     * Clear cart ID from cookies
+     */
+    clearCartId(): void;
 }
 /**
  * Next.js specific cookie storage implementation
  * Works with the Next.js cookies API
  */
-export declare class NextCookieTokenStorage implements TokenStorage {
+export declare class NextCookieTokenStorage implements ClientStorage {
     private accessTokenKey;
     private refreshTokenKey;
+    private cartIdKey;
     private cookieStore;
     constructor(cookieStore: any, prefix?: string);
     /**
@@ -250,6 +278,18 @@ export declare class NextCookieTokenStorage implements TokenStorage {
      * Clear all tokens from Next.js cookies
      */
     clearTokens(): void;
+    /**
+     * Get cart ID from Next.js cookies
+     */
+    getCartId(): string | null;
+    /**
+     * Set cart ID in Next.js cookies
+     */
+    setCartId(cartId: string): void;
+    /**
+     * Clear cart ID from Next.js cookies
+     */
+    clearCartId(): void;
 }
 /**
  * Helper to create a token storage instance based on environment

package/dist/lib/auth.js

@@ -385,12 +385,13 @@ class AuthClient extends client_1.StorefrontAPIClient {
 }
 exports.AuthClient = AuthClient;
 /**
- * Default in-memory implementation of token storage
+ * Default in-memory implementation of client storage
  */
 class MemoryTokenStorage {
     constructor() {
         this.accessToken = null;
         this.refreshToken = null;
+        this.cartId = null;
     }
     getAccessToken() {
         return this.accessToken;
@@ -408,6 +409,15 @@ class MemoryTokenStorage {
         this.accessToken = null;
         this.refreshToken = null;
     }
+    getCartId() {
+        return this.cartId;
+    }
+    setCartId(cartId) {
+        this.cartId = cartId;
+    }
+    clearCartId() {
+        this.cartId = null;
+    }
 }
 exports.MemoryTokenStorage = MemoryTokenStorage;
 /**
@@ -417,6 +427,7 @@ class BrowserTokenStorage {
     constructor(prefix = "storefront_") {
         this.accessTokenKey = `${prefix}access_token`;
         this.refreshTokenKey = `${prefix}refresh_token`;
+        this.cartIdKey = `${prefix}cart_id`;
     }
     getAccessToken() {
         if (typeof localStorage === "undefined")
@@ -444,6 +455,21 @@ class BrowserTokenStorage {
         localStorage.removeItem(this.accessTokenKey);
         localStorage.removeItem(this.refreshTokenKey);
     }
+    getCartId() {
+        if (typeof localStorage === "undefined")
+            return null;
+        return localStorage.getItem(this.cartIdKey);
+    }
+    setCartId(cartId) {
+        if (typeof localStorage === "undefined")
+            return;
+        localStorage.setItem(this.cartIdKey, cartId);
+    }
+    clearCartId() {
+        if (typeof localStorage === "undefined")
+            return;
+        localStorage.removeItem(this.cartIdKey);
+    }
 }
 exports.BrowserTokenStorage = BrowserTokenStorage;
 /**
@@ -459,6 +485,7 @@ class CookieTokenStorage {
     }) {
         this.accessTokenKey = `${prefix}access_token`;
         this.refreshTokenKey = `${prefix}refresh_token`;
+        this.cartIdKey = `${prefix}cart_id`;
         this.cookieOptions = cookieOptions;
     }
     /**
@@ -520,6 +547,39 @@ class CookieTokenStorage {
         }
         // Next.js - would need to be implemented by user
     }
+    /**
+     * 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;
+    }
+    /**
+     * 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
+    }
+    /**
+     * Clear cart ID from cookies
+     */
+    clearCartId() {
+        // Browser environment
+        if (typeof document !== "undefined") {
+            deleteCookie(this.cartIdKey);
+        }
+        // Next.js - would need to be implemented by user
+    }
 }
 exports.CookieTokenStorage = CookieTokenStorage;
 /**
@@ -575,6 +635,7 @@ class NextCookieTokenStorage {
     constructor(cookieStore, prefix = "storefront_") {
         this.accessTokenKey = `${prefix}access_token`;
         this.refreshTokenKey = `${prefix}refresh_token`;
+        this.cartIdKey = `${prefix}cart_id`;
         this.cookieStore = cookieStore;
     }
     /**
@@ -652,6 +713,49 @@ class NextCookieTokenStorage {
             // Silently fail
         }
     }
+    /**
+     * 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;
+        }
+    }
+    /**
+     * 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
+        }
+    }
+    /**
+     * Clear cart ID from Next.js cookies
+     */
+    clearCartId() {
+        try {
+            // Assuming cookieStore.delete method exists
+            this.cookieStore.delete(this.cartIdKey);
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
 }
 exports.NextCookieTokenStorage = NextCookieTokenStorage;
 /**

package/dist/lib/cart.d.ts

@@ -1,9 +1,33 @@
 import { StorefrontAPIClient } from "./client";
 import type { components } from "../types/storefront";
+import { ClientStorage } from "./auth";
 /**
  * Client for interacting with cart endpoints
  */
 export declare class CartClient extends StorefrontAPIClient {
+    private clientStorage;
+    /**
+     * Set the client storage implementation to use for cart ID management
+     *
+     * @param storage - The client storage instance
+     */
+    setClientStorage(storage: ClientStorage): void;
+    /**
+     * Get the stored cart ID
+     *
+     * @returns The cart ID or null if not found
+     */
+    getCartId(): string | null;
+    /**
+     * Set the cart ID in storage
+     *
+     * @param cartId - The cart ID to store
+     */
+    setCartId(cartId: string): void;
+    /**
+     * Clear the stored cart ID
+     */
+    clearCartId(): void;
     /**
      * Create a new cart
      *
@@ -16,21 +40,45 @@ export declare class CartClient extends StorefrontAPIClient {
         cart: components["schemas"]["Cart"];
     }>;
     /**
-     * Get cart details by ID
+     * Get cart details - either by ID or using the stored cart ID
      *
-     * @param cartId - The ID of the cart
+     * @param cartId - Optional cart ID (if not provided, uses stored cart ID)
      * @returns Promise with cart details
+     * @throws Error if no cartId is provided and none is stored
      */
-    getCart(cartId: string): Promise<{
+    getCart(cartId?: string): Promise<{
         cart: components["schemas"]["Cart"];
     }>;
     /**
-     * Delete a cart by ID
+     * Delete a cart - either by ID or using the stored cart ID
      *
-     * @param cartId - The ID of the cart
+     * @param cartId - Optional cart ID (if not provided, uses stored cart ID)
      * @returns Promise that resolves when the cart is deleted
+     * @throws Error if no cartId is provided and none is stored
      */
-    deleteCart(cartId: string): Promise<void>;
+    deleteCart(cartId?: string): Promise<void>;
+    /**
+     * Add item to cart - either by specified ID or stored cart ID
+     * Will create a new cart if no cart ID is available
+     *
+     * @param item - The item to add to the cart
+     * @param cartId - Optional cart ID (if not provided, uses stored cart ID or creates a new cart)
+     * @returns Promise with updated or created cart
+     */
+    addItem(item: components["schemas"]["UpdateCartItem"], cartId?: string): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
+    /**
+     * Update cart items (add, update quantity, remove)
+     *
+     * @param cartId - The ID of the cart or undefined to use stored cart ID
+     * @param item - The item data
+     * @returns Promise with updated cart
+     * @throws Error if no cartId is provided and none is stored
+     */
+    updateCartItem(cartId: string | undefined, item: components["schemas"]["UpdateCartItem"]): Promise<{
+        cart: components["schemas"]["Cart"];
+    }>;
     /**
      * Get cart details by user ID
      *
@@ -47,16 +95,6 @@ export declare class CartClient extends StorefrontAPIClient {
      * @returns Promise that resolves when the cart is deleted
      */
     deleteUserCart(userId: string): Promise<void>;
-    /**
-     * Update cart items (add, update quantity, remove)
-     *
-     * @param cartId - The ID of the cart
-     * @param item - The item data
-     * @returns Promise with updated cart
-     */
-    updateCartItem(cartId: string, item: components["schemas"]["UpdateCartItem"]): Promise<{
-        cart: components["schemas"]["Cart"];
-    }>;
     /**
      * Update cart addresses
      *

package/dist/lib/cart.js

@@ -6,6 +6,40 @@ const client_1 = require("./client");
  * Client for interacting with cart endpoints
  */
 class CartClient extends client_1.StorefrontAPIClient {
+    constructor() {
+        super(...arguments);
+        this.clientStorage = null;
+    }
+    /**
+     * Set the client storage implementation to use for cart ID management
+     *
+     * @param storage - The client storage instance
+     */
+    setClientStorage(storage) {
+        this.clientStorage = storage;
+    }
+    /**
+     * Get the stored cart ID
+     *
+     * @returns The cart ID or null if not found
+     */
+    getCartId() {
+        return this.clientStorage?.getCartId() || null;
+    }
+    /**
+     * Set the cart ID in storage
+     *
+     * @param cartId - The cart ID to store
+     */
+    setCartId(cartId) {
+        this.clientStorage?.setCartId(cartId);
+    }
+    /**
+     * Clear the stored cart ID
+     */
+    clearCartId() {
+        this.clientStorage?.clearCartId();
+    }
     /**
      * Create a new cart
      *
@@ -20,20 +54,30 @@ class CartClient extends client_1.StorefrontAPIClient {
             if (error) {
                 this.handleError(error);
             }
+            // Store the cart ID
+            if (data?.content?.cart?.id) {
+                this.setCartId(data.content.cart.id);
+            }
             return data?.content;
         });
     }
     /**
-     * Get cart details by ID
+     * Get cart details - either by ID or using the stored cart ID
      *
-     * @param cartId - The ID of the cart
+     * @param cartId - Optional cart ID (if not provided, uses stored cart ID)
      * @returns Promise with cart details
+     * @throws Error if no cartId is provided and none is stored
      */
     async getCart(cartId) {
+        // Use provided cartId or stored cartId
+        const id = cartId || this.getCartId();
+        if (!id) {
+            throw new Error("Cart ID is required but not provided");
+        }
         return this.executeRequest(async () => {
             const { data, error } = await this.client.GET("/carts/{id}", {
                 params: {
-                    path: { id: cartId },
+                    path: { id },
                 },
             });
             if (error) {
@@ -43,21 +87,78 @@ class CartClient extends client_1.StorefrontAPIClient {
         });
     }
     /**
-     * Delete a cart by ID
+     * Delete a cart - either by ID or using the stored cart ID
      *
-     * @param cartId - The ID of the cart
+     * @param cartId - Optional cart ID (if not provided, uses stored cart ID)
      * @returns Promise that resolves when the cart is deleted
+     * @throws Error if no cartId is provided and none is stored
      */
     async deleteCart(cartId) {
-        const { error } = await this.client.DELETE("/carts/{id}", {
-            params: {
-                path: { id: cartId },
-            },
-            body: undefined,
+        // Use provided cartId or stored cartId
+        const id = cartId || this.getCartId();
+        if (!id) {
+            throw new Error("Cart ID is required but not provided");
+        }
+        return this.executeRequest(async () => {
+            const { error } = await this.client.DELETE("/carts/{id}", {
+                params: {
+                    path: { id },
+                },
+                body: undefined,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            // Clear the stored cart ID if we deleted the current cart
+            if (cartId === undefined || cartId === this.getCartId()) {
+                this.clearCartId();
+            }
         });
-        if (error) {
-            this.handleError(error);
+    }
+    /**
+     * Add item to cart - either by specified ID or stored cart ID
+     * Will create a new cart if no cart ID is available
+     *
+     * @param item - The item to add to the cart
+     * @param cartId - Optional cart ID (if not provided, uses stored cart ID or creates a new cart)
+     * @returns Promise with updated or created cart
+     */
+    async addItem(item, cartId) {
+        // Check if we have a cart ID (either provided or stored)
+        const id = cartId || this.getCartId();
+        // If we don't have a cart ID, create a new cart
+        if (!id) {
+            return this.createCart({ items: [item] });
+        }
+        // Otherwise update existing cart
+        return this.updateCartItem(id, item);
+    }
+    /**
+     * Update cart items (add, update quantity, remove)
+     *
+     * @param cartId - The ID of the cart or undefined to use stored cart ID
+     * @param item - The item data
+     * @returns Promise with updated cart
+     * @throws Error if no cartId is provided and none is stored
+     */
+    async updateCartItem(cartId, item) {
+        // Use provided cartId or stored cartId
+        const id = cartId || this.getCartId();
+        if (!id) {
+            throw new Error("Cart ID is required but not provided");
         }
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.POST("/carts/{id}/items", {
+                params: {
+                    path: { id },
+                },
+                body: item,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
+        });
     }
     /**
      * Get cart details by user ID
@@ -66,15 +167,17 @@ class CartClient extends client_1.StorefrontAPIClient {
      * @returns Promise with cart details
      */
     async getUserCart(userId) {
-        const { data, error } = await this.client.GET("/carts/users/{user_id}", {
-            params: {
-                path: { user_id: userId },
-            },
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/carts/users/{user_id}", {
+                params: {
+                    path: { user_id: userId },
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Delete a cart by user ID
@@ -83,34 +186,17 @@ class CartClient extends client_1.StorefrontAPIClient {
      * @returns Promise that resolves when the cart is deleted
      */
     async deleteUserCart(userId) {
-        const { error } = await this.client.DELETE("/carts/users/{user_id}", {
-            params: {
-                path: { user_id: userId },
-            },
-            body: undefined,
-        });
-        if (error) {
-            this.handleError(error);
-        }
-    }
-    /**
-     * Update cart items (add, update quantity, remove)
-     *
-     * @param cartId - The ID of the cart
-     * @param item - The item data
-     * @returns Promise with updated cart
-     */
-    async updateCartItem(cartId, item) {
-        const { data, error } = await this.client.POST("/carts/{id}/items", {
-            params: {
-                path: { id: cartId },
-            },
-            body: item,
+        return this.executeRequest(async () => {
+            const { error } = await this.client.DELETE("/carts/users/{user_id}", {
+                params: {
+                    path: { user_id: userId },
+                },
+                body: undefined,
+            });
+            if (error) {
+                this.handleError(error);
+            }
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Update cart addresses
@@ -120,16 +206,18 @@ class CartClient extends client_1.StorefrontAPIClient {
      * @returns Promise with updated cart
      */
     async updateCartAddress(cartId, addressData) {
-        const { data, error } = await this.client.POST("/carts/{id}/address", {
-            params: {
-                path: { id: cartId },
-            },
-            body: addressData,
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.POST("/carts/{id}/address", {
+                params: {
+                    path: { id: cartId },
+                },
+                body: addressData,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Apply a coupon to the cart
@@ -139,16 +227,18 @@ class CartClient extends client_1.StorefrontAPIClient {
      * @returns Promise with updated cart
      */
     async applyCoupon(cartId, couponCode) {
-        const { data, error } = await this.client.POST("/carts/{id}/coupon", {
-            params: {
-                path: { id: cartId },
-            },
-            body: { coupon_code: couponCode },
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.POST("/carts/{id}/coupon", {
+                params: {
+                    path: { id: cartId },
+                },
+                body: { coupon_code: couponCode },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Remove a coupon from the cart
@@ -157,16 +247,18 @@ class CartClient extends client_1.StorefrontAPIClient {
      * @returns Promise with updated cart
      */
     async removeCoupon(cartId) {
-        const { data, error } = await this.client.DELETE("/carts/{id}/coupon", {
-            params: {
-                path: { id: cartId },
-            },
-            body: undefined,
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.DELETE("/carts/{id}/coupon", {
+                params: {
+                    path: { id: cartId },
+                },
+                body: undefined,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Redeem loyalty points
@@ -176,16 +268,18 @@ class CartClient extends client_1.StorefrontAPIClient {
      * @returns Promise with updated cart
      */
     async redeemLoyaltyPoints(cartId, points) {
-        const { data, error } = await this.client.POST("/carts/{id}/loyalty-points", {
-            params: {
-                path: { id: cartId },
-            },
-            body: { loyalty_point_redeemed: points },
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.POST("/carts/{id}/loyalty-points", {
+                params: {
+                    path: { id: cartId },
+                },
+                body: { loyalty_point_redeemed: points },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Remove loyalty points
@@ -194,16 +288,18 @@ class CartClient extends client_1.StorefrontAPIClient {
      * @returns Promise with updated cart
      */
     async removeLoyaltyPoints(cartId) {
-        const { data, error } = await this.client.DELETE("/carts/{id}/loyalty-points", {
-            params: {
-                path: { id: cartId },
-            },
-            body: undefined,
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.DELETE("/carts/{id}/loyalty-points", {
+                params: {
+                    path: { id: cartId },
+                },
+                body: undefined,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
 }
 exports.CartClient = CartClient;

package/dist/lib/catalog.js

@@ -31,16 +31,18 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with product details
      */
     async getProductDetail(productId, options) {
-        const { data, error } = await this.client.GET("/catalog/products/{product_id}", {
-            params: {
-                path: { product_id: productId },
-                query: options,
-            },
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/catalog/products/{product_id}", {
+                params: {
+                    path: { product_id: productId },
+                    query: options,
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * List variants for a specific product
@@ -50,16 +52,18 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with variants
      */
     async listProductVariants(productId, options) {
-        const { data, error } = await this.client.GET("/catalog/products/{product_id}/variants", {
-            params: {
-                path: { product_id: productId },
-                query: options,
-            },
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/catalog/products/{product_id}/variants", {
+                params: {
+                    path: { product_id: productId },
+                    query: options,
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Get details for a specific variant
@@ -70,19 +74,21 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with variant details
      */
     async getVariantDetail(productId, variantId, options) {
-        const { data, error } = await this.client.GET("/catalog/products/{product_id}/variants/{variant_id}", {
-            params: {
-                path: {
-                    product_id: productId,
-                    variant_id: variantId,
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/catalog/products/{product_id}/variants/{variant_id}", {
+                params: {
+                    path: {
+                        product_id: productId,
+                        variant_id: variantId,
+                    },
+                    query: options,
                 },
-                query: options,
-            },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * List all categories
@@ -91,13 +97,15 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with categories and pagination info
      */
     async listCategories(options) {
-        const { data, error } = await this.client.GET("/catalog/categories", {
-            params: { query: options },
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/catalog/categories", {
+                params: { query: options },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * List reviews for a specific product
@@ -107,16 +115,18 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with reviews and pagination info
      */
     async listProductReviews(productId, options) {
-        const { data, error } = await this.client.GET("/catalog/products/{product_id}/reviews", {
-            params: {
-                path: { product_id: productId },
-                query: options,
-            },
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.GET("/catalog/products/{product_id}/reviews", {
+                params: {
+                    path: { product_id: productId },
+                    query: options,
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Create a review for a specific product
@@ -128,16 +138,18 @@ class CatalogClient extends client_1.StorefrontAPIClient {
     async createProductReview(productId, reviewData) {
         // Note: In a real implementation, you would need to handle multipart/form-data
         // This would require FormData and may need additional handling
-        const { error } = await this.client.POST("/catalog/products/{product_id}/reviews", {
-            params: {
-                path: { product_id: productId },
-            },
-            body: reviewData,
-            // This is simplified as we're not properly handling multipart/form-data
+        return this.executeRequest(async () => {
+            const { error } = await this.client.POST("/catalog/products/{product_id}/reviews", {
+                params: {
+                    path: { product_id: productId },
+                },
+                body: reviewData,
+                // This is simplified as we're not properly handling multipart/form-data
+            });
+            if (error) {
+                this.handleError(error);
+            }
         });
-        if (error) {
-            this.handleError(error);
-        }
     }
     /**
      * Search for products
@@ -146,13 +158,15 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with search results
      */
     async searchProducts(searchData) {
-        const { data, error } = await this.client.POST("/catalog/products/search", {
-            body: searchData,
+        return this.executeRequest(async () => {
+            const { data, error } = await this.client.POST("/catalog/products/search", {
+                body: searchData,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
         });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
     }
     /**
      * Get product details by ID (alternative implementation)

package/dist/lib/client.d.ts

@@ -61,6 +61,7 @@ export declare class StorefrontAPIClient {
     private headers;
     private readonly baseUrl;
     private isRefreshing;
+    private static sharedConfigs;
     /**
      * Create a new StorefrontAPIClient
      *

package/dist/lib/client.js

@@ -44,25 +44,51 @@ class StorefrontAPIClient {
      */
     constructor(config) {
         this.isRefreshing = false;
-        this.config = config;
+        // Use shared config reference for the same storeId to ensure all clients use the same config
+        const storeKey = config.storeId + (config.baseUrl || config.environment || "");
+        if (!StorefrontAPIClient.sharedConfigs.has(storeKey)) {
+            StorefrontAPIClient.sharedConfigs.set(storeKey, { ...config });
+        }
+        // Use the shared config reference
+        this.config = StorefrontAPIClient.sharedConfigs.get(storeKey);
+        // Copy non-shared values from the provided config
+        if (config.token && !this.config.token) {
+            this.config.token = config.token;
+        }
+        if (config.apiKey && !this.config.apiKey) {
+            this.config.apiKey = config.apiKey;
+        }
         this.headers = {
             "Content-Type": "application/json",
         };
-        if (config.token) {
-            this.headers["Authorization"] = `Bearer ${config.token}`;
+        if (this.config.token) {
+            this.headers["Authorization"] = `Bearer ${this.config.token}`;
         }
-        if (config.apiKey) {
-            this.headers["X-Api-Key"] = config.apiKey;
+        if (this.config.apiKey) {
+            this.headers["X-Api-Key"] = this.config.apiKey;
         }
         // Determine base URL from environment or use custom URL if provided
-        this.baseUrl = this.getBaseUrlFromConfig(config);
+        this.baseUrl = this.getBaseUrlFromConfig(this.config);
         this.client = (0, openapi_fetch_1.default)({
             baseUrl: this.baseUrl,
             fetch: (input, init) => {
                 // Add timeout if configured
-                const timeoutSignal = config.timeout
-                    ? AbortSignal.timeout(config.timeout)
+                const timeoutSignal = this.config.timeout
+                    ? AbortSignal.timeout(this.config.timeout)
                     : undefined;
+                // Always check for the most current token and API key before each request
+                if (this.config.token) {
+                    this.headers["Authorization"] = `Bearer ${this.config.token}`;
+                }
+                else {
+                    delete this.headers["Authorization"];
+                }
+                if (this.config.apiKey) {
+                    this.headers["X-Api-Key"] = this.config.apiKey;
+                }
+                else {
+                    delete this.headers["X-Api-Key"];
+                }
                 // Merge headers
                 const headers = {
                     ...this.headers,
@@ -237,3 +263,5 @@ class StorefrontAPIClient {
     }
 }
 exports.StorefrontAPIClient = StorefrontAPIClient;
+// Shared static reference for configs by storeId to ensure all clients use the same config
+StorefrontAPIClient.sharedConfigs = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commercengine/storefront-sdk",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "TypeScript SDK for the Storefront API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",