@commercengine/storefront-sdk 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -1,7 +1,13 @@
 import { StorefrontAPIClient, Environment } from "./lib/client";
 import { CatalogClient } from "./lib/catalog";
 import { CartClient } from "./lib/cart";
-import { AuthClient, TokenStorage } from "./lib/auth";
+import { AuthClient } from "./lib/auth";
+import { OrderClient } from "./lib/order";
+import { ShippingClient } from "./lib/shipping";
+import { HelpersClient } from "./lib/helper";
+import { CustomerClient } from "./lib/customer";
+import { TokenStorage, MemoryTokenStorage, BrowserTokenStorage } from "./lib/middleware";
+import { type UserInfo } from "./lib/jwt-utils";
 /**
  * SDK initialization options
  */
@@ -19,9 +25,17 @@ export interface StorefrontSDKOptions {
      */
     baseUrl?: string;
     /**
-     * Optional authentication token
+     * Optional initial access token
+     * - If tokenStorage is provided: Used as initial token value, then managed automatically
+     * - If tokenStorage is not provided: Used for manual token management
      */
-    token?: string;
+    accessToken?: string;
+    /**
+     * Optional initial refresh token
+     * - Only used when tokenStorage is provided
+     * - Allows initialization with both access and refresh tokens
+     */
+    refreshToken?: string;
     /**
      * X-Api-Key for anonymous authentication endpoints
      * Required for initial authentication
@@ -32,10 +46,18 @@ export interface StorefrontSDKOptions {
      */
     timeout?: number;
     /**
-     * Optional token storage strategy
-     * Defaults to MemoryTokenStorage if not provided
+     * Optional token storage for automatic token management
+     * If provided, enables automatic token refresh and management
      */
     tokenStorage?: TokenStorage;
+    /**
+     * Callback when tokens are updated (login/refresh)
+     */
+    onTokensUpdated?: (accessToken: string, refreshToken: string) => void;
+    /**
+     * Callback when tokens are cleared (logout/error)
+     */
+    onTokensCleared?: () => void;
 }
 /**
  * Main SDK class for the Storefront API
@@ -54,13 +76,21 @@ export declare class StorefrontSDK {
      */
     readonly auth: AuthClient;
     /**
-     * The client storage instance used by this SDK
+     * Client for customer-related endpoints
+     */
+    readonly customer: CustomerClient;
+    /**
+     * Client for helper-related endpoints
      */
-    private readonly clientStorage;
+    readonly helpers: HelpersClient;
     /**
-     * Whether the SDK has been initialized
+     * Client for shipping-related endpoints
      */
-    private isInitialized;
+    readonly shipping: ShippingClient;
+    /**
+     * Client for order-related endpoints
+     */
+    readonly order: OrderClient;
     /**
      * Create a new StorefrontSDK instance
      *
@@ -68,58 +98,79 @@ export declare class StorefrontSDK {
      */
     constructor(options: StorefrontSDKOptions);
     /**
-     * Set up storage with automatic fallback for non-browser environments
+     * Set authentication tokens for all clients
+     *
+     * @param accessToken - The access token (required)
+     * @param refreshToken - The refresh token (optional)
+     *
+     * Behavior:
+     * - If tokenStorage is provided: Stores tokens for automatic management
+     * - If tokenStorage is not provided: Only stores access token for manual management
      */
-    private setupStorage;
+    setTokens(accessToken: string, refreshToken?: string): Promise<void>;
     /**
-     * Initialize the SDK
-     * This method should be called before using any SDK features
-     * It ensures tokens are available and valid
-     * @returns Promise that resolves when initialization is complete
+     * Clear all authentication tokens from all clients
+     *
+     * Behavior:
+     * - If tokenStorage is provided: Clears both access and refresh tokens from storage
+     * - If tokenStorage is not provided: Clears the manual access token
      */
-    init(): Promise<void>;
+    clearTokens(): Promise<void>;
     /**
-     * Get the current user ID if available
+     * Set the API key for all clients
+     *
+     * @param apiKey - The API key to set
      */
-    getUserId(): Promise<string | null>;
+    setApiKey(apiKey: string): void;
     /**
-     * Get the current cart ID if one is stored
-     *
-     * @returns The current cart ID or null if none exists
+     * Clear the API key from all clients
+     */
+    clearApiKey(): void;
+    /**
+     * Get the current access token if using token storage
      */
