@commercengine/storefront-sdk 0.3.8 → 0.3.10

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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,211 @@
+/**
+ * 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;
+        },
+    };
+}

package/dist/types/storefront-api-types.d.ts

@@ -2,9 +2,11 @@ import type { paths } from './storefront';
 export type ApiResult<T> = {
     data: T;
     error: null;
+    response: Response;
 } | {
     data: null;
     error: ApiErrorResponse;
+    response: Response;
 };
 export type ApiErrorResponse = {
     success?: boolean;
@@ -15,21 +17,23 @@ export type ApiErrorResponse = {
 export type ListProductsResponse = paths['/catalog/products']['get']['responses'][200]['content']['application/json'];
 export type ListProductsContent = ListProductsResponse['content'];
 export type ListProductsQuery = paths['/catalog/products']['get']['parameters']['query'];
+export type ListProductsHeaderParams = paths['/catalog/products']['get']['parameters']['header'];
 export type ListSkusResponse = paths['/catalog/skus']['get']['responses'][200]['content']['application/json'];
 export type ListSkusContent = ListSkusResponse['content'];
 export type ListSkusQuery = paths['/catalog/skus']['get']['parameters']['query'];
-export type GetProductDetailResponse = paths['/catalog/products/{product_id}']['get']['responses'][200]['content']['application/json'];
+export type ListSkusHeaderParams = paths['/catalog/skus']['get']['parameters']['header'];
+export type GetProductDetailResponse = paths['/catalog/products/{product_id_or_slug}']['get']['responses'][200]['content']['application/json'];
 export type GetProductDetailContent = GetProductDetailResponse['content'];
-export type GetProductDetailQuery = paths['/catalog/products/{product_id}']['get']['parameters']['query'];
-export type GetProductDetailPathParams = paths['/catalog/products/{product_id}']['get']['parameters']['path'];
+export type GetProductDetailPathParams = paths['/catalog/products/{product_id_or_slug}']['get']['parameters']['path'];
+export type GetProductDetailHeaderParams = paths['/catalog/products/{product_id_or_slug}']['get']['parameters']['header'];
 export type ListProductVariantsResponse = paths['/catalog/products/{product_id}/variants']['get']['responses'][200]['content']['application/json'];
 export type ListProductVariantsContent = ListProductVariantsResponse['content'];
-export type ListProductVariantsQuery = paths['/catalog/products/{product_id}/variants']['get']['parameters']['query'];
 export type ListProductVariantsPathParams = paths['/catalog/products/{product_id}/variants']['get']['parameters']['path'];
+export type ListProductVariantsHeaderParams = paths['/catalog/products/{product_id}/variants']['get']['parameters']['header'];
 export type GetVariantDetailResponse = paths['/catalog/products/{product_id}/variants/{variant_id}']['get']['responses'][200]['content']['application/json'];
 export type GetVariantDetailContent = GetVariantDetailResponse['content'];
-export type GetVariantDetailQuery = paths['/catalog/products/{product_id}/variants/{variant_id}']['get']['parameters']['query'];
 export type GetVariantDetailPathParams = paths['/catalog/products/{product_id}/variants/{variant_id}']['get']['parameters']['path'];
+export type GetVariantDetailHeaderParams = paths['/catalog/products/{product_id}/variants/{variant_id}']['get']['parameters']['header'];
 export type ListCategoriesResponse = paths['/catalog/categories']['get']['responses'][200]['content']['application/json'];
 export type ListCategoriesContent = ListCategoriesResponse['content'];
 export type ListCategoriesQuery = paths['/catalog/categories']['get']['parameters']['query'];
@@ -43,12 +47,15 @@ export type CreateProductReviewFormData = NonNullable<paths['/catalog/products/{
 export type ListSimilarProductsResponse = paths['/catalog/products/similar']['get']['responses'][200]['content']['application/json'];
 export type ListSimilarProductsContent = ListSimilarProductsResponse['content'];
 export type ListSimilarProductsQuery = paths['/catalog/products/similar']['get']['parameters']['query'];
+export type ListSimilarProductsHeaderParams = paths['/catalog/products/similar']['get']['parameters']['header'];
 export type ListUpsellProductsResponse = paths['/catalog/products/up-sell']['get']['responses'][200]['content']['application/json'];
 export type ListUpsellProductsContent = ListUpsellProductsResponse['content'];
 export type ListUpsellProductsQuery = paths['/catalog/products/up-sell']['get']['parameters']['query'];
+export type ListUpsellProductsHeaderParams = paths['/catalog/products/up-sell']['get']['parameters']['header'];
 export type ListCrosssellProductsResponse = paths['/catalog/products/cross-sell']['get']['responses'][200]['content']['application/json'];
 export type ListCrosssellProductsContent = ListCrosssellProductsResponse['content'];
 export type ListCrosssellProductsQuery = paths['/catalog/products/cross-sell']['get']['parameters']['query'];
+export type ListCrosssellProductsHeaderParams = paths['/catalog/products/cross-sell']['get']['parameters']['header'];
 export type SearchProductsResponse = paths['/catalog/products/search']['post']['responses'][200]['content']['application/json'];
 export type SearchProductsContent = SearchProductsResponse['content'];
 export type SearchProductsBody = NonNullable<paths['/catalog/products/search']['post']['requestBody']>['content']['application/json'];
@@ -151,6 +158,8 @@ export type DeleteAddressResponse = paths['/customers/{user_id}/addresses/{addre
 export type DeleteAddressPathParams = paths['/customers/{user_id}/addresses/{address_id}']['delete']['parameters']['path'];
 export type ListKycDocumentResponse = paths['/store/kyc-document']['get']['responses'][200]['content']['application/json'];
 export type ListKycDocumentContent = ListKycDocumentResponse['content'];
+export type GetConfigResponse = paths['/store/config']['get']['responses'][200]['content']['application/json'];
+export type GetConfigContent = GetConfigResponse['content'];
 export type ListDocumentsResponse = paths['/customers/{id}/documents']['get']['responses'][200]['content']['application/json'];
 export type ListDocumentsContent = ListDocumentsResponse['content'];
 export type ListDocumentsPathParams = paths['/customers/{id}/documents']['get']['parameters']['path'];