@commercengine/storefront-sdk 0.9.0 → 0.9.1

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import "openapi-fetch";
 import { ApiResult, BaseAPIClient, BaseSDKOptions, DebugLoggerFn, ResponseUtils } from "@commercengine/sdk-core";
 
 //#region src/types/storefront.d.ts

package/dist/index.js

@@ -1,6 +1,418 @@
-import { BaseAPIClient, ResponseUtils, getPathnameFromUrl } from "@commercengine/sdk-core";
+import createClient from "openapi-fetch";
 import { decodeJwt } from "jose";
 
+//#region ../sdk-core/dist/index.js
+/**
+* Response utilities for debugging and working with Response objects
+*/
+var ResponseUtils = class {
+	/**
+	* 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}`;
+	}
+	/**
+	* Format response for logging purposes (enhanced version)
+	*/
+	static formatResponse(response) {
+		return {
+			status: response.status,
+			statusText: response.statusText,
+			url: response.url,
+			ok: response.ok
+		};
+	}
+};
+/**
+* Debug logging utilities
+*/
+var DebugLogger = class {
+	logger;
+	responseTextCache = /* @__PURE__ */ 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: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+	/**
+	* Log debug information about API response
+	*/
+	async logResponse(response, responseBody) {
+		if (responseBody && typeof responseBody === "string") this.responseTextCache.set(response.url, responseBody);
+		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: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		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();
+	}
+	info(message, data) {
+		this.logger("info", message, data);
+	}
+	warn(message, data) {
+		this.logger("warn", message, data);
+	}
+	error(message, data) {
+		this.logger("error", message, data);
+	}
+};
+/**
+* Extract request body for logging
+*/
+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)
+* Enhanced version that combines original functionality with duration tracking
+*/
+function createDebugMiddleware(logger) {
+	const debugLogger = new DebugLogger(logger);
+	return {
+		async onRequest({ request }) {
+			request.__debugStartTime = Date.now();
+			const requestBody = await extractRequestBody(request);
+			debugLogger.logRequest(request, requestBody);
+			return request;
+		},
+		async onResponse({ request, response }) {
+			const startTime = request.__debugStartTime;
+			const duration = startTime ? Date.now() - startTime : 0;
+			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) {}
+			await debugLogger.logResponse(response, responseBody);
+			if (duration > 0) debugLogger.info(`Request completed in ${duration}ms`, {
+				url: request.url,
+				method: request.method
+			});
+			return response;
+		},
+		async onError({ error, request }) {
+			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 : void 0
+				},
+				request: {
+					method: request.method,
+					url: request.url,
+					headers: Object.fromEntries(request.headers.entries())
+				},
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			throw error;
+		}
+	};
+}
+/**
+* Timeout middleware for Commerce Engine SDKs
+*/
+/**
+* Create timeout middleware for openapi-fetch
+* Adds configurable request timeout functionality
+* 
+* @param timeoutMs - Timeout duration in milliseconds
+* @returns Middleware object with onRequest handler
+*/
+function createTimeoutMiddleware(timeoutMs) {
+	return { onRequest: async ({ request }) => {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+		if (request.signal) request.signal.addEventListener("abort", () => controller.abort());
+		const newRequest = new Request(request, { signal: controller.signal });
+		controller.signal.addEventListener("abort", () => clearTimeout(timeoutId));
+		return newRequest;
+	} };
+}
+/**
+* Transform headers using a transformation mapping
+* Headers not in the transformation map are passed through unchanged
+*
+* @param headers - Headers object with original names
+* @param transformations - Mapping of original names to transformed names
+* @returns Headers object with transformed names
+*/
+function transformHeaders(headers, transformations) {
+	const transformed = {};
+	for (const [key, value] of Object.entries(headers)) if (value !== void 0) {
+		const headerName = transformations[key] || key;
+		transformed[headerName] = value;
+	}
+	return transformed;
+}
+/**
+* Merge headers with transformation support
+* Transforms default headers, then merges with method headers
+*
+* @param defaultHeaders - Default headers from SDK configuration
+* @param methodHeaders - Headers passed to the specific method call
+* @param transformations - Mapping for header name transformations
+* @returns Merged headers object with transformations applied
+*/
+function mergeAndTransformHeaders(defaultHeaders, methodHeaders, transformations) {
+	const merged = {};
+	if (defaultHeaders && transformations) {
+		const transformedDefaults = transformHeaders(defaultHeaders, transformations);
+		Object.assign(merged, transformedDefaults);
+	} else if (defaultHeaders) Object.assign(merged, defaultHeaders);
+	if (methodHeaders) Object.assign(merged, methodHeaders);
+	Object.keys(merged).forEach((key) => {
+		if (merged[key] === void 0) delete merged[key];
+	});
+	return merged;
+}
+/**
+* Execute a request and handle the response consistently
+* This provides unified error handling and response processing across all SDKs
+*
+* @param apiCall - Function that executes the API request
+* @returns Promise with the API response in standardized format
+*/
+async function executeRequest(apiCall) {
+	try {
+		const { data, error, response } = await apiCall();
+		if (error) return {
+			data: null,
+			error,
+			response
+		};
+		if (data && data.content !== void 0) return {
+			data: data.content,
+			error: null,
+			response
+		};
+		return {
+			data,
+			error: null,
+			response
+		};
+	} catch (err) {
+		const mockResponse = new Response(null, {
+			status: 0,
+			statusText: "Network Error"
+		});
+		const errorResult = {
+			data: null,
+			error: {
+				success: false,
+				code: "NETWORK_ERROR",
+				message: "Network error occurred",
+				error: err
+			},
+			response: mockResponse
+		};
+		return errorResult;
+	}
+}
+/**
+* Generic base API client that all Commerce Engine SDKs can extend
+* Handles common functionality like middleware setup, request execution, and header management
+* Does NOT include token management - that's SDK-specific
+* 
+* @template TPaths - OpenAPI paths type
+* @template THeaders - Supported default headers type
+*/
+var BaseAPIClient = class {
+	client;
+	config;
+	baseUrl;
+	headerTransformations;
+	/**
+	* Create a new BaseAPIClient
+	*
+	* @param config - Configuration for the API client
+	* @param baseUrl - The base URL for the API (must be provided by subclass)
+	* @param headerTransformations - Header name transformations for this SDK
+	*/
+	constructor(config, baseUrl, headerTransformations = {}) {
+		this.config = { ...config };
+		this.headerTransformations = headerTransformations;
+		this.baseUrl = baseUrl;
+		this.client = createClient({ baseUrl: this.baseUrl });
+		this.setupMiddleware();
+	}
+	/**
+	* Set up all middleware for the client
+	*/
+	setupMiddleware() {
+		if (this.config.timeout) {
+			const timeoutMiddleware = createTimeoutMiddleware(this.config.timeout);
+			this.client.use(timeoutMiddleware);
+		}
+		if (this.config.debug) {
+			const debugMiddleware = createDebugMiddleware(this.config.logger);
+			this.client.use(debugMiddleware);
+		}
+	}
+	/**
+	* Get the base URL of the API
+	*
+	* @returns The base URL of the API
+	*/
+	getBaseUrl() {
+		return this.baseUrl;
+	}
+	/**
+	* Execute a request and handle the response consistently
+	* This provides unified error handling and response processing
+	*
+	* @param apiCall - Function that executes the API request
+	* @returns Promise with the API response in standardized format
+	*/
+	async executeRequest(apiCall) {
+		return executeRequest(apiCall);
+	}
+	/**
+	* Merge default headers with method-level headers
+	* Method-level headers take precedence over default headers
+	* Automatically applies SDK-specific header transformations
+	*
+	* @param methodHeaders - Headers passed to the specific method call
+	* @returns Merged headers object with proper HTTP header names
+	*/
+	mergeHeaders(methodHeaders) {
+		return mergeAndTransformHeaders(this.config.defaultHeaders, methodHeaders, this.headerTransformations);
+	}
+	/**
+	* Set default headers for the client
+	*
+	* @param headers - Default headers to set
+	*/
+	setDefaultHeaders(headers) {
+		this.config.defaultHeaders = headers;
+	}
+	/**
+	* Get current default headers
+	*
+	* @returns Current default headers
+	*/
+	getDefaultHeaders() {
+		return this.config.defaultHeaders;
+	}
+};
+/**
+* Generic URL utility functions for any SDK
+*/
+/**
+* Extract pathname from URL
+* Useful for middleware that needs to inspect request paths
+*/
+function getPathnameFromUrl(url) {
+	try {
+		const urlObj = new URL(url);
+		return urlObj.pathname;
+	} catch {
+		return url.split("?")[0] || url;
+	}
+}
+
+//#endregion
 //#region src/lib/jwt-utils.ts
 /**
 * Decode and extract user information from a JWT token