@commercengine/storefront-sdk 0.3.0 → 0.3.2

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 { StorefrontSDKOptions } from "../index";
 /**
  * Available API environments
  */
@@ -12,76 +15,23 @@ export declare enum Environment {
      */
     Production = "production"
 }
-import type { paths } from "../types/storefront";
-/**
- * Configuration options for the StorefrontAPI client
- */
-export interface StorefrontAPIConfig {
-    /**
-     * The store ID to use for API requests
-     */
-    storeId: string;
-    /**
-     * The environment to use (staging or production)
-     */
-    environment?: Environment;
-    /**
-     * Custom base URL (overrides environment-based URL if provided)
-     */
-    baseUrl?: string;
-    /**
-     * Optional authentication token
-     */
-    token?: string;
-    /**
-     * X-Api-Key for anonymous authentication endpoints
-     * Required for initial authentication
-     */
-    apiKey?: string;
-    /**
-     * Optional timeout in milliseconds
-     */
-    timeout?: number;
-}
-/**
- * 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;
+    protected config: StorefrontSDKOptions;
     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);
+    constructor(config: StorefrontSDKOptions);
+    /**
+     * Set up timeout middleware
+     */
+    private setupTimeoutMiddleware;
     /**
      * Constructs the base URL from the configuration
      *
@@ -97,20 +47,31 @@ 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
+     * Set authentication tokens
      *
-     * @param token - The authentication token
+     * @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
      */
-    setToken(token: string): void;
+    setTokens(accessToken: string, refreshToken?: string): Promise<void>;
     /**
-     * Clear the authentication token
+     * Clear all authentication tokens
+     *
+     * Behavior:
+     * - If tokenStorage is provided: Clears both access and refresh tokens from storage
+     * - If tokenStorage is not provided: Clears the manual access token
      */
-    clearToken(): void;
+    clearTokens(): Promise<void>;
     /**
      * Set the X-Api-Key header
      *
@@ -122,26 +83,18 @@ export declare class StorefrontAPIClient {
      */
     clearApiKey(): void;
     /**
-     * Handle API errors
-     *
-     * @param error - Error object from OpenAPI-Fetch
-     * @throws Rethrows the error with additional context
-     */
-    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>>;
 }