@commercengine/storefront-sdk 0.3.11 → 0.4.0

package/dist/lib/header-utils.js

@@ -1,66 +0,0 @@
-/**
- * Mapping of SDK header parameter names to actual HTTP header names
- * Only include headers that need transformation - others pass through as-is
- */
-const HEADER_TRANSFORMATIONS = {
-    customer_group_id: "x-customer-group-id",
-    // Future transformations can be added here:
-    // some_param: "X-Some-Header",
-    // another_param: "X-Another-Header",
-};
-/**
- * Transform SDK header parameters to actual HTTP header names
- * Headers not in the transformation map are passed through unchanged
- *
- * @param headers - Headers object with SDK parameter names
- * @returns Headers object with actual HTTP header names
- */
-export function transformHeaders(headers) {
-    const transformed = {};
-    // Iterate through all headers in the input
-    for (const [key, value] of Object.entries(headers)) {
-        if (value !== undefined) {
-            // Use transformation if available, otherwise use the original key
-            const headerName = HEADER_TRANSFORMATIONS[key] || key;
-            transformed[headerName] = value;
-        }
-    }
-    return transformed;
-}
-/**
- * Merge default headers with method-level headers
- * Method-level headers take precedence over default headers
- * Automatically transforms SDK parameter names to HTTP header names
- *
- * @param defaultHeaders - Default headers from SDK configuration
- * @param methodHeaders - Headers passed to the specific method call
- * @returns Merged headers object with proper HTTP header names
- */
-export function mergeHeaders(defaultHeaders, methodHeaders) {
-    const merged = {};
-    // Transform and add default headers if they exist
-    if (defaultHeaders) {
-        const transformedDefaults = transformHeaders(defaultHeaders);
-        Object.assign(merged, transformedDefaults);
-    }
-    // Method headers override default headers
-    if (methodHeaders) {
-        Object.assign(merged, methodHeaders);
-    }
-    // Remove undefined values
-    Object.keys(merged).forEach((key) => {
-        if (merged[key] === undefined) {
-            delete merged[key];
-        }
-    });
-    return merged;
-}
-/**
- * Get the list of supported header transformations
- * Useful for debugging or documentation purposes
- *
- * @returns Copy of the header transformations mapping
- */
-export function getHeaderTransformations() {
-    return { ...HEADER_TRANSFORMATIONS };
-}

package/dist/lib/helper.d.ts

@@ -1,27 +0,0 @@
-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>>;
-}

package/dist/lib/helper.js