-    getCartId(): Promise<string | null>;
+    getAccessToken(): Promise<string | null>;
     /**
-     * Set a specific cart ID to use
+     * Get user information from the current access token
      *
-     * @param cartId - The cart ID to use
+     * @returns User information extracted from JWT token, or null if no token or invalid token
      */
-    setCartId(cartId: string): Promise<void>;
+    getUserInfo(): Promise<UserInfo | null>;
     /**
-     * Clear the current cart ID
+     * Get the current user ID from the access token
+     *
+     * @returns User ID (ulid) or null if no token or invalid token
      */
-    clearCartId(): Promise<void>;
+    getUserId(): Promise<string | null>;
     /**
-     * Set the authentication token for all clients
-     * Also stores the token in the configured storage
+     * Check if the current user is logged in (not anonymous)
+     *
+     * @returns True if user is logged in, false if anonymous or no token
      */
-    setToken(token: string): Promise<void>;
+    isLoggedIn(): Promise<boolean>;
     /**
-     * Clear the authentication token from all clients and storage
+     * Check if the current user is anonymous
+     *
+     * @returns True if user is anonymous or no token, false if logged in
      */
-    clearToken(): Promise<void>;
+    isAnonymous(): Promise<boolean>;
     /**
-     * Set the API key for all clients
+     * Get the customer ID from the current access token
      *
-     * @param apiKey - The API key to set
+     * @returns Customer ID or null if no token, invalid token, or user has no customer ID
      */
-    setApiKey(apiKey: string): void;
+    getCustomerId(): Promise<string | null>;
     /**
-     * Clear the API key from all clients
+     * Get the customer group ID from the current access token
+     *
+     * @returns Customer group ID or null if no token, invalid token, or user has no customer group
      */
-    clearApiKey(): void;
+    getCustomerGroupId(): Promise<string | null>;
 }
 export default StorefrontSDK;
-export { StorefrontAPIClient, CatalogClient, CartClient, AuthClient };
+export { StorefrontAPIClient, AuthClient, CartClient, CatalogClient, CustomerClient, HelpersClient, ShippingClient, OrderClient };
 export { Environment };
-export { TokenStorage, MemoryTokenStorage, BrowserTokenStorage, CookieTokenStorage, NextCookieTokenStorage, createTokenStorage, } from "./lib/auth";
+export { TokenStorage, MemoryTokenStorage, BrowserTokenStorage };
+export type { UserInfo } from "./lib/jwt-utils";
 export type { components, operations, paths } from "./types/storefront";
+export type * from "./types/storefront-api-types";

package/dist/index.js

@@ -1,178 +1,207 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTokenStorage = exports.NextCookieTokenStorage = exports.CookieTokenStorage = exports.BrowserTokenStorage = exports.MemoryTokenStorage = exports.Environment = exports.AuthClient = exports.CartClient = exports.CatalogClient = exports.StorefrontAPIClient = exports.StorefrontSDK = void 0;
-const client_1 = require("./lib/client");
-Object.defineProperty(exports, "StorefrontAPIClient", { enumerable: true, get: function () { return client_1.StorefrontAPIClient; } });
-Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return client_1.Environment; } });
-const catalog_1 = require("./lib/catalog");
-Object.defineProperty(exports, "CatalogClient", { enumerable: true, get: function () { return catalog_1.CatalogClient; } });
-const cart_1 = require("./lib/cart");
-Object.defineProperty(exports, "CartClient", { enumerable: true, get: function () { return cart_1.CartClient; } });
-const auth_1 = require("./lib/auth");
-Object.defineProperty(exports, "AuthClient", { enumerable: true, get: function () { return auth_1.AuthClient; } });
+import { StorefrontAPIClient, Environment, } from "./lib/client";
+import { CatalogClient } from "./lib/catalog";
+import { CartClient } from "./lib/cart";
+import { AuthClient } from "./lib/auth";
+import { OrderClient } from "./lib/order";
+import { ShippingClient } from "./lib/shipping";
+import { HelpersClient } from "./lib/helper";
+import { CustomerClient } from "./lib/customer";
+import { MemoryTokenStorage, BrowserTokenStorage, } from "./lib/middleware";
+import { extractUserInfoFromToken, getUserIdFromToken, isUserLoggedIn, isUserAnonymous, } from "./lib/jwt-utils";
 /**
  * Main SDK class for the Storefront API
  */
-class StorefrontSDK {
+export class StorefrontSDK {
+    /**
+     * Client for catalog-related endpoints (products, categories, etc.)
+     */
+    catalog;
+    /**
+     * Client for cart-related endpoints
+     */
+    cart;
+    /**
+     * Client for authentication-related endpoints
+     */
+    auth;
+    /**
+     * Client for customer-related endpoints
+     */
+    customer;
+    /**
+     * Client for helper-related endpoints
+     */
+    helpers;
+    /**
+     * Client for shipping-related endpoints
+     */
+    shipping;
+    /**
+     * Client for order-related endpoints
+     */
+    order;
     /**
      * Create a new StorefrontSDK instance
      *
      * @param options - Configuration options for the SDK
      */
     constructor(options) {
-        /**
-         * Whether the SDK has been initialized
-         */
-        this.isInitialized = false;
-        // Set up client storage with fallback handling
-        this.clientStorage = this.setupStorage(options.tokenStorage);
         // Convert options to internal config format
         const config = {
             storeId: options.storeId,
             environment: options.environment,
             baseUrl: options.baseUrl,
-            token: options.token,
+            accessToken: options.accessToken,
+            refreshToken: options.refreshToken,
             apiKey: options.apiKey,
             timeout: options.timeout,
+            tokenStorage: options.tokenStorage,
+            onTokensUpdated: options.onTokensUpdated,
+            onTokensCleared: options.onTokensCleared,
         };
-        this.catalog = new catalog_1.CatalogClient(config);
-        this.cart = new cart_1.CartClient(config);
-        this.auth = new auth_1.AuthClient(config, this.clientStorage);
-        // Set client storage for cart management
-        this.cart.setClientStorage(this.clientStorage);
+        this.catalog = new CatalogClient(config);
+        this.cart = new CartClient(config);
+        this.auth = new AuthClient(config);
+        this.customer = new CustomerClient(config);
+        this.helpers = new HelpersClient(config);
+        this.shipping = new ShippingClient(config);
+        this.order = new OrderClient(config);
     }
     /**
-     * Set up storage with automatic fallback for non-browser environments
-     */
-    setupStorage(requestedStorage) {
-        if (!requestedStorage) {
-            return new auth_1.MemoryTokenStorage();
-        }
-        try {
-            // Test if the requested storage is available
-            requestedStorage.getItem("test");
-            // Check if it's a ClientStorage implementation
-            if ("getCartId" in requestedStorage &&
-                "setCartId" in requestedStorage &&
-                "clearCartId" in requestedStorage) {
-                return requestedStorage;
-            }
-            // If it's just a TokenStorage, wrap it in a MemoryTokenStorage for cart functionality
-            console.warn("Provided storage does not implement ClientStorage interface, wrapping with MemoryTokenStorage for cart functionality");
-            return new auth_1.MemoryTokenStorage();
-        }
-        catch (e) {
-            // If storage access fails, fallback to memory storage
-            console.warn("Requested storage is not available in this environment, falling back to memory storage");
-            return new auth_1.MemoryTokenStorage();
-        }
+     * Set authentication tokens for all clients
+     *
+     * @param accessToken - The access token (required)
+     * @param refreshToken - The refresh token (optional)
+     *
+     * Behavior:
+     * - If tokenStorage is provided: Stores tokens for automatic management
+     * - If tokenStorage is not provided: Only stores access token for manual management
+     */
+    async setTokens(accessToken, refreshToken) {
+        await this.catalog.setTokens(accessToken, refreshToken);
+        await this.cart.setTokens(accessToken, refreshToken);
+        await this.auth.setTokens(accessToken, refreshToken);
+        await this.customer.setTokens(accessToken, refreshToken);
+        await this.helpers.setTokens(accessToken, refreshToken);
+        await this.shipping.setTokens(accessToken, refreshToken);
+        await this.order.setTokens(accessToken, refreshToken);
     }
     /**
-     * Initialize the SDK
-     * This method should be called before using any SDK features
-     * It ensures tokens are available and valid
-     * @returns Promise that resolves when initialization is complete
-     */
-    async init() {
-        if (this.isInitialized) {
-            return;
-        }
-        try {
-            // Try to get existing tokens from storage
-            const accessToken = await this.clientStorage.getItem("access_token");
-            const userData = await this.clientStorage.getItem("user_data");
-            if (accessToken && userData) {
-                // Set the token for all clients
-                await this.setToken(accessToken);
-            }
-            else {
-                // If no token exists or no user data, get a new anonymous token
-                const authResponse = await this.auth.getAnonymousToken();
-                await this.setToken(authResponse.access_token);
-                // Store user data
-                await this.clientStorage.setItem("user_data", JSON.stringify(authResponse.user));
-            }
-            this.isInitialized = true;
-        }
-        catch (error) {
-            console.error("Failed to initialize SDK:", error);
-            throw error;
-        }
+     * Clear all authentication tokens from all clients
+     *
+     * Behavior:
+     * - If tokenStorage is provided: Clears both access and refresh tokens from storage
+     * - If tokenStorage is not provided: Clears the manual access token
+     */
+    async clearTokens() {
+        await this.catalog.clearTokens();
+        await this.cart.clearTokens();
+        await this.auth.clearTokens();
+        await this.customer.clearTokens();
+        await this.helpers.clearTokens();
+        await this.shipping.clearTokens();
+        await this.order.clearTokens();
     }
     /**
-     * Get the current user ID if available
+     * Set the API key for all clients
+     *
+     * @param apiKey - The API key to set
      */
-    async getUserId() {
-        return this.clientStorage.getItem("user_id");
+    setApiKey(apiKey) {
+        this.catalog.setApiKey(apiKey);
+        this.cart.setApiKey(apiKey);
+        this.auth.setApiKey(apiKey);
+        this.customer.setApiKey(apiKey);
+        this.helpers.setApiKey(apiKey);
+        this.shipping.setApiKey(apiKey);
+        this.order.setApiKey(apiKey);
     }
     /**
-     * Get the current cart ID if one is stored
-     *
-     * @returns The current cart ID or null if none exists
+     * Clear the API key from all clients
      */
-    async getCartId() {
-        return this.clientStorage.getCartId();
+    clearApiKey() {
+        this.catalog.clearApiKey();
+        this.cart.clearApiKey();
+        this.auth.clearApiKey();
+        this.customer.clearApiKey();
+        this.helpers.clearApiKey();
+        this.shipping.clearApiKey();
+        this.order.clearApiKey();
     }
     /**
-     * Set a specific cart ID to use
+     * Get the current access token if using token storage
+     */
+    async getAccessToken() {
+        return await this.auth.getAuthorizationHeader().then(header => header.startsWith('Bearer ') ? header.substring(7) : null);
+    }
+    /**
+     * Get user information from the current access token
      *
-     * @param cartId - The cart ID to use
+     * @returns User information extracted from JWT token, or null if no token or invalid token
      */
-    async setCartId(cartId) {
-        await this.clientStorage.setCartId(cartId);
+    async getUserInfo() {
+        const token = await this.getAccessToken();
+        if (!token)
+            return null;
+        return extractUserInfoFromToken(token);
     }
     /**
-     * Clear the current cart ID
+     * Get the current user ID from the access token
+     *
+     * @returns User ID (ulid) or null if no token or invalid token
      */
-    async clearCartId() {
-        await this.clientStorage.clearCartId();
+    async getUserId() {
+        const token = await this.getAccessToken();
+        if (!token)
+            return null;
+        return getUserIdFromToken(token);
     }
     /**
-     * Set the authentication token for all clients
-     * Also stores the token in the configured storage
+     * Check if the current user is logged in (not anonymous)
+     *
+     * @returns True if user is logged in, false if anonymous or no token
      */
-    async setToken(token) {
-        this.catalog.setToken(token);
-        this.cart.setToken(token);
-        this.auth.setToken(token);
-        await this.clientStorage.setItem("access_token", token);
+    async isLoggedIn() {
+        const token = await this.getAccessToken();
+        if (!token)
+            return false;
+        return isUserLoggedIn(token);
     }
     /**
-     * Clear the authentication token from all clients and storage
+     * Check if the current user is anonymous
+     *
+     * @returns True if user is anonymous or no token, false if logged in
      */
-    async clearToken() {
-        this.catalog.clearToken();
-        this.cart.clearToken();
-        this.auth.clearToken();
-        await this.clientStorage.removeItem("access_token");
-        await this.clientStorage.removeItem("refresh_token");
+    async isAnonymous() {
+        const token = await this.getAccessToken();
+        if (!token)
+            return true;
+        return isUserAnonymous(token);
     }
     /**
-     * Set the API key for all clients
+     * Get the customer ID from the current access token
      *
-     * @param apiKey - The API key to set
+     * @returns Customer ID or null if no token, invalid token, or user has no customer ID
      */
-    setApiKey(apiKey) {
-        this.catalog.setApiKey(apiKey);
-        this.cart.setApiKey(apiKey);
-        this.auth.setApiKey(apiKey);
+    async getCustomerId() {
+        const userInfo = await this.getUserInfo();
+        return userInfo?.customerId || null;
     }
     /**
-     * Clear the API key from all clients
+     * Get the customer group ID from the current access token
+     *
+     * @returns Customer group ID or null if no token, invalid token, or user has no customer group
      */
-    clearApiKey() {
-        this.catalog.clearApiKey();
-        this.cart.clearApiKey();
-        this.auth.clearApiKey();
+    async getCustomerGroupId() {
+        const userInfo = await this.getUserInfo();
+        return userInfo?.customerGroupId || null;
     }
 }
-exports.StorefrontSDK = StorefrontSDK;
 // Export the main SDK class
-exports.default = StorefrontSDK;
+export default StorefrontSDK;
+// Export individual clients for advanced usage
+export { StorefrontAPIClient, AuthClient, CartClient, CatalogClient, CustomerClient, HelpersClient, ShippingClient, OrderClient };
+// Export environment enum
+export { Environment };
 // Export token storage types
-var auth_2 = require("./lib/auth");
-Object.defineProperty(exports, "MemoryTokenStorage", { enumerable: true, get: function () { return auth_2.MemoryTokenStorage; } });
-Object.defineProperty(exports, "BrowserTokenStorage", { enumerable: true, get: function () { return auth_2.BrowserTokenStorage; } });
-Object.defineProperty(exports, "CookieTokenStorage", { enumerable: true, get: function () { return auth_2.CookieTokenStorage; } });
-Object.defineProperty(exports, "NextCookieTokenStorage", { enumerable: true, get: function () { return auth_2.NextCookieTokenStorage; } });
-Object.defineProperty(exports, "createTokenStorage", { enumerable: true, get: function () { return auth_2.createTokenStorage; } });
+export { MemoryTokenStorage, BrowserTokenStorage };

package/dist/lib/auth-utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Extract pathname from URL
+ */
+export declare function getPathnameFromUrl(url: string): string;
+/**
+ * Check if a URL path is an auth endpoint that should use API key
+ */
+export declare function isAnonymousAuthEndpoint(pathname: string): boolean;
+/**
+ * Check if a URL path is a login/register endpoint that returns tokens
+ */
+export declare function isTokenReturningEndpoint(pathname: string): boolean;
+/**
+ * Check if a URL path is the logout endpoint
+ */
+export declare function isLogoutEndpoint(pathname: string): boolean;

package/dist/lib/auth-utils.js

@@ -0,0 +1,38 @@
+/**
+ * Extract pathname from URL
+ */
+export function getPathnameFromUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        return urlObj.pathname;
+    }
+    catch {
+        // If URL parsing fails, assume it's a relative path
+        return url.split('?')[0];
+    }
+}
+/**
+ * Check if a URL path is an auth endpoint that should use API key
+ */
+export function isAnonymousAuthEndpoint(pathname) {
+    return pathname.endsWith("/auth/anonymous");
+}
+/**
+ * Check if a URL path is a login/register endpoint that returns tokens
+ */
+export function isTokenReturningEndpoint(pathname) {
+    const tokenEndpoints = [
+        "/auth/login/password",
+        "/auth/register/phone",
+        "/auth/register/email",
+        "/auth/verify-otp",
+        "/auth/refresh-token"
+    ];
+    return tokenEndpoints.some(endpoint => pathname.endsWith(endpoint));
+}
+/**
+ * Check if a URL path is the logout endpoint
+ */
+export function isLogoutEndpoint(pathname) {
+    return pathname.endsWith("/auth/logout");
+}