@aifabrix/miso-client 2.1.2 → 2.2.0

package/dist/utils/data-client.js

@@ -0,0 +1,703 @@
+"use strict";
+/**
+ * DataClient - Browser-compatible HTTP client wrapper around MisoClient
+ * Provides enhanced HTTP capabilities with ISO 27001 compliance, caching, retry, and more
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataClient = void 0;
+exports.dataClient = dataClient;
+const index_1 = require("../index");
+const data_client_types_1 = require("../types/data-client.types");
+const data_masker_1 = require("./data-masker");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+/**
+ * Check if running in browser environment
+ */
+function isBrowser() {
+    return (typeof globalThis.window !== "undefined" &&
+        typeof globalThis.localStorage !== "undefined" &&
+        typeof globalThis.fetch !== "undefined");
+}
+/**
+ * Get value from localStorage (browser only)
+ */
+function getLocalStorage(key) {
+    if (!isBrowser())
+        return null;
+    try {
+        return globalThis.localStorage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract userId from JWT token
+ */
+function extractUserIdFromToken(token) {
+    try {
+        const decoded = jsonwebtoken_1.default.decode(token);
+        if (!decoded)
+            return null;
+        return (decoded.sub || decoded.userId || decoded.user_id || decoded.id);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calculate cache key from endpoint and options
+ */
+function generateCacheKey(endpoint, options) {
+    const method = options?.method || "GET";
+    const body = options?.body ? JSON.stringify(options.body) : "";
+    return `data-client:${method}:${endpoint}:${body}`;
+}
+/**
+ * Truncate large payloads before masking (performance optimization)
+ */
+function truncatePayload(data, maxSize) {
+    const json = JSON.stringify(data);
+    if (json.length <= maxSize) {
+        return { data, truncated: false };
+    }
+    return {
+        data: { _message: "Payload truncated for performance", _size: json.length },
+        truncated: true,
+    };
+}
+/**
+ * Calculate request/response sizes
+ */
+function calculateSize(data) {
+    try {
+        return JSON.stringify(data).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Check if error is retryable
+ */
+function isRetryableError(statusCode, _error) {
+    if (!statusCode)
+        return true; // Network errors are retryable
+    if (statusCode >= 500)
+        return true; // Server errors
+    if (statusCode === 408)
+        return true; // Timeout
+    if (statusCode === 429)
+        return true; // Rate limit
+    if (statusCode === 401 || statusCode === 403)
+        return false; // Auth errors
+    if (statusCode >= 400 && statusCode < 500)
+        return false; // Client errors
+    return false;
+}
+/**
+ * Calculate exponential backoff delay
+ */
+function calculateBackoffDelay(attempt, baseDelay, maxDelay) {
+    const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+    return delay + Math.random() * 1000; // Add jitter
+}
+class DataClient {
+    constructor(config) {
+        this.misoClient = null;
+        this.cache = new Map();
+        this.pendingRequests = new Map();
+        this.interceptors = {};
+        this.metrics = {
+            totalRequests: 0,
+            totalFailures: 0,
+            responseTimes: [],
+            cacheHits: 0,
+            cacheMisses: 0,
+        };
+        this.config = {
+            tokenKeys: ["token", "accessToken", "authToken"],
+            loginUrl: "/login",
+            timeout: 30000,
+            cache: {
+                enabled: true,
+                defaultTTL: 300,
+                maxSize: 100,
+            },
+            retry: {
+                enabled: true,
+                maxRetries: 3,
+                baseDelay: 1000,
+                maxDelay: 10000,
+            },
+            audit: {
+                enabled: true,
+                level: "standard",
+                batchSize: 10,
+                maxResponseSize: 10000,
+                maxMaskingSize: 50000,
+                skipEndpoints: [],
+            },
+            ...config,
+        };
+        // Security: Warn if clientSecret is provided in browser environment
+        // This is a security risk as clientSecret should never be exposed in client-side code
+        if (isBrowser() && this.config.misoConfig?.clientSecret) {
+            console.warn("⚠️ SECURITY WARNING: clientSecret detected in browser environment. " +
+                "Client secrets should NEVER be exposed in client-side code. " +
+                "Use the client token pattern instead (clientToken + onClientTokenRefresh). " +
+                "See documentation for browser-safe configuration.");
+        }
+        // Initialize MisoClient if config provided
+        if (this.config.misoConfig) {
+            this.misoClient = new index_1.MisoClient(this.config.misoConfig);
+        }
+        // Initialize DataMasker with config path if provided
+        if (this.config.misoConfig?.sensitiveFieldsConfig) {
+            data_masker_1.DataMasker.setConfigPath(this.config.misoConfig.sensitiveFieldsConfig);
+        }
+    }
+    /**
+     * Get authentication token from localStorage
+     */
+    getToken() {
+        if (!isBrowser())
+            return null;
+        const keys = this.config.tokenKeys || ["token", "accessToken", "authToken"];
+        for (const key of keys) {
+            const token = getLocalStorage(key);
+            if (token)
+                return token;
+        }
+        return null;
+    }
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated() {
+        return this.getToken() !== null;
+    }
+    /**
+     * Redirect to login page
+     */
+    redirectToLogin() {
+        if (!isBrowser())
+            return;
+        const loginUrl = this.config.loginUrl || "/login";
+        globalThis.window.location.href = loginUrl;
+    }
+    /**
+     * Set interceptors
+     */
+    setInterceptors(config) {
+        this.interceptors = { ...this.interceptors, ...config };
+    }
+    /**
+     * Set audit configuration
+     */
+    setAuditConfig(config) {
+        this.config.audit = { ...this.config.audit, ...config };
+    }
+    /**
+     * Set log level for MisoClient logger
+     * Note: This updates the MisoClient config logLevel if MisoClient is initialized
+     * @param level - Log level ('debug' | 'info' | 'warn' | 'error')
+     */
+    setLogLevel(level) {
+        if (this.misoClient && this.config.misoConfig) {
+            // Update the config's logLevel
+            // Note: TypeScript readonly doesn't prevent runtime updates
+            this.config.misoConfig.logLevel = level;
+            // Also try to update MisoClient's internal config if accessible
+            try {
+                const misoConfig = this.misoClient.config;
+                if (misoConfig) {
+                    misoConfig.logLevel = level;
+                }
+            }
+            catch {
+                // Silently ignore if config is not accessible
+            }
+        }
+    }
+    /**
+     * Clear all cached responses
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get request metrics
+     */
+    getMetrics() {
+        const responseTimes = this.metrics.responseTimes.sort((a, b) => a - b);
+        const len = responseTimes.length;
+        return {
+            totalRequests: this.metrics.totalRequests,
+            totalFailures: this.metrics.totalFailures,
+            averageResponseTime: len > 0
+                ? responseTimes.reduce((a, b) => a + b, 0) / len
+                : 0,
+            responseTimeDistribution: {
+                min: len > 0 ? responseTimes[0] : 0,
+                max: len > 0 ? responseTimes[len - 1] : 0,
+                p50: len > 0 ? responseTimes[Math.floor(len * 0.5)] : 0,
+                p95: len > 0 ? responseTimes[Math.floor(len * 0.95)] : 0,
+                p99: len > 0 ? responseTimes[Math.floor(len * 0.99)] : 0,
+            },
+            errorRate: this.metrics.totalRequests > 0
+                ? this.metrics.totalFailures / this.metrics.totalRequests
+                : 0,
+            cacheHitRate: this.metrics.cacheHits + this.metrics.cacheMisses > 0
+                ? this.metrics.cacheHits /
+                    (this.metrics.cacheHits + this.metrics.cacheMisses)
+                : 0,
+        };
+    }
+    /**
+     * Check if endpoint should skip audit logging
+     */
+    shouldSkipAudit(endpoint) {
+        if (!this.config.audit?.enabled)
+            return true;
+        const skipEndpoints = this.config.audit.skipEndpoints || [];
+        return skipEndpoints.some((skip) => endpoint.includes(skip));
+    }
+    /**
+     * Log audit event (ISO 27001 compliance)
+     */
+    async logAuditEvent(method, url, statusCode, duration, requestSize, responseSize, error, requestHeaders, responseHeaders, requestBody, responseBody) {
+        if (this.shouldSkipAudit(url) || !this.misoClient)
+            return;
+        try {
+            const token = this.getToken();
+            const userId = token ? extractUserIdFromToken(token) : undefined;
+            const auditLevel = this.config.audit?.level || "standard";
+            // Build audit context based on level
+            const auditContext = {
+                method,
+                url,
+                statusCode,
+                duration,
+            };
+            if (userId) {
+                auditContext.userId = userId;
+            }
+            // Minimal level: only basic info
+            if (auditLevel === "minimal") {
+                await this.misoClient.log.audit(`http.request.${method.toLowerCase()}`, url, auditContext, { token: token || undefined });
+                return;
+            }
+            // Standard/Detailed/Full levels: include headers and bodies (masked)
+            const maxResponseSize = this.config.audit?.maxResponseSize || 10000;
+            const maxMaskingSize = this.config.audit?.maxMaskingSize || 50000;
+            // Truncate and mask request body
+            let maskedRequestBody = undefined;
+            if (requestBody !== undefined) {
+                const truncated = truncatePayload(requestBody, maxMaskingSize);
+                if (!truncated.truncated) {
+                    maskedRequestBody = data_masker_1.DataMasker.maskSensitiveData(truncated.data);
+                }
+                else {
+                    maskedRequestBody = truncated.data;
+                }
+            }
+            // Truncate and mask response body (for standard, detailed, full levels)
+            let maskedResponseBody = undefined;
+            if (responseBody !== undefined) {
+                const truncated = truncatePayload(responseBody, maxResponseSize);
+                if (!truncated.truncated) {
+                    maskedResponseBody = data_masker_1.DataMasker.maskSensitiveData(truncated.data);
+                }
+                else {
+                    maskedResponseBody = truncated.data;
+                }
+            }
+            // Mask headers
+            const maskedRequestHeaders = requestHeaders
+                ? data_masker_1.DataMasker.maskSensitiveData(requestHeaders)
+                : undefined;
+            const maskedResponseHeaders = responseHeaders
+                ? data_masker_1.DataMasker.maskSensitiveData(responseHeaders)
+                : undefined;
+            // Add to context based on level (standard, detailed, full all include headers/bodies)
+            if (maskedRequestHeaders)
+                auditContext.requestHeaders = maskedRequestHeaders;
+            if (maskedResponseHeaders)
+                auditContext.responseHeaders = maskedResponseHeaders;
+            if (maskedRequestBody !== undefined)
+                auditContext.requestBody = maskedRequestBody;
+            if (maskedResponseBody !== undefined)
+                auditContext.responseBody = maskedResponseBody;
+            // Add sizes for detailed/full levels
+            if (auditLevel === "detailed" || auditLevel === "full") {
+                if (requestSize !== undefined)
+                    auditContext.requestSize = requestSize;
+                if (responseSize !== undefined)
+                    auditContext.responseSize = responseSize;
+            }
+            if (error) {
+                const maskedError = data_masker_1.DataMasker.maskSensitiveData({
+                    message: error.message,
+                    name: error.name,
+                    stack: error.stack,
+                });
+                auditContext.error = maskedError;
+            }
+            await this.misoClient.log.audit(`http.request.${method.toLowerCase()}`, url, auditContext, { token: token || undefined });
+        }
+        catch (auditError) {
+            // Silently fail audit logging to avoid breaking requests
+            console.warn("Failed to log audit event:", auditError);
+        }
+    }
+    /**
+     * Make HTTP request with all features (caching, retry, deduplication, audit)
+     */
+    async request(method, endpoint, options) {
+        const startTime = Date.now();
+        const fullUrl = `${this.config.baseUrl}${endpoint}`;
+        const cacheKey = generateCacheKey(endpoint, options);
+        const isGetRequest = method.toUpperCase() === "GET";
+        const cacheEnabled = (this.config.cache?.enabled !== false) &&
+            isGetRequest &&
+            (options?.cache?.enabled !== false);
+        // Check cache for GET requests
+        if (cacheEnabled) {
+            const cached = this.cache.get(cacheKey);
+            if (cached && cached.expiresAt > Date.now()) {
+                this.metrics.cacheHits++;
+                return cached.data;
+            }
+            this.metrics.cacheMisses++;
+        }
+        // Check for duplicate concurrent requests (only for GET requests)
+        if (isGetRequest) {
+            const pendingRequest = this.pendingRequests.get(cacheKey);
+            if (pendingRequest) {
+                return pendingRequest;
+            }
+        }
+        // Create request promise
+        const requestPromise = this.executeRequest(method, fullUrl, endpoint, options, cacheKey, cacheEnabled, startTime);
+        // Store pending request (only for GET requests)
+        if (isGetRequest) {
+            this.pendingRequests.set(cacheKey, requestPromise);
+        }
+        try {
+            const result = await requestPromise;
+            return result;
+        }
+        finally {
+            // Cleanup pending request
+            if (isGetRequest) {
+                this.pendingRequests.delete(cacheKey);
+            }
+        }
+    }
+    /**
+     * Execute HTTP request with retry logic
+     */
+    async executeRequest(method, fullUrl, endpoint, options, cacheKey, cacheEnabled, startTime) {
+        const maxRetries = options?.retries !== undefined
+            ? options.retries
+            : this.config.retry?.maxRetries || 3;
+        const retryEnabled = this.config.retry?.enabled !== false;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await this.makeFetchRequest(method, fullUrl, options);
+                const duration = Date.now() - startTime;
+                // Update metrics
+                this.metrics.totalRequests++;
+                this.metrics.responseTimes.push(duration);
+                // Parse response
+                const data = await this.parseResponse(response);
+                // Cache successful GET responses
+                if (cacheEnabled && response.ok) {
+                    const ttl = options?.cache?.ttl || this.config.cache?.defaultTTL || 300;
+                    this.cache.set(cacheKey, {
+                        data,
+                        expiresAt: Date.now() + ttl * 1000,
+                        key: cacheKey,
+                    });
+                    // Enforce max cache size
+                    if (this.cache.size > (this.config.cache?.maxSize || 100)) {
+                        const firstKey = this.cache.keys().next().value;
+                        if (firstKey)
+                            this.cache.delete(firstKey);
+                    }
+                }
+                // Apply response interceptor
+                if (this.interceptors.onResponse) {
+                    return await this.interceptors.onResponse(response, data);
+                }
+                // Audit logging
+                if (!options?.skipAudit) {
+                    const requestSize = options?.body
+                        ? calculateSize(options.body)
+                        : undefined;
+                    const responseSize = calculateSize(data);
+                    await this.logAuditEvent(method, endpoint, response.status, duration, requestSize, responseSize, undefined, this.extractHeaders(options?.headers), this.extractHeaders(response.headers), options?.body, data);
+                }
+                // Handle error responses
+                if (!response.ok) {
+                    if (response.status === 401) {
+                        this.handleAuthError();
+                        throw new data_client_types_1.AuthenticationError("Authentication required", response);
+                    }
+                    throw new data_client_types_1.ApiError(`Request failed with status ${response.status}`, response.status, response);
+                }
+                return data;
+            }
+            catch (error) {
+                lastError = error;
+                const duration = Date.now() - startTime;
+                // Check if retryable
+                const isRetryable = retryEnabled &&
+                    attempt < maxRetries &&
+                    isRetryableError(error.statusCode, error);
+                if (!isRetryable) {
+                    this.metrics.totalFailures++;
+                    // Audit log error
+                    if (!options?.skipAudit) {
+                        await this.logAuditEvent(method, endpoint, error.statusCode || 0, duration, options?.body ? calculateSize(options.body) : undefined, undefined, error, this.extractHeaders(options?.headers), undefined, options?.body, undefined);
+                    }
+                    // Apply error interceptor
+                    if (this.interceptors.onError) {
+                        throw await this.interceptors.onError(error);
+                    }
+                    throw error;
+                }
+                // Calculate backoff delay
+                const baseDelay = this.config.retry?.baseDelay || 1000;
+                const maxDelay = this.config.retry?.maxDelay || 10000;
+                const delay = calculateBackoffDelay(attempt, baseDelay, maxDelay);
+                // Wait before retry
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        // All retries exhausted
+        this.metrics.totalFailures++;
+        if (lastError) {
+            if (this.interceptors.onError) {
+                throw await this.interceptors.onError(lastError);
+            }
+            throw lastError;
+        }
+        throw new Error("Request failed after retries");
+    }
+    /**
+     * Make fetch request with timeout and authentication
+     */
+    async makeFetchRequest(method, url, options) {
+        // Build headers
+        const headers = new Headers(this.config.defaultHeaders);
+        if (options?.headers) {
+            if (options.headers instanceof Headers) {
+                options.headers.forEach((value, key) => headers.set(key, value));
+            }
+            else {
+                Object.entries(options.headers).forEach(([key, value]) => {
+                    headers.set(key, String(value));
+                });
+            }
+        }
+        // Add authentication
+        if (!options?.skipAuth) {
+            const token = this.getToken();
+            if (token) {
+                headers.set("Authorization", `Bearer ${token}`);
+            }
+            // Note: MisoClient client-token is handled server-side, not in browser
+        }
+        // Create abort controller for timeout
+        const timeout = options?.timeout || this.config.timeout || 30000;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        // Merge signals
+        const signal = options?.signal
+            ? this.mergeSignals(controller.signal, options.signal)
+            : controller.signal;
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: options?.body,
+                signal,
+                ...options,
+            });
+            clearTimeout(timeoutId);
+            return response;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new data_client_types_1.TimeoutError(`Request timeout after ${timeout}ms`, timeout);
+            }
+            throw new data_client_types_1.NetworkError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Merge AbortSignals
+     */
+    mergeSignals(signal1, signal2) {
+        const controller = new AbortController();
+        const abort = () => {
+            controller.abort();
+            signal1.removeEventListener("abort", abort);
+            signal2.removeEventListener("abort", abort);
+        };
+        if (signal1.aborted || signal2.aborted) {
+            controller.abort();
+            return controller.signal;
+        }
+        signal1.addEventListener("abort", abort);
+        signal2.addEventListener("abort", abort);
+        return controller.signal;
+    }
+    /**
+     * Parse response based on content type
+     */
+    async parseResponse(response) {
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+            return (await response.json());
+        }
+        if (contentType.includes("text/")) {
+            return (await response.text());
+        }
+        return (await response.blob());
+    }
+    /**
+     * Extract headers from Headers object or Record
+     */
+    extractHeaders(headers) {
+        if (!headers)
+            return undefined;
+        if (headers instanceof Headers) {
+            const result = {};
+            headers.forEach((value, key) => {
+                result[key] = value;
+            });
+            return result;
+        }
+        if (Array.isArray(headers)) {
+            const result = {};
+            headers.forEach(([key, value]) => {
+                result[key] = String(value);
+            });
+            return result;
+        }
+        // Convert Record<string, string | readonly string[]> to Record<string, string>
+        const result = {};
+        Object.entries(headers).forEach(([key, value]) => {
+            result[key] = Array.isArray(value) ? value.join(", ") : String(value);
+        });
+        return result;
+    }
+    /**
+     * Handle authentication error
+     */
+    handleAuthError() {
+        if (isBrowser()) {
+            this.redirectToLogin();
+        }
+    }
+    /**
+     * Apply request interceptor
+     */
+    async applyRequestInterceptor(url, options) {
+        if (this.interceptors.onRequest) {
+            return await this.interceptors.onRequest(url, options);
+        }
+        return options;
+    }
+    // ==================== HTTP METHODS ====================
+    /**
+     * GET request
+     */
+    async get(endpoint, options) {
+        const finalOptions = await this.applyRequestInterceptor(endpoint, {
+            ...options,
+            method: "GET",
+        });
+        return this.request("GET", endpoint, finalOptions);
+    }
+    /**
+     * POST request
+     */
+    async post(endpoint, data, options) {
+        const finalOptions = await this.applyRequestInterceptor(endpoint, {
+            ...options,
+            method: "POST",
+            body: data ? JSON.stringify(data) : undefined,
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.headers,
+            },
+        });
+        return this.request("POST", endpoint, finalOptions);
+    }
+    /**
+     * PUT request
+     */
+    async put(endpoint, data, options) {
+        const finalOptions = await this.applyRequestInterceptor(endpoint, {
+            ...options,
+            method: "PUT",
+            body: data ? JSON.stringify(data) : undefined,
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.headers,
+            },
+        });
+        return this.request("PUT", endpoint, finalOptions);
+    }
+    /**
+     * PATCH request (uses fetch fallback since MisoClient doesn't support PATCH)
+     */
+    async patch(endpoint, data, options) {
+        const finalOptions = await this.applyRequestInterceptor(endpoint, {
+            ...options,
+            method: "PATCH",
+            body: data ? JSON.stringify(data) : undefined,
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.headers,
+            },
+        });
+        return this.request("PATCH", endpoint, finalOptions);
+    }
+    /**
+     * DELETE request
+     */
+    async delete(endpoint, options) {
+        const finalOptions = await this.applyRequestInterceptor(endpoint, {
+            ...options,
+            method: "DELETE",
+        });
+        return this.request("DELETE", endpoint, finalOptions);
+    }
+}
+exports.DataClient = DataClient;
+/**
+ * Singleton instance factory
+ */
+let defaultDataClient = null;
+/**
+ * Get or create default DataClient instance
+ */
+function dataClient(config) {
+    if (!defaultDataClient && config) {
+        defaultDataClient = new DataClient(config);
+    }
+    if (!defaultDataClient) {
+        throw new Error("DataClient not initialized. Call dataClient(config) first.");
+    }
+    return defaultDataClient;
+}
+//# sourceMappingURL=data-client.js.map