@commercengine/storefront-sdk 0.2.1 → 0.3.1

package/dist/lib/client.js

@@ -1,14 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorefrontAPIClient = exports.Environment = void 0;
-const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
+import createClient from "openapi-fetch";
+import { createDefaultAuthMiddleware } from "./middleware";
 /**
  * Available API environments
  */
-var Environment;
+export var Environment;
 (function (Environment) {
     /**
      * Staging environment
@@ -18,87 +13,62 @@ var Environment;
      * Production environment
      */
     Environment["Production"] = "production";
-})(Environment || (exports.Environment = Environment = {}));
+})(Environment || (Environment = {}));
 /**
  * Base API client for Storefront API
  */
-class StorefrontAPIClient {
+export class StorefrontAPIClient {
+    client;
+    config;
+    baseUrl;
     /**
      * 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) {
-        this.isRefreshing = false;
-        // 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 (this.config.token) {
-            this.headers["Authorization"] = `Bearer ${this.config.token}`;
-        }
-        if (this.config.apiKey) {
-            this.headers["X-Api-Key"] = this.config.apiKey;
-        }
+        this.config = { ...config };
         // Determine base URL from environment or use custom URL if provided
         this.baseUrl = this.getBaseUrlFromConfig(this.config);
-        this.client = (0, openapi_fetch_1.default)({
+        this.client = createClient({
             baseUrl: this.baseUrl,
-            fetch: (input, init) => {
-                // Add timeout if configured
-                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"];
+        });
+        // Set up auth middleware if token storage is provided
+        if (this.config.tokenStorage) {
+            const authMiddleware = createDefaultAuthMiddleware({
+                apiKey: this.config.apiKey,
+                baseUrl: this.baseUrl,
+                tokenStorage: this.config.tokenStorage,
+                onTokensUpdated: this.config.onTokensUpdated,
+                onTokensCleared: this.config.onTokensCleared,
+            });
+            this.client.use(authMiddleware);
+        }
+        // Set up timeout middleware if configured
+        if (this.config.timeout) {
+            this.setupTimeoutMiddleware();
+        }
+    }
+    /**
+     * Set up timeout middleware
+     */
+    setupTimeoutMiddleware() {
+        this.client.use({
+            onRequest: async ({ request }) => {
+                // Add timeout signal
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+                // Merge with existing signal if present
+                if (request.signal) {
+                    request.signal.addEventListener('abort', () => controller.abort());
                 }
-                // Merge headers
-                const headers = {
-                    ...this.headers,
-                    ...(init?.headers || {}),
-                };
-                return fetch(input, {
-                    ...init,
-                    headers,
-                    signal: timeoutSignal || init?.signal,
+                // Create new request with timeout signal
+                const newRequest = new Request(request, {
+                    signal: controller.signal,
                 });
+                // Clean up timeout when request completes
+                controller.signal.addEventListener('abort', () => clearTimeout(timeoutId));
+                return newRequest;
             },
         });
     }
@@ -133,27 +103,42 @@ class StorefrontAPIClient {
     }
     /**
      * 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() {
+    async getAuthorizationHeader() {
+        if (this.config.tokenStorage) {
+            const token = await this.config.tokenStorage.getAccessToken();
+            return token ? `Bearer ${token}` : "";
+        }
         return this.config.token ? `Bearer ${this.config.token}` : "";
     }
     /**
      * Set the authentication token
+     * If using token storage, stores the token; otherwise sets manual token
      *
      * @param token - The authentication token
      */
-    setToken(token) {
-        this.config.token = token;
-        this.headers["Authorization"] = `Bearer ${token}`;
+    async setToken(token) {
+        if (this.config.tokenStorage) {
+            await this.config.tokenStorage.setAccessToken(token);
+        }
+        else {
+            this.config.token = token;
+        }
     }
     /**
      * Clear the authentication token
      */
-    clearToken() {
-        this.config.token = undefined;
-        delete this.headers["Authorization"];
+    async clearToken() {
+        if (this.config.tokenStorage) {
+            await this.config.tokenStorage.clearTokens();
+        }
+        else {
+            this.config.token = undefined;
+        }
     }
     /**
      * Set the X-Api-Key header
@@ -162,14 +147,12 @@ class StorefrontAPIClient {
      */
     setApiKey(apiKey) {
         this.config.apiKey = apiKey;
-        this.headers["X-Api-Key"] = apiKey;
     }
     /**
      * Clear the X-Api-Key header
      */
     clearApiKey() {
         this.config.apiKey = undefined;
-        delete this.headers["X-Api-Key"];
     }
     /**
      * Handle API errors
@@ -182,26 +165,6 @@ class StorefrontAPIClient {
         const statusCode = error.status || (error.response?.status ? error.response.status : 500);
         const errorData = error.data ||
             error.response?.data || { message: error.message || "Unknown error" };
-        // If we have a 401 error and we're not already in a refresh operation,
-        // attempt to refresh the token
-        if (statusCode === 401 && !this.isRefreshing) {
-            try {
-                this.isRefreshing = true;
-                const refreshed = await this.attemptTokenRefresh();
-                if (refreshed) {
-                    // Token refreshed successfully - no need to throw error
-                    // The calling method should retry the request
-                    this.isRefreshing = false;
-                    throw new Error("Token refreshed, please retry the request");
-                }
-            }
-            catch (refreshError) {
-                // If refresh fails, continue to throw the original error
-            }
-            finally {
-                this.isRefreshing = false;
-            }
-        }
         if (statusCode === 401) {
             throw new Error("Unauthorized: Please check your authentication token");
         }
@@ -216,52 +179,32 @@ class StorefrontAPIClient {
         }
     }
     /**
-     * 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
-     */
-    async attemptTokenRefresh() {
-        // Base implementation does nothing
-        // Will be overridden by AuthClient
-        return false;
-    }
-    /**
-     * 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
      */
-    async executeRequest(requestFn) {
+    async executeRequest(apiCall) {
         try {
-            return await requestFn();
-        }
-        catch (error) {
-            // Handle 401 errors by attempting to refresh token
-            if (error &&
-                typeof error === "object" &&
-                "status" in error &&
-                error.status === 401) {
-                // Attempt to refresh the token
-                const refreshed = await this.attemptTokenRefresh();
-                if (refreshed) {
-                    // If token was refreshed, retry the request once
-                    return await requestFn();
-                }
+            const { data, error } = await apiCall();
+            // openapi-fetch returns error for 4xx/5xx, data for 2xx
+            if (error) {
+                return { data: null, error };
             }
-            // Check if the error is from handleError and is the special refresh token message
-            if (error instanceof Error &&
-                error.message === "Token refreshed, please retry the request") {
-                // If token was refreshed, retry the request once
-                return await requestFn();
-            }
-            // Otherwise, throw the error to be handled by the caller
-            throw error;
+            // data will be defined for 2xx responses
+            return { data: data, error: null };
+        }
+        catch (err) {
+            // This handles network errors or other unexpected errors
+            return {
+                data: null,
+                error: {
+                    success: false,
+                    code: 'NETWORK_ERROR',
+                    message: 'Network error occurred',
+                    error: err,
+                },
+            };
         }
     }
 }
-exports.StorefrontAPIClient = StorefrontAPIClient;
-// Shared static reference for configs by storeId to ensure all clients use the same config
-StorefrontAPIClient.sharedConfigs = new Map();

package/dist/lib/customer.d.ts

@@ -0,0 +1,91 @@
+import { CreateAddressBody, CreateAddressContent, CreateAddressPathParams, CreateCustomerContent, DeleteAddressPathParams, DeleteAddressResponse, GetAddressDetailContent, GetAddressDetailPathParams, GetCustomerDetailContent, GetCustomerDetailPathParams, GetLoyaltyDetailsContent, GetLoyaltyDetailsPathParams, ListAddressesContent, ListAddressesPathParams, ListLoyaltyActivitiesContent, ListLoyaltyActivitiesPathParams, ListUserReviewsContent, ListUserReviewsPathParams, UpdateAddressDetailBody, UpdateAddressDetailContent, UpdateAddressDetailPathParams, UpdateCustomerBody, UpdateCustomerContent, UpdateCustomerPathParams } from "../types/storefront-api-types";
+import { CreateCustomerBody } from "../types/storefront-api-types";
+import { ApiResult } from "../types/storefront-api-types";
+import { StorefrontAPIClient } from "./client";
+import { StorefrontAPIConfig } from "./client";
+/**
+ * Client for interacting with customer endpoints
+ */
+export declare class CustomerClient extends StorefrontAPIClient {
+    constructor(config: StorefrontAPIConfig);
+    /**
+     * Create a customer
+     *
+     * @param body - Customer creation body
+     * @returns Promise with customer details
+     */
+    createCustomer(body: CreateCustomerBody): Promise<ApiResult<CreateCustomerContent>>;
+    /**
+     * Get customer details
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with customer details
+     */
+    getCustomer(pathParams: GetCustomerDetailPathParams): Promise<ApiResult<GetCustomerDetailContent>>;
+    /**
+     * Update a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Customer update body
+     * @returns Promise with customer details
+     */
+    updateCustomer(pathParams: UpdateCustomerPathParams, body: UpdateCustomerBody): Promise<ApiResult<UpdateCustomerContent>>;
+    /**
+     * Get all saved addresses for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with addresses
+     */
+    listAddresses(pathParams: ListAddressesPathParams): Promise<ApiResult<ListAddressesContent>>;
+    /**
+     * Create a new address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Address creation body
+     * @returns Promise with address details
+     */
+    createAddress(pathParams: CreateAddressPathParams, body: CreateAddressBody): Promise<ApiResult<CreateAddressContent>>;
+    /**
+     * Get an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with address details
+     */
+    getAddress(pathParams: GetAddressDetailPathParams): Promise<ApiResult<GetAddressDetailContent>>;
+    /**
+     * Update an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Address update body
+     * @returns Promise with address details
+     */
+    updateAddress(pathParams: UpdateAddressDetailPathParams, body: UpdateAddressDetailBody): Promise<ApiResult<UpdateAddressDetailContent>>;
+    /**
+     * Delete an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with address details
+     */
+    deleteAddress(pathParams: DeleteAddressPathParams): Promise<ApiResult<DeleteAddressResponse>>;
+    /**
+     * Get customer loyalty details
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with loyalty details
+     */
+    getLoyaltyDetails(pathParams: GetLoyaltyDetailsPathParams): Promise<ApiResult<GetLoyaltyDetailsContent>>;
+    /**
+     * List all loyalty points activity for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with loyalty points activity
+     */
+    listLoyaltyPointsActivity(pathParams: ListLoyaltyActivitiesPathParams): Promise<ApiResult<ListLoyaltyActivitiesContent>>;
+    /**
+     * List all reviews left by a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with reviews
+     */
+    listCustomerReviews(pathParams: ListUserReviewsPathParams): Promise<ApiResult<ListUserReviewsContent>>;
+}

package/dist/lib/customer.js

@@ -0,0 +1,156 @@
+import { StorefrontAPIClient } from "./client";
+/**
+ * Client for interacting with customer endpoints
+ */
+export class CustomerClient extends StorefrontAPIClient {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Create a customer
+     *
+     * @param body - Customer creation body
+     * @returns Promise with customer details
+     */
+    async createCustomer(body) {
+        return this.executeRequest(() => this.client.POST("/customers", {
+            body: body,
+        }));
+    }
+    /**
+     * Get customer details
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with customer details
+     */
+    async getCustomer(pathParams) {
+        return this.executeRequest(() => this.client.GET("/customers/{id}", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+    /**
+     * Update a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Customer update body
+     * @returns Promise with customer details
+     */
+    async updateCustomer(pathParams, body) {
+        return this.executeRequest(() => this.client.PUT("/customers/{id}", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
+    }
+    /**
+     * Get all saved addresses for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with addresses
+     */
+    async listAddresses(pathParams) {
+        return this.executeRequest(() => this.client.GET("/customers/{user_id}/addresses", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+    /**
+     * Create a new address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Address creation body
+     * @returns Promise with address details
+     */
+    async createAddress(pathParams, body) {
+        return this.executeRequest(() => this.client.POST("/customers/{user_id}/addresses", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
+    }
+    /**
+     * Get an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with address details
+     */
+    async getAddress(pathParams) {
+        return this.executeRequest(() => this.client.GET("/customers/{user_id}/addresses/{address_id}", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+    /**
+     * Update an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Address update body
+     * @returns Promise with address details
+     */
+    async updateAddress(pathParams, body) {
+        return this.executeRequest(() => this.client.PUT("/customers/{user_id}/addresses/{address_id}", {
+            params: {
+                path: pathParams,
+            },
+            body: body,
+        }));
+    }
+    /**
+     * Delete an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with address details
+     */
+    async deleteAddress(pathParams) {
+        return this.executeRequest(() => this.client.DELETE("/customers/{user_id}/addresses/{address_id}", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+    /**
+     * Get customer loyalty details
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with loyalty details
+     */
+    async getLoyaltyDetails(pathParams) {
+        return this.executeRequest(() => this.client.GET("/customers/{user_id}/loyalty", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+    /**
+     * List all loyalty points activity for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with loyalty points activity
+     */
+    async listLoyaltyPointsActivity(pathParams) {
+        return this.executeRequest(() => this.client.GET("/customers/{user_id}/loyalty-points-activity", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+    /**
+     * List all reviews left by a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with reviews
+     */
+    async listCustomerReviews(pathParams) {
+        return this.executeRequest(() => this.client.GET("/customers/{user_id}/reviews", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+}

package/dist/lib/helper.d.ts

@@ -0,0 +1,28 @@
+import { ApiResult, ListCountriesContent, ListCountryPincodesContent, ListCountryPincodesPathParams, ListCountryStatesContent, ListCountryStatesPathParams } from "../types/storefront-api-types";
+import { StorefrontAPIClient, StorefrontAPIConfig } from "./client";
+/**
+ * Client for interacting with helper endpoints
+ */
+export declare class HelpersClient extends StorefrontAPIClient {
+    constructor(config: StorefrontAPIConfig);
+    /**
+     * Get a list of countries
+     *
+     * @returns Promise with countries
+     */
+    listCountries(): Promise<ApiResult<ListCountriesContent>>;
+    /**
+     * - Get a list of states for a country
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with states
+     */
+    listCountryStates(pathParams: ListCountryStatesPathParams): Promise<ApiResult<ListCountryStatesContent>>;
+    /**
+     * Get pincodes for a country
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with pincodes
+     */
+    listCountryPincodes(pathParams: ListCountryPincodesPathParams): Promise<ApiResult<ListCountryPincodesContent>>;
+}

package/dist/lib/helper.js

@@ -0,0 +1,43 @@
+import { StorefrontAPIClient } from "./client";
+/**
+ * Client for interacting with helper endpoints
+ */
+export class HelpersClient extends StorefrontAPIClient {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Get a list of countries
+     *
+     * @returns Promise with countries
+     */
+    async listCountries() {
+        return this.executeRequest(() => this.client.GET("/common/countries", {}));
+    }
+    /**
+     * - Get a list of states for a country
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with states
+     */
+    async listCountryStates(pathParams) {
+        return this.executeRequest(() => this.client.GET("/common/countries/{country_iso_code}/states", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+    /**
+     * Get pincodes for a country
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with pincodes
+     */
+    async listCountryPincodes(pathParams) {
+        return this.executeRequest(() => this.client.GET("/common/countries/{country_iso_code}/pincodes", {
+            params: {
+                path: pathParams,
+            },
+        }));
+    }
+}