@djust-b2b/djust-front-sdk 3.0.0-beta.9 → 3.0.0

package/lib/client/transport.js

@@ -0,0 +1,735 @@
+"use strict";
+/**
+ * DJUST SDK Transport Layer
+ * Production-grade HTTP transport with timeout, retry, caching, and performance optimizations.
+ *
+ * Features:
+ * - Request deduplication (prevents duplicate concurrent requests)
+ * - Response caching with TTL and ETag support
+ * - Performance monitoring and metrics
+ * - Retry with exponential backoff
+ * - Request timeout
+ * - Connection keep-alive
+ * - Compression support
+ *
+ * @since 2.17.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+exports.createTransport = createTransport;
+const tslib_1 = require("tslib");
+const qs = tslib_1.__importStar(require("query-string"));
+const base_1 = require("../errors/base");
+const network_error_1 = require("../errors/classes/network.error");
+const timeout_error_1 = require("../errors/classes/timeout.error");
+const rate_limit_error_1 = require("../errors/classes/rate-limit.error");
+const factory_1 = require("../errors/factory");
+const compat_1 = require("../errors/compat");
+const guards_1 = require("../errors/guards");
+// ============================================================================
+// DEFAULT VALUES
+// ============================================================================
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_RETRY_CONFIG = {
+    enabled: false,
+    maxAttempts: 3,
+    initialDelayMs: 1000,
+    maxDelayMs: 30000,
+    jitter: 0.1,
+    retryableStatuses: [408, 429, 500, 502, 503, 504],
+};
+const DEFAULT_PERFORMANCE_CONFIG = {
+    deduplication: true,
+    deduplicationWindowMs: 100,
+    cache: false,
+    cacheMaxSize: 100,
+    cacheTTL: 60000,
+    staleWhileRevalidate: true,
+    monitoring: false,
+    compression: true,
+    keepAlive: true,
+};
+// ============================================================================
+// TRANSPORT CLASS
+// ============================================================================
+/**
+ * Production-grade HTTP transport for DJUST SDK.
+ * Includes built-in performance optimizations and auth lifecycle hooks.
+ */
+class Transport {
+    constructor(config) {
+        // Performance internals
+        this.cache = new Map();
+        this.pendingRequests = new Map();
+        this.metrics = {
+            requestCount: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            dedupedRequests: 0,
+            totalDurationMs: 0,
+            errors: 0,
+        };
+        this.config = config;
+        this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...(config.retry || {}) };
+        this.perfConfig = {
+            ...DEFAULT_PERFORMANCE_CONFIG,
+            ...(config.performance || {}),
+        };
+        this.hooks = config.hooks || {};
+        this.authHooks = config.authHooks || {};
+    }
+    // ==========================================================================
+    // AUTH HOOKS API
+    // ==========================================================================
+    /**
+     * Triggers the onLogin hook after successful login.
+     * Called by AuthService.login()
+     */
+    async triggerLoginHook(context) {
+        if (this.authHooks.onLogin) {
+            try {
+                await this.authHooks.onLogin(context);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[DJUST SDK] onLogin hook error:", error);
+                }
+            }
+        }
+    }
+    /**
+     * Triggers the onTokenRefresh hook after successful token refresh.
+     * Called by AuthService.refreshToken()
+     */
+    async triggerTokenRefreshHook(context) {
+        if (this.authHooks.onTokenRefresh) {
+            try {
+                await this.authHooks.onTokenRefresh(context);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[DJUST SDK] onTokenRefresh hook error:", error);
+                }
+            }
+        }
+    }
+    /**
+     * Triggers the onLogout hook after logout attempt.
+     * Called by AuthService.logout()
+     */
+    async triggerLogoutHook(context) {
+        if (this.authHooks.onLogout) {
+            try {
+                await this.authHooks.onLogout(context);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[DJUST SDK] onLogout hook error:", error);
+                }
+            }
+        }
+    }
+    /**
+     * Triggers the onAuthFailure hook when authentication fails.
+     * Called on 401 errors or refresh token failures.
+     */
+    async triggerAuthFailureHook(context) {
+        if (this.authHooks.onAuthFailure) {
+            try {
+                await this.authHooks.onAuthFailure(context);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[DJUST SDK] onAuthFailure hook error:", error);
+                }
+            }
+        }
+    }
+    /**
+     * Calls the onBeforeAuthenticatedRequest hook to potentially refresh tokens.
+     * Returns a new token if provided by the hook.
+     */
+    async callBeforeAuthRequestHook(context) {
+        if (this.authHooks.onBeforeAuthenticatedRequest) {
+            try {
+                return await this.authHooks.onBeforeAuthenticatedRequest(context);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[DJUST SDK] onBeforeAuthenticatedRequest hook error:", error);
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Checks if auth hooks are configured.
+     */
+    hasAuthHooks() {
+        return Object.keys(this.authHooks).length > 0;
+    }
+    // ==========================================================================
+    // PUBLIC API
+    // ==========================================================================
+    /**
+     * Executes an HTTP request with full error handling, caching, and retry support.
+     */
+    async request(request, context = {}) {
+        const requestId = context.requestId || this.generateRequestId();
+        const startTime = Date.now();
+        const url = this.buildUrl(request.path, request.params);
+        const cacheKey = request.cacheKey || this.buildCacheKey(request.method, url, context);
+        this.metrics.requestCount++;
+        // 1. Check cache first (GET requests only)
+        if (this.shouldUseCache(request, context)) {
+            const cached = this.getFromCache(cacheKey);
+            if (cached) {
+                const age = Date.now() - cached.timestamp;
+                const isStale = age > (context.cacheTTL || this.perfConfig.cacheTTL);
+                this.metrics.cacheHits++;
+                await this.hooks.onCacheHit?.({
+                    requestId,
+                    url,
+                    cacheKey,
+                    stale: isStale,
+                    age,
+                });
+                if (!isStale || this.perfConfig.staleWhileRevalidate) {
+                    // Return cached data
+                    if (isStale && this.perfConfig.staleWhileRevalidate) {
+                        // Revalidate in background
+                        this.revalidateInBackground(request, context, cacheKey);
+                    }
+                    return {
+                        data: cached.data,
+                        headers: new Headers(),
+                        status: 200,
+                        durationMs: Date.now() - startTime,
+                        requestId,
+                        cached: true,
+                    };
+                }
+            }
+            else {
+                this.metrics.cacheMisses++;
+            }
+        }
+        // 2. Check for pending dedup request (GET requests only)
+        if (this.shouldDedupe(request, context)) {
+            const pending = this.pendingRequests.get(cacheKey);
+            if (pending &&
+                Date.now() - pending.timestamp < this.perfConfig.deduplicationWindowMs) {
+                this.metrics.dedupedRequests++;
+                if (this.config.debug) {
+                    console.log(`[DJUST SDK] Deduped request: ${request.method} ${url}`);
+                }
+                const response = await pending.promise;
+                return { ...response, deduped: true };
+            }
+        }
+        // 3. Execute the actual request
+        const executePromise = this.executeWithRetry(request, context, requestId, startTime);
+        // Store pending request for deduplication
+        if (this.shouldDedupe(request, context)) {
+            // Create a "safe" promise that won't cause unhandled rejection warnings
+            // when stored in the map but not immediately awaited
+            const safePromise = executePromise.catch((error) => {
+                // Re-throw so callers still get the error, but this catch prevents
+                // Node.js unhandled rejection warnings when the promise is stored
+                throw error;
+            });
+            this.pendingRequests.set(cacheKey, {
+                promise: safePromise,
+                timestamp: Date.now(),
+            });
+            // Cleanup after completion
+            safePromise
+                .finally(() => {
+                setTimeout(() => {
+                    const current = this.pendingRequests.get(cacheKey);
+                    if (current?.promise === safePromise) {
+                        this.pendingRequests.delete(cacheKey);
+                    }
+                }, 10);
+            })
+                .catch(() => {
+                // Silent catch for cleanup - errors are handled by callers
+            });
+        }
+        const response = await executePromise;
+        // 4. Store in cache if applicable
+        if (this.shouldUseCache(request, context) && response.status === 200) {
+            const etag = response.headers.get("etag") || undefined;
+            const cacheControl = response.headers.get("cache-control");
+            const maxAge = this.parseCacheMaxAge(cacheControl);
+            this.setCache(cacheKey, response.data, etag, maxAge);
+        }
+        this.metrics.totalDurationMs += response.durationMs;
+        return response;
+    }
+    /**
+     * Gets performance metrics
+     */
+    getMetrics() {
+        const total = this.metrics.cacheHits + this.metrics.cacheMisses;
+        return {
+            ...this.metrics,
+            cacheHitRate: total > 0 ? this.metrics.cacheHits / total : 0,
+            avgDurationMs: this.metrics.requestCount > 0
+                ? Math.round(this.metrics.totalDurationMs / this.metrics.requestCount)
+                : 0,
+            cacheSize: this.cache.size,
+            pendingRequests: this.pendingRequests.size,
+        };
+    }
+    /**
+     * Clears the response cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Invalidates cache entries matching a pattern
+     */
+    invalidateCache(pattern) {
+        let count = 0;
+        const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+        const keys = Array.from(this.cache.keys());
+        for (const key of keys) {
+            if (regex.test(key)) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Resets performance metrics
+     */
+    resetMetrics() {
+        this.metrics.requestCount = 0;
+        this.metrics.cacheHits = 0;
+        this.metrics.cacheMisses = 0;
+        this.metrics.dedupedRequests = 0;
+        this.metrics.totalDurationMs = 0;
+        this.metrics.errors = 0;
+    }
+    // ==========================================================================
+    // PRIVATE - EXECUTION
+    // ==========================================================================
+    async executeWithRetry(request, context, requestId, startTime) {
+        const timeout = request.timeout ?? this.config.timeout ?? DEFAULT_TIMEOUT_MS;
+        const serializedBody = this.serializeBody(request.body);
+        let lastError;
+        let attempt = 0;
+        const maxAttempts = this.retryConfig.enabled
+            ? this.retryConfig.maxAttempts
+            : 1;
+        while (attempt < maxAttempts) {
+            attempt++;
+            try {
+                return await this.executeRequest({ ...request, body: serializedBody }, context, requestId, timeout, attempt, startTime);
+            }
+            catch (error) {
+                lastError = error;
+                this.metrics.errors++;
+                const durationMs = Date.now() - startTime;
+                const shouldRetry = this.shouldRetry(lastError, attempt, maxAttempts);
+                await this.hooks.onError?.({
+                    requestId,
+                    method: request.method,
+                    url: this.buildUrl(request.path, request.params),
+                    headers: this.buildHeadersObject(context, requestId),
+                    body: serializedBody,
+                    attempt,
+                    startTime,
+                    error: lastError,
+                    durationMs,
+                    willRetry: shouldRetry,
+                });
+                if (shouldRetry) {
+                    const delayMs = this.calculateRetryDelay(lastError, attempt);
+                    await this.hooks.onRetry?.({
+                        requestId,
+                        attempt,
+                        maxAttempts,
+                        delayMs,
+                        error: lastError,
+                        reason: this.getRetryReason(lastError),
+                    });
+                    if (this.config.debug) {
+                        console.log(`[DJUST SDK] Retry ${attempt}/${maxAttempts} after ${delayMs}ms`);
+                    }
+                    await this.sleep(delayMs);
+                    continue;
+                }
+                break;
+            }
+        }
+        if (lastError instanceof base_1.SDKError && !this.config.strictErrors) {
+            throw (0, compat_1.toLegacyError)(lastError);
+        }
+        throw lastError;
+    }
+    async executeRequest(request, context, requestId, timeout, attempt, startTime) {
+        const url = this.buildUrl(request.path, request.params);
+        const headers = this.buildHeaders(context, requestId);
+        const headersObject = this.buildHeadersObject(context, requestId);
+        await this.hooks.onRequestStart?.({
+            requestId,
+            method: request.method,
+            url,
+            headers: headersObject,
+            body: request.body,
+            attempt,
+            startTime,
+        });
+        if (this.config.debug) {
+            console.log(`[DJUST SDK] ${request.method} ${url} (attempt ${attempt})`);
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        if (request.signal) {
+            request.signal.addEventListener("abort", () => controller.abort());
+        }
+        try {
+            const fetchOptions = {
+                method: request.method,
+                headers,
+                body: request.body,
+                signal: controller.signal,
+            };
+            // Add keep-alive hint (browser support varies)
+            if (this.perfConfig.keepAlive) {
+                fetchOptions.keepalive = true;
+            }
+            const response = await fetch(url, fetchOptions);
+            clearTimeout(timeoutId);
+            const durationMs = Date.now() - startTime;
+            if (!response.ok) {
+                const errorBody = await response.text();
+                // Parse request body if it's a JSON string
+                let parsedRequestBody = undefined;
+                if (request.body) {
+                    try {
+                        if (typeof request.body === "string") {
+                            parsedRequestBody = JSON.parse(request.body);
+                        }
+                        else {
+                            parsedRequestBody = request.body;
+                        }
+                    }
+                    catch {
+                        // If parsing fails, keep as string
+                        parsedRequestBody = request.body;
+                    }
+                }
+                throw (0, factory_1.createErrorFromResponse)({
+                    statusCode: response.status,
+                    body: errorBody,
+                    url,
+                    method: request.method,
+                    durationMs,
+                    requestId,
+                    queryParams: request.params,
+                    requestBody: parsedRequestBody,
+                    requestHeaders: headersObject,
+                    sdkMethod: context.sdkMethod,
+                });
+            }
+            // Parse response
+            const contentType = response.headers.get("content-type");
+            const isJson = contentType?.includes("application/json");
+            const responseText = await response.text();
+            let data;
+            if (isJson && responseText) {
+                data = JSON.parse(responseText);
+            }
+            else {
+                data = responseText;
+            }
+            await this.hooks.onRequestEnd?.({
+                requestId,
+                method: request.method,
+                url,
+                headers: headersObject,
+                body: request.body,
+                attempt,
+                startTime,
+                status: response.status,
+                durationMs,
+                responseHeaders: response.headers,
+            });
+            return {
+                data,
+                headers: response.headers,
+                status: response.status,
+                durationMs,
+                requestId,
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof base_1.SDKError) {
+                throw error;
+            }
+            const err = error;
+            if (err.name === "AbortError") {
+                if (request.signal?.aborted) {
+                    throw network_error_1.NetworkError.aborted({
+                        requestId,
+                        endpoint: request.path,
+                        method: request.method,
+                    });
+                }
+                throw new timeout_error_1.TimeoutError(timeout, {
+                    requestId,
+                    endpoint: request.path,
+                    method: request.method,
+                });
+            }
+            throw (0, factory_1.createErrorFromException)(err, {
+                requestId,
+                endpoint: request.path,
+                method: request.method,
+                durationMs: Date.now() - startTime,
+            });
+        }
+    }
+    // ==========================================================================
+    // PRIVATE - CACHE
+    // ==========================================================================
+    shouldUseCache(request, context) {
+        return (this.perfConfig.cache && request.method === "GET" && !context.skipCache);
+    }
+    getFromCache(key) {
+        return this.cache.get(key);
+    }
+    setCache(key, data, etag, maxAge) {
+        // Evict oldest if at capacity
+        if (this.cache.size >= this.perfConfig.cacheMaxSize &&
+            !this.cache.has(key)) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now(),
+            etag,
+            maxAge,
+        });
+    }
+    buildCacheKey(method, url, context) {
+        // Include relevant context in cache key
+        const parts = [method, url];
+        if (context.accessToken)
+            parts.push(`token:${context.accessToken.slice(-8)}`);
+        if (context.customerAccountId)
+            parts.push(`account:${context.customerAccountId}`);
+        if (context.locale)
+            parts.push(`locale:${context.locale}`);
+        return parts.join("|");
+    }
+    parseCacheMaxAge(cacheControl) {
+        if (!cacheControl)
+            return undefined;
+        const match = cacheControl.match(/max-age=(\d+)/);
+        return match ? parseInt(match[1], 10) * 1000 : undefined;
+    }
+    revalidateInBackground(request, context, cacheKey) {
+        // Fire and forget revalidation
+        this.executeWithRetry(request, { ...context, skipCache: true }, this.generateRequestId(), Date.now())
+            .then((response) => {
+            if (response.status === 200) {
+                this.setCache(cacheKey, response.data);
+            }
+        })
+            .catch(() => {
+            // Ignore revalidation errors
+        });
+    }
+    // ==========================================================================
+    // PRIVATE - DEDUPLICATION
+    // ==========================================================================
+    shouldDedupe(request, context) {
+        return (this.perfConfig.deduplication &&
+            request.method === "GET" &&
+            !context.skipDedup);
+    }
+    // ==========================================================================
+    // PRIVATE - RETRY
+    // ==========================================================================
+    shouldRetry(error, attempt, maxAttempts) {
+        if (!this.retryConfig.enabled)
+            return false;
+        if (attempt >= maxAttempts)
+            return false;
+        if (error instanceof base_1.SDKError) {
+            if (error.retriable)
+                return true;
+            if (this.retryConfig.retryableStatuses.includes(error.httpStatus))
+                return true;
+        }
+        if (error instanceof network_error_1.NetworkError)
+            return true;
+        return (0, guards_1.isRetryable)(error);
+    }
+    calculateRetryDelay(error, attempt) {
+        if (error instanceof rate_limit_error_1.RateLimitError && error.retryAfterMs) {
+            return Math.min(error.retryAfterMs, this.retryConfig.maxDelayMs);
+        }
+        const exponentialDelay = this.retryConfig.initialDelayMs * Math.pow(2, attempt - 1);
+        const jitterMultiplier = 1 + (Math.random() * 2 - 1) * this.retryConfig.jitter;
+        const delayWithJitter = exponentialDelay * jitterMultiplier;
+        return Math.min(Math.round(delayWithJitter), this.retryConfig.maxDelayMs);
+    }
+    getRetryReason(error) {
+        if (error instanceof rate_limit_error_1.RateLimitError)
+            return "rate_limit";
+        if (error instanceof timeout_error_1.TimeoutError)
+            return "timeout";
+        if (error instanceof network_error_1.NetworkError)
+            return "network";
+        if (error instanceof base_1.SDKError)
+            return `http_${error.httpStatus}`;
+        return "unknown";
+    }
+    // ==========================================================================
+    // PRIVATE - UTILITIES
+    // ==========================================================================
+    buildUrl(path, params) {
+        let url = `${this.config.baseUrl}${path}`;
+        if (params && Object.keys(params).length > 0) {
+            const filteredParams = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+            const useRepeatFormat = path.includes("search") || path.includes("/customer-accounts/orders");
+            const queryString = useRepeatFormat
+                ? this.stringifyParamsRepeat(filteredParams)
+                : qs.stringify(filteredParams, {
+                    arrayFormat: "bracket",
+                    skipNull: true,
+                });
+            if (queryString) {
+                url += `?${queryString}`;
+            }
+        }
+        return url;
+    }
+    /**
+     * Serializes params so that arrays become repeated keys: &brand=1664&brand=1664+BLANC
+     * (API search and customer-accounts/orders expect this format, not comma or bracket).
+     */
+    stringifyParamsRepeat(params) {
+        const pairs = [];
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (item === undefined || item === null)
+                        continue;
+                    pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+                }
+            }
+            else {
+                pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        return pairs.join("&");
+    }
+    buildHeaders(context, requestId) {
+        const headers = new Headers({
+            "dj-client": this.config.clientId,
+            "dj-api-key": this.config.apiKey,
+            "Content-Type": "application/json",
+            "x-request-id": requestId,
+        });
+        // Compression support
+        if (this.perfConfig.compression) {
+            headers.append("Accept-Encoding", "gzip, deflate, br");
+        }
+        // Keep-alive hint
+        if (this.perfConfig.keepAlive) {
+            headers.append("Connection", "keep-alive");
+        }
+        if (context.accessToken) {
+            headers.append("Authorization", `Bearer ${context.accessToken}`);
+        }
+        if (context.locale) {
+            headers.append("locale", context.locale);
+        }
+        if (context.customerAccountId) {
+            headers.append("customer-account-id", context.customerAccountId);
+        }
+        if (context.storeId) {
+            headers.append("dj-store", context.storeId);
+        }
+        if (context.storeViewId) {
+            headers.append("dj-store-view", context.storeViewId);
+        }
+        if (context.headers) {
+            Object.entries(context.headers).forEach(([key, value]) => {
+                headers.append(key, value);
+            });
+        }
+        return headers;
+    }
+    buildHeadersObject(context, requestId) {
+        const headers = {
+            "dj-client": this.config.clientId,
+            "Content-Type": "application/json",
+        };
+        if (this.config.apiKey) {
+            headers["dj-api-key"] = "[REDACTED]";
+        }
+        if (requestId) {
+            headers["x-request-id"] = requestId;
+        }
+        if (context.accessToken) {
+            headers["Authorization"] = "Bearer [REDACTED]";
+        }
+        if (context.locale)
+            headers["locale"] = context.locale;
+        if (context.customerAccountId)
+            headers["customer-account-id"] = context.customerAccountId;
+        // Always expose store headers in debug metadata (even when omitted from the request)
+        headers["dj-store"] = context.storeId || "(not sent)";
+        headers["dj-store-view"] = context.storeViewId || "(not sent)";
+        if (context.headers) {
+            for (const [key, value] of Object.entries(context.headers)) {
+                headers[key] = value;
+            }
+        }
+        return headers;
+    }
+    serializeBody(body) {
+        if (body === undefined || body === null)
+            return undefined;
+        if (typeof body === "string")
+            return body;
+        return JSON.stringify(body);
+    }
+    generateRequestId() {
+        if (typeof crypto !== "undefined" && crypto.randomUUID) {
+            return crypto.randomUUID();
+        }
+        return `dj-${Date.now().toString(36)}-${Math.random()
+            .toString(36)
+            .substr(2, 9)}`;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.Transport = Transport;
+// ============================================================================
+// FACTORY FUNCTION
+// ============================================================================
+/**
+ * Creates a new Transport instance with performance optimizations.
+ */
+function createTransport(config) {
+    return new Transport(config);
+}
+//# sourceMappingURL=transport.js.map