@commercengine/storefront-sdk 0.1.2 → 0.2.0

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,51 +148,65 @@ 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;
         secure: boolean;
         sameSite: string;
+        httpOnly: boolean;
         maxAge: number;
     });
     /**
@@ -219,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);
     /**
@@ -249,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;
 /**
@@ -453,11 +479,13 @@ class CookieTokenStorage {
     constructor(prefix = "storefront_", cookieOptions = {
         path: "/",
         secure: true,
-        sameSite: "strict",
+        sameSite: "lax",
+        httpOnly: true,
         maxAge: 60 * 60 * 24 * 30, // 30 days
     }) {
         this.accessTokenKey = `${prefix}access_token`;
         this.refreshTokenKey = `${prefix}refresh_token`;
+        this.cartIdKey = `${prefix}cart_id`;
         this.cookieOptions = cookieOptions;
     }
     /**
@@ -519,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;
 /**
@@ -574,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;
     }
     /**
@@ -651,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,74 @@ 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) {
+        // Use provided cartId or stored cartId
+        const id = cartId || this.getCartId();
+        if (!id) {
+            throw new Error("Cart ID is required but not provided");
+        }
         const { error } = await this.client.DELETE("/carts/{id}", {
             params: {
-                path: { id: cartId },
+                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();
+        }
+    }
+    /**
+     * 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");
+        }
+        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
@@ -93,25 +190,6 @@ class CartClient extends client_1.StorefrontAPIClient {
             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,
-        });
-        if (error) {
-            this.handleError(error);
-        }
-        return data?.content;
-    }
     /**
      * Update cart addresses
      *

package/package.json

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