@commercengine/storefront-sdk 0.2.1 → 0.3.1

package/dist/lib/catalog.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CatalogClient = void 0;
-const client_1 = require("./client");
+import { StorefrontAPIClient } from "./client";
 /**
  * Client for interacting with catalog endpoints
  */
-class CatalogClient extends client_1.StorefrontAPIClient {
+export class CatalogClient extends StorefrontAPIClient {
     /**
      * List all products
      *
@@ -13,15 +10,20 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with products and pagination info
      */
     async listProducts(options) {
-        return this.executeRequest(async () => {
-            const { data, error } = await this.client.GET("/catalog/products", {
-                params: { query: options },
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            return data?.content;
-        });
+        return this.executeRequest(() => this.client.GET('/catalog/products', {
+            params: { query: options },
+        }));
+    }
+    /**
+     * List all skus
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with skus and pagination info
+     */
+    async listSkus(options) {
+        return this.executeRequest(() => this.client.GET('/catalog/skus', {
+            params: { query: options },
+        }));
     }
     /**
      * Get details for a specific product
@@ -30,19 +32,13 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @param options - Optional query parameters
      * @returns Promise with product details
      */
-    async getProductDetail(productId, 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;
-        });
+    async getProductDetail(pathParams, queryParams) {
+        return this.executeRequest(() => this.client.GET('/catalog/products/{product_id}', {
+            params: {
+                path: pathParams,
+                query: queryParams,
+            },
+        }));
     }
     /**
      * List variants for a specific product
@@ -51,19 +47,13 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @param options - Optional query parameters
      * @returns Promise with variants
      */
-    async listProductVariants(productId, 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;
-        });
+    async listProductVariants(pathParams, queryParams) {
+        return this.executeRequest(() => this.client.GET("/catalog/products/{product_id}/variants", {
+            params: {
+                path: pathParams,
+                query: queryParams,
+            },
+        }));
     }
     /**
      * Get details for a specific variant
@@ -73,22 +63,13 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @param options - Optional query parameters
      * @returns Promise with variant details
      */
-    async getVariantDetail(productId, variantId, options) {
-        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,
-                },
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            return data?.content;
-        });
+    async getVariantDetail(pathParams, queryParams) {
+        return this.executeRequest(() => this.client.GET("/catalog/products/{product_id}/variants/{variant_id}", {
+            params: {
+                path: pathParams,
+                query: queryParams,
+            },
+        }));
     }
     /**
      * List all categories
@@ -97,15 +78,9 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @returns Promise with categories and pagination info
      */
     async listCategories(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;
-        });
+        return this.executeRequest(() => this.client.GET("/catalog/categories", {
+            params: { query: options },
+        }));
     }
     /**
      * List reviews for a specific product
@@ -114,19 +89,13 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @param options - Optional query parameters
      * @returns Promise with reviews and pagination info
      */
-    async listProductReviews(productId, 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;
-        });
+    async listProductReviews(pathParams, queryParams) {
+        return this.executeRequest(() => this.client.GET("/catalog/products/{product_id}/reviews", {
+            params: {
+                path: pathParams,
+                query: queryParams,
+            },
+        }));
     }
     /**
      * Create a review for a specific product
@@ -135,56 +104,78 @@ class CatalogClient extends client_1.StorefrontAPIClient {
      * @param reviewData - The review data
      * @returns Promise that resolves when the review is created
      */
-    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
-        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);
+    async createProductReview(pathParams, formData) {
+        return this.executeRequest(() => this.client.POST("/catalog/products/{product_id}/reviews", {
+            params: {
+                path: pathParams,
+            },
+            body: formData,
+            bodySerializer: (body) => {
+                const fd = new FormData();
+                for (const [key, value] of Object.entries(body)) {
+                    if (value !== undefined && value !== null) {
+                        // Handle File objects directly
+                        if (value instanceof File || value instanceof Blob) {
+                            fd.append(key, value);
+                        }
+                        else {
+                            // Convert other values to string
+                            fd.append(key, String(value));
+                        }
+                    }
+                }
+                return fd;
             }
-        });
+        }));
     }
     /**
      * Search for products
      *
      * @param searchData - The search parameters
-     * @returns Promise with search results
+     * @returns Promise with search results, facet distribution, facet stats, and pagination
      */
     async searchProducts(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;
-        });
+        return this.executeRequest(() => this.client.POST("/catalog/products/search", {
+            body: searchData,
+        }));
     }
     /**
-     * Get product details by ID (alternative implementation)
-     * @param productId - The product ID to retrieve
-     * @returns Promise with the product details
+     * Retrieve cross-sell recommendations for a specific product
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with cross-sell recommendations with pagination
      */
-    async getProduct(productId) {
-        return this.executeRequest(async () => {
-            const { data, error } = await this.client.GET("/catalog/products/{product_id}", {
-                params: {
-                    path: { product_id: productId },
-                },
-            });
-            if (error) {
-                this.handleError(error);
-            }
-            return data?.content;
-        });
+    async listCrossSellProducts(options) {
+        return this.executeRequest(() => this.client.GET("/catalog/products/cross-sell", {
+            params: {
+                query: options,
+            },
+        }));
+    }
+    /**
+     * Retrieve up-sell recommendations for a specific product
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with up-sell recommendations with pagination
+     */
+    async listUpSellProducts(options) {
+        return this.executeRequest(() => this.client.GET("/catalog/products/up-sell", {
+            params: {
+                query: options,
+            },
+        }));
+    }
+    /**
+     * Retrieve related products for a specific product
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with related products with pagination
+     */
+    async listSimilarProducts(options) {
+        return this.executeRequest(() => this.client.GET("/catalog/products/similar", {
+            params: {
+                query: options,
+            },
+        }));
     }
 }
-exports.CatalogClient = CatalogClient;

package/dist/lib/client.d.ts

@@ -1,4 +1,7 @@
 import createClient from "openapi-fetch";
+import type { paths } from "../types/storefront";
+import { ApiErrorResponse, ApiResult } from "../types/storefront-api-types";
+import { type TokenStorage } from "./middleware";
 /**
  * Available API environments
  */
@@ -12,7 +15,6 @@ export declare enum Environment {
      */
     Production = "production"
 }
-import type { paths } from "../types/storefront";
 /**
  * Configuration options for the StorefrontAPI client
  */
@@ -30,7 +32,7 @@ export interface StorefrontAPIConfig {
      */
     baseUrl?: string;
     /**
-     * Optional authentication token
+     * Optional authentication token (for manual token management)
      */
     token?: string;
     /**
@@ -42,46 +44,37 @@ export interface StorefrontAPIConfig {
      * Optional timeout in milliseconds
      */
     timeout?: number;
+    /**
+     * Optional token storage for automatic token management
+     * If provided, enables automatic token refresh and management via middleware
+     */
+    tokenStorage?: TokenStorage;
+    /**
+     * Callback when tokens are updated (login/refresh)
+     */
+    onTokensUpdated?: (accessToken: string, refreshToken: string) => void;
+    /**
+     * Callback when tokens are cleared (logout/error)
+     */
+    onTokensCleared?: () => void;
 }
-/**
- * Error response from the API
- */
-export type ApiErrorResponse = {
-    message?: string;
-    success: boolean;
-    code?: string;
-    error?: Record<string, any>;
-};
 /**
  * Base API client for Storefront API
  */
 export declare class StorefrontAPIClient {
     protected client: ReturnType<typeof createClient<paths>>;
     protected config: StorefrontAPIConfig;
-    private headers;
     private readonly baseUrl;
-    private isRefreshing;
-    private static sharedConfigs;
     /**
      * Create a new StorefrontAPIClient
      *
      * @param config - Configuration for the API client
-     *
-     * @remarks
-     * This client implements a token refresh mechanism that will:
-     * 1. Automatically retry requests that fail with a 401 error
-     * 2. Refresh the token before retrying the request
-     * 3. If the token refresh fails, the original error will be thrown
-     *
-     * This behavior is inherited by all client classes that extend StorefrontAPIClient.
-     *
-     * When using the AuthClient, tokens can be stored persistently in:
-     * - Memory (default) - Tokens are lost when the page refreshes or app restarts
-     * - Browser localStorage - Tokens persist across page refreshes
-     * - Cookies - Tokens persist across page refreshes and can be read server-side
-     * - Next.js cookies API - For server-side components
      */
     constructor(config: StorefrontAPIConfig);
+    /**
+     * Set up timeout middleware
+     */
+    private setupTimeoutMiddleware;
     /**
      * Constructs the base URL from the configuration
      *
@@ -97,20 +90,23 @@ export declare class StorefrontAPIClient {
     getBaseUrl(): string;
     /**
      * Get the authorization header value
+     * If using token storage, gets the current token from storage
+     * Otherwise returns the manual token
      *
      * @returns The Authorization header value or empty string if no token is set
      */
-    getAuthorizationHeader(): string;
+    getAuthorizationHeader(): Promise<string>;
     /**
      * Set the authentication token
+     * If using token storage, stores the token; otherwise sets manual token
      *
      * @param token - The authentication token
      */
-    setToken(token: string): void;
+    setToken(token: string): Promise<void>;
     /**
      * Clear the authentication token
      */
-    clearToken(): void;
+    clearToken(): Promise<void>;
     /**
      * Set the X-Api-Key header
      *
@@ -129,19 +125,18 @@ export declare class StorefrontAPIClient {
      */
     protected handleError(error: any): Promise<never>;
     /**
-     * Attempt to refresh the token
-     * This is a placeholder method that will be overridden by AuthClient
-     *
-     * @returns Promise that resolves to true if token was refreshed, false otherwise
-     */
-    protected attemptTokenRefresh(): Promise<boolean>;
-    /**
-     * Execute a request with automatic token refresh handling
-     * For AuthClient, this will attempt to refresh the token and retry once on 401 errors
-     * Base implementation just executes the request
+     * Execute a request and handle the response
      *
-     * @param requestFn - Function that executes the API request
+     * @param apiCall - Function that executes the API request
      * @returns Promise with the API response
      */
-    protected executeRequest<T>(requestFn: () => Promise<T>): Promise<T>;
+    protected executeRequest<T>(apiCall: () => Promise<{
+        data?: {
+            message?: string;
+            success?: boolean;
+            content?: T;
+        };
+        error?: ApiErrorResponse;
+        response: Response;
+    }>): Promise<ApiResult<T>>;
 }