@commercengine/storefront-sdk 0.3.0 → 0.3.2

package/dist/lib/client.js

@@ -1,14 +1,10 @@
-"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";
+import { getPathnameFromUrl, isAnonymousAuthEndpoint } from "./auth-utils";
 /**
  * Available API environments
  */
-var Environment;
+export var Environment;
 (function (Environment) {
     /**
      * Staging environment
@@ -18,87 +14,101 @@ 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);
+            // If initial tokens were provided, store them in tokenStorage
+            if (this.config.accessToken) {
+                this.config.tokenStorage.setAccessToken(this.config.accessToken).catch(error => {
+                    console.warn('Failed to set initial access token in storage:', error);
+                });
+                // Clear the manual token since we're using storage
+                this.config.accessToken = undefined;
+            }
+            if (this.config.refreshToken) {
+                this.config.tokenStorage.setRefreshToken(this.config.refreshToken).catch(error => {
+                    console.warn('Failed to set initial refresh token in storage:', error);
+                });
+                // Clear the manual refresh token since we're using storage
+                this.config.refreshToken = undefined;
+            }
+        }
+        else {
+            // For manual token management, add simple header injection middleware
+            this.client.use({
+                onRequest: async ({ request }) => {
+                    const pathname = getPathnameFromUrl(request.url);
+                    // Handle anonymous auth endpoint - use API key
+                    if (isAnonymousAuthEndpoint(pathname)) {
+                        if (this.config.apiKey) {
+                            request.headers.set("X-Api-Key", this.config.apiKey);
+                        }
+                        // Also send existing access token if available for continuity
+                        if (this.config.accessToken) {
+                            request.headers.set("Authorization", `Bearer ${this.config.accessToken}`);
+                        }
+                        return request;
+                    }
+                    // For all other endpoints, use access token
+                    if (this.config.accessToken) {
+                        request.headers.set("Authorization", `Bearer ${this.config.accessToken}`);
+                    }
+                    return request;
+                },
+            });
+        }
+        // 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 +143,58 @@ 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() {
-        return this.config.token ? `Bearer ${this.config.token}` : "";
+    async getAuthorizationHeader() {
+        if (this.config.tokenStorage) {
+            const token = await this.config.tokenStorage.getAccessToken();
+            return token ? `Bearer ${token}` : "";
+        }
+        return this.config.accessToken ? `Bearer ${this.config.accessToken}` : "";
     }
     /**
-     * Set the authentication token
+     * Set authentication tokens
+     *
+     * @param accessToken - The access token (required)
+     * @param refreshToken - The refresh token (optional)
      *
-     * @param token - The authentication token
+     * Behavior:
+     * - If tokenStorage is provided: Stores tokens for automatic management
+     * - If tokenStorage is not provided: Only stores access token for manual management
      */
-    setToken(token) {
-        this.config.token = token;
-        this.headers["Authorization"] = `Bearer ${token}`;
+    async setTokens(accessToken, refreshToken) {
+        if (this.config.tokenStorage) {
+            // Automatic token management
+            await this.config.tokenStorage.setAccessToken(accessToken);
+            if (refreshToken) {
+                await this.config.tokenStorage.setRefreshToken(refreshToken);
+            }
+        }
+        else {
+            // Manual token management - only access token
+            this.config.accessToken = accessToken;
+            if (refreshToken) {
+                console.warn("Refresh token provided but ignored in manual token management mode. Use tokenStorage for automatic management.");
+            }
+        }
     }
     /**
-     * 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() {
-        this.config.token = undefined;
-        delete this.headers["Authorization"];
+    async clearTokens() {
+        if (this.config.tokenStorage) {
+            await this.config.tokenStorage.clearTokens();
+        }
+        else {
+            this.config.accessToken = undefined;
+        }
     }
     /**
      * Set the X-Api-Key header
@@ -162,106 +203,40 @@ 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
-     *
-     * @param error - Error object from OpenAPI-Fetch
-     * @throws Rethrows the error with additional context
-     */
-    async handleError(error) {
-        // Extract status code and error data from OpenAPI-Fetch error response
-        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");
-        }
-        else if (statusCode === 404) {
-            throw new Error("Resource not found");
-        }
-        else if (errorData?.message) {
-            throw new Error(`API Error (${statusCode}): ${errorData.message}`);
-        }
-        else {
-            throw new Error(`API Error (${statusCode})`);
-        }
-    }
-    /**
-     * 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();
-                }
-            }
-            // 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();
+            const { data, error } = await apiCall();
+            // openapi-fetch returns error for 4xx/5xx, data for 2xx
+            if (error) {
+                return { data: null, error };
             }
-            // 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,87 @@
+import type { ApiResult, CreateCustomerBody, 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 { StorefrontAPIClient } from "./client";
+/**
+ * Client for interacting with customer endpoints
+ */
+export declare class CustomerClient extends StorefrontAPIClient {
+    /**
+     * 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,153 @@
+import { StorefrontAPIClient } from "./client";
+/**
+ * Client for interacting with customer endpoints
+ */
+export class CustomerClient extends StorefrontAPIClient {
+    /**
+     * 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,27 @@
+import type { ApiResult, ListCountriesContent, ListCountryPincodesContent, ListCountryPincodesPathParams, ListCountryStatesContent, ListCountryStatesPathParams } from "../types/storefront-api-types";
+import { StorefrontAPIClient } from "./client";
+/**
+ * Client for interacting with helper endpoints
+ */
+export declare class HelpersClient extends StorefrontAPIClient {
+    /**
+     * 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>>;
+}