@@ -1,40 +0,0 @@
-import { StorefrontAPIClient } from "./client";
-/**
- * Client for interacting with helper endpoints
- */
-export class HelpersClient extends StorefrontAPIClient {
-    /**
-     * 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,
-            },
-        }));
-    }
-}

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

@@ -1,75 +0,0 @@
-/**
- * JWT payload structure for storefront tokens
- */
-export interface JwtPayload {
-    token_type: string;
-    exp: number;
-    iat: number;
-    jti: string;
-    ulid: string;
-    email: string | null;
-    phone: string | null;
-    username: string;
-    first_name: string | null;
-    last_name: string | null;
-    store_id: string;
-    is_logged_in: boolean;
-    customer_id: string | null;
-    customer_group_id: string | null;
-    anonymous_id: string;
-}
-/**
- * User information extracted from JWT token
- */
-export interface UserInfo {
-    id: string;
-    email: string | null;
-    phone: string | null;
-    username: string;
-    firstName: string | null;
-    lastName: string | null;
-    storeId: string;
-    isLoggedIn: boolean;
-    isAnonymous: boolean;
-    customerId: string | null;
-    customerGroupId: string | null;
-    anonymousId: string;
-    tokenExpiry: Date;
-    tokenIssuedAt: Date;
-}
-/**
- * Decode and extract user information from a JWT token
- *
- * @param token - The JWT token to decode
- * @returns User information or null if token is invalid
- */
-export declare function extractUserInfoFromToken(token: string): UserInfo | null;
-/**
- * Check if a JWT token is expired
- *
- * @param token - The JWT token to check
- * @param bufferSeconds - Buffer time in seconds (default: 30)
- * @returns True if token is expired or will expire within buffer time
- */
-export declare function isTokenExpired(token: string, bufferSeconds?: number): boolean;
-/**
- * Get the user ID from a JWT token
- *
- * @param token - The JWT token
- * @returns User ID (ulid) or null if token is invalid
- */
-export declare function getUserIdFromToken(token: string): string | null;
-/**
- * Check if user is logged in based on JWT token
- *
- * @param token - The JWT token
- * @returns True if user is logged in, false otherwise
- */
-export declare function isUserLoggedIn(token: string): boolean;
-/**
- * Check if user is anonymous based on JWT token
- *
- * @param token - The JWT token
- * @returns True if user is anonymous, false otherwise
- */
-export declare function isUserAnonymous(token: string): boolean;

package/dist/lib/jwt-utils.js

@@ -1,84 +0,0 @@
-import { decodeJwt } from "jose";
-/**
- * Decode and extract user information from a JWT token
- *
- * @param token - The JWT token to decode
- * @returns User information or null if token is invalid
- */
-export function extractUserInfoFromToken(token) {
-    try {
-        const payload = decodeJwt(token);
-        return {
-            id: payload.ulid,
-            email: payload.email,
-            phone: payload.phone,
-            username: payload.username,
-            firstName: payload.first_name,
-            lastName: payload.last_name,
-            storeId: payload.store_id,
-            isLoggedIn: payload.is_logged_in,
-            isAnonymous: !payload.is_logged_in,
-            customerId: payload.customer_id,
-            customerGroupId: payload.customer_group_id,
-            anonymousId: payload.anonymous_id,
-            tokenExpiry: new Date(payload.exp * 1000),
-            tokenIssuedAt: new Date(payload.iat * 1000),
-        };
-    }
-    catch (error) {
-        console.warn("Failed to decode JWT token:", error);
-        return null;
-    }
-}
-/**
- * Check if a JWT token is expired
- *
- * @param token - The JWT token to check
- * @param bufferSeconds - Buffer time in seconds (default: 30)
- * @returns True if token is expired or will expire within buffer time
- */
-export function isTokenExpired(token, bufferSeconds = 30) {
-    try {
-        const payload = decodeJwt(token);
-        if (!payload.exp)
-            return true;
-        const currentTime = Math.floor(Date.now() / 1000);
-        const expiryTime = payload.exp;
-        // Consider token expired if it expires within the buffer time
-        return currentTime >= (expiryTime - bufferSeconds);
-    }
-    catch (error) {
-        console.warn("Failed to decode JWT token:", error);
-        return true; // Treat invalid tokens as expired
-    }
-}
-/**
- * Get the user ID from a JWT token
- *
- * @param token - The JWT token
- * @returns User ID (ulid) or null if token is invalid
- */
-export function getUserIdFromToken(token) {
-    const userInfo = extractUserInfoFromToken(token);
-    return userInfo?.id || null;
-}
-/**
- * Check if user is logged in based on JWT token
- *
- * @param token - The JWT token
- * @returns True if user is logged in, false otherwise
- */
-export function isUserLoggedIn(token) {
-    const userInfo = extractUserInfoFromToken(token);
-    return userInfo?.isLoggedIn || false;
-}
-/**
- * Check if user is anonymous based on JWT token
- *
- * @param token - The JWT token
- * @returns True if user is anonymous, false otherwise
- */
-export function isUserAnonymous(token) {
-    const userInfo = extractUserInfoFromToken(token);
-    return userInfo?.isAnonymous || true;
-}

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

@@ -1,88 +0,0 @@
-import type { Middleware } from "openapi-fetch";
-/**
- * Debug logger function interface
- */
-export interface DebugLoggerFn {
-    (level: "info" | "warn" | "error", message: string, data?: any): void;
-}
-/**
- * Response utilities for debugging and working with Response objects
- */
-export declare class ResponseUtils {
-    /**
-     * Get response headers as a plain object
-     */
-    static getHeaders(response: Response): Record<string, string>;
-    /**
-     * Get specific header value
-     */
-    static getHeader(response: Response, name: string): string | null;
-    /**
-     * Check if response was successful
-     */
-    static isSuccess(response: Response): boolean;
-    /**
-     * Get response metadata
-     */
-    static getMetadata(response: Response): {
-        status: number;
-        statusText: string;
-        ok: boolean;
-        url: string;
-        redirected: boolean;
-        type: ResponseType;
-        headers: {
-            [k: string]: string;
-        };
-    };
-    /**
-     * Clone and read response as text (useful for debugging)
-     * Note: This can only be called once per response
-     */
-    static getText(response: Response): Promise<string>;
-    /**
-     * Clone and read response as JSON (useful for debugging)
-     * Note: This can only be called once per response
-     */
-    static getJSON(response: Response): Promise<any>;
-    /**
-     * Format response information for debugging
-     */
-    static format(response: Response): string;
-}
-/**
- * Debug logging utilities
- */
-export declare class DebugLogger {
-    private logger;
-    private responseTextCache;
-    constructor(logger?: DebugLoggerFn);
-    /**
-     * Log debug information about API request
-     */
-    logRequest(request: Request, requestBody?: any): void;
-    /**
-     * Log debug information about API response
-     */
-    logResponse(response: Response, responseBody?: any): Promise<void>;
-    /**
-     * Log error information
-     */
-    logError(message: string, error: any): void;
-    /**
-     * Get cached response text for a URL (if available)
-     */
-    getCachedResponseText(url: string): string | null;
-    /**
-     * Clear cached response texts
-     */
-    clearCache(): void;
-}
-/**
- * Extract request body for logging
- */
-export declare function extractRequestBody(request: Request): Promise<any>;
-/**
- * Create debug middleware for openapi-fetch (internal use)
- */
-export declare function createDebugMiddleware(logger?: DebugLoggerFn): Middleware;

package/dist/lib/logger-utils.js

@@ -1,211 +0,0 @@
-/**
- * Response utilities for debugging and working with Response objects
- */
-export class ResponseUtils {
-    /**
-     * Get response headers as a plain object
-     */
-    static getHeaders(response) {
-        return Object.fromEntries(response.headers.entries());
-    }
-    /**
-     * Get specific header value
-     */
-    static getHeader(response, name) {
-        return response.headers.get(name);
-    }
-    /**
-     * Check if response was successful
-     */
-    static isSuccess(response) {
-        return response.ok;
-    }
-    /**
-     * Get response metadata
-     */
-    static getMetadata(response) {
-        return {
-            status: response.status,
-            statusText: response.statusText,
-            ok: response.ok,
-            url: response.url,
-            redirected: response.redirected,
-            type: response.type,
-            headers: Object.fromEntries(response.headers.entries()),
-        };
-    }
-    /**
-     * Clone and read response as text (useful for debugging)
-     * Note: This can only be called once per response
-     */
-    static async getText(response) {
-        const cloned = response.clone();
-        return await cloned.text();
-    }
-    /**
-     * Clone and read response as JSON (useful for debugging)
-     * Note: This can only be called once per response
-     */
-    static async getJSON(response) {
-        const cloned = response.clone();
-        return await cloned.json();
-    }
-    /**
-     * Format response information for debugging
-     */
-    static format(response) {
-        const metadata = this.getMetadata(response);
-        return `${metadata.status} ${metadata.statusText} - ${metadata.url}`;
-    }
-}
-/**
- * Debug logging utilities
- */
-export class DebugLogger {
-    logger;
-    responseTextCache = new Map();
-    constructor(logger) {
-        this.logger =
-            logger ||
-                ((level, message, data) => {
-                    console.log(`[${level.toUpperCase()}]`, message);
-                    if (data)
-                        console.log(data);
-                });
-    }
-    /**
-     * Log debug information about API request
-     */
-    logRequest(request, requestBody) {
-        this.logger("info", "API Request Debug Info", {
-            method: request.method,
-            url: request.url,
-            headers: Object.fromEntries(request.headers.entries()),
-            body: requestBody,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    /**
-     * Log debug information about API response
-     */
-    async logResponse(response, responseBody) {
-        // Cache response text for later use by ResponseUtils
-        if (responseBody && typeof responseBody === "string") {
-            this.responseTextCache.set(response.url, responseBody);
-        }
-        // Log response metadata
-        this.logger("info", "API Response Debug Info", {
-            url: response.url,
-            status: response.status,
-            statusText: response.statusText,
-            ok: response.ok,
-            headers: Object.fromEntries(response.headers.entries()),
-            redirected: response.redirected,
-            type: response.type,
-            timestamp: new Date().toISOString(),
-        });
-        // Log response body if available
-        if (responseBody) {
-            this.logger("info", "API Response Data", {
-                data: responseBody,
-                contentType: response.headers.get("content-type"),
-                contentLength: response.headers.get("content-length"),
-            });
-        }
-    }
-    /**
-     * Log error information
-     */
-    logError(message, error) {
-        this.logger("error", message, error);
-    }
-    /**
-     * Get cached response text for a URL (if available)
-     */
-    getCachedResponseText(url) {
-        return this.responseTextCache.get(url) || null;
-    }
-    /**
-     * Clear cached response texts
-     */
-    clearCache() {
-        this.responseTextCache.clear();
-    }
-}
-/**
- * Extract request body for logging
- */
-export async function extractRequestBody(request) {
-    if (request.method === "GET" || request.method === "HEAD") {
-        return null;
-    }
-    try {
-        const clonedRequest = request.clone();
-        const contentType = request.headers.get("content-type")?.toLowerCase();
-        if (contentType?.startsWith("application/json")) {
-            return await clonedRequest.json();
-        }
-        else if (contentType?.startsWith("multipart/form-data")) {
-            return "[FormData - cannot display]";
-        }
-        else if (contentType?.startsWith("text/")) {
-            return await clonedRequest.text();
-        }
-        return "[Request body - unknown format]";
-    }
-    catch (error) {
-        return "[Request body unavailable]";
-    }
-}
-/**
- * Create debug middleware for openapi-fetch (internal use)
- */
-export function createDebugMiddleware(logger) {
-    const debugLogger = new DebugLogger(logger);
-    return {
-        async onRequest({ request }) {
-            // Log request information
-            const requestBody = await extractRequestBody(request);
-            debugLogger.logRequest(request, requestBody);
-            return request;
-        },
-        async onResponse({ response }) {
-            // Clone response to read body without consuming it
-            const cloned = response.clone();
-            let responseBody = null;
-            try {
-                const contentType = response.headers.get("content-type")?.toLowerCase();
-                if (contentType?.startsWith("application/json")) {
-                    responseBody = await cloned.json();
-                }
-                else if (contentType?.startsWith("text/")) {
-                    responseBody = await cloned.text();
-                }
-            }
-            catch (error) {
-                // Ignore body reading errors
-            }
-            // Log response information
-            await debugLogger.logResponse(response, responseBody);
-            return response;
-        },
-        async onError({ error, request }) {
-            // Log error information with request context
-            debugLogger.logError("API Request Failed", {
-                error: {
-                    name: error instanceof Error ? error.name : "Unknown",
-                    message: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                },
-                request: {
-                    method: request.method,
-                    url: request.url,
-                    headers: Object.fromEntries(request.headers.entries()),
-                },
-                timestamp: new Date().toISOString(),
-            });
-            // Re-throw the error to maintain normal error handling
-            throw error;
-        },
-    };
-}