@wildo-ai/saas-frontend-lib 1.0.1

package/dist/esm/core/requests/wildo-http-client.frontend.service.js

@@ -0,0 +1,773 @@
+import axios from 'axios';
+import { z } from 'zod';
+import { HttpStatusCode, WildoHeaderKeys } from '@wildo-ai/saas-models';
+import { envLoader } from '../../core/runtime/env-variable-loader.frontend.service.js';
+import { LoggerFrontendService } from '../../core/monitoring/logger.frontend.service.js';
+import { getReadinessChecker } from './api-readiness-checker.frontend.service.js';
+import { errorManagement } from '../../core/errors/error-management.frontend.service.js';
+import { frontendEventBus } from '../../core/events/event-bus.frontend.service.js';
+import { FrontendEvents } from '../../core/events/events.frontend.schemas.js';
+/**
+ * Advanced HTTP Client with sophisticated interceptor system
+ * Automatically uses VITE_API_BASE_URL from environment variables
+ */
+export class WildoBackendHttpClient {
+    axiosInstance;
+    config;
+    authToken = null;
+    tokenRenewalHandler = null;
+    stepUpAuthHandler = null;
+    anonymousUserId = null;
+    anonymousSessionToken = null;
+    anonymousSessionInitPending = false;
+    anonymousSessionTokenHandler = null;
+    consumableToken = null;
+    // Network and concurrency management
+    networkConnectionState = { connected: true, connectionType: 'unknown' };
+    currentConcurrency = 0;
+    isQueueProcessing = false;
+    requestQueue = [];
+    queueInterval = null;
+    // Logging
+    logger;
+    logDebug;
+    // Readiness checker
+    readinessChecker;
+    // Frontend service identity cached at construction from VITE_FRONTEND_SERVICE_NAME.
+    // Injected as X-Frontend-Service-Name header on every request.
+    frontendServiceName;
+    constructor(config = {}) {
+        // Initialize logger
+        this.logger = LoggerFrontendService.getLogger();
+        this.logDebug = this.logger.debugByType('WildoBackendHttpClient');
+        // Enable debug logging in development mode
+        this.logger.setDebugTypeLogging('WildoBackendHttpClient', false);
+        // Load environment configuration to get API base URL
+        const envConfig = envLoader.loadEnvironmentConfig();
+        this.frontendServiceName = envConfig.frontendServiceName;
+        // In development mode, disable retries by default to avoid log spam during debugging
+        // In production, keep retries enabled for resilience
+        const isDev = envLoader.isDevelopment();
+        const defaultRetryAttempts = isDev ? 0 : 3;
+        this.config = {
+            timeout: 30000,
+            maxConcurrentRequests: 30,
+            retryDelay: 1000,
+            enableNetworkQueue: true,
+            queueProcessInterval: 1000,
+            // Use environment variable as default, but allow override via config
+            baseURL: config.baseURL || envConfig.apiBaseUrl,
+            ...config,
+            // Apply retry attempts AFTER spread to ensure environment-based default is used
+            // when not explicitly provided in config
+            retryAttempts: config.retryAttempts !== undefined ? config.retryAttempts : defaultRetryAttempts,
+        };
+        this.logDebug('HTTP Client initialized', {
+            isDevelopment: isDev,
+            nodeEnv: envConfig.nodeEnv,
+            retryAttempts: this.config.retryAttempts,
+            configRetryAttempts: config.retryAttempts,
+            defaultRetryAttempts
+        });
+        this.axiosInstance = axios.create({
+            baseURL: this.config.baseURL,
+            timeout: this.config.timeout,
+            headers: {
+                [WildoHeaderKeys.ACCEPT]: 'application/json',
+                [WildoHeaderKeys.CONTENT_TYPE]: 'application/json',
+            },
+        });
+        // Initialize readiness checker for this API
+        this.readinessChecker = getReadinessChecker(this.config.baseURL || '');
+        this.setupInterceptors();
+        this.setupNetworkMonitoring();
+        this.startQueueProcessor();
+    }
+    /**
+     * Setup sophisticated request and response interceptors
+     */
+    setupInterceptors() {
+        // Request interceptors (order matters - last added runs first)
+        this.axiosInstance.interceptors.request.use(this.networkInterruptionInterceptor.bind(this), this.requestErrorHandler.bind(this));
+        this.axiosInstance.interceptors.request.use(this.concurrencyControlInterceptor.bind(this), this.requestErrorHandler.bind(this));
+        this.axiosInstance.interceptors.request.use(this.loadingRequestInterceptor.bind(this), this.requestErrorHandler.bind(this));
+        this.axiosInstance.interceptors.request.use(this.authenticationInterceptor.bind(this), this.requestErrorHandler.bind(this));
+        // Response interceptors
+        this.axiosInstance.interceptors.response.use(this.responseSuccessInterceptor.bind(this), this.responseErrorInterceptor.bind(this));
+    }
+    /**
+     * Setup network connection monitoring (browser only)
+     */
+    setupNetworkMonitoring() {
+        if (typeof globalThis !== 'undefined' && 'navigator' in globalThis && 'addEventListener' in globalThis) {
+            const handleOnline = () => {
+                this.networkConnectionState = { connected: true, connectionType: 'unknown' };
+            };
+            const handleOffline = () => {
+                this.networkConnectionState = { connected: false, connectionType: 'unknown' };
+            };
+            this.networkConnectionState = globalThis.navigator.onLine
+                ? { connected: true, connectionType: 'unknown' }
+                : { connected: false, connectionType: 'unknown' };
+            globalThis.addEventListener('online', handleOnline);
+            globalThis.addEventListener('offline', handleOffline);
+        }
+    }
+    /**
+     * Start the queue processor for handling queued requests
+     */
+    startQueueProcessor() {
+        if (this.config.enableNetworkQueue && !this.queueInterval) {
+            this.queueInterval = setInterval(() => {
+                this.processRequestQueue();
+            }, this.config.queueProcessInterval);
+        }
+    }
+    /**
+     * Process queued requests when network is available
+     */
+    processRequestQueue() {
+        if (this.isQueueProcessing)
+            return;
+        this.isQueueProcessing = true;
+        while (this.networkConnectionState.connected &&
+            this.requestQueue.length > 0 &&
+            this.currentConcurrency <= (this.config.maxConcurrentRequests || 30)) {
+            const queuedRequest = this.requestQueue.shift();
+            if (queuedRequest) {
+                queuedRequest.resolve(queuedRequest.config);
+            }
+        }
+        this.isQueueProcessing = false;
+    }
+    /**
+     * Network interruption interceptor - queues requests when offline
+     */
+    async networkInterruptionInterceptor(config) {
+        try {
+            if (!this.networkConnectionState.connected) {
+                this.logger.error('HTTP Client - network not connected', { url: config.url });
+                if (this.config.enableNetworkQueue) {
+                    return new Promise((resolve, reject) => {
+                        this.requestQueue.push({ resolve, reject, config });
+                    });
+                }
+            }
+            return config;
+        }
+        catch (error) {
+            this.logger.error('Network interruption interceptor error', { error });
+            return config;
+        }
+    }
+    /**
+     * Concurrency control interceptor - manages concurrent request limits
+     */
+    async concurrencyControlInterceptor(config) {
+        this.currentConcurrency++;
+        return config;
+    }
+    /**
+     * Authentication interceptor - adds JWT token to requests
+     */
+    authenticationInterceptor(config) {
+        try {
+            if (!config.headers) {
+                config.headers = {};
+            }
+            if (this.authToken) {
+                config.headers[WildoHeaderKeys.AUTHORIZATION] = `Bearer ${this.authToken}`;
+            }
+            // Inject X-Frontend-Service-Name on every request so the backend knows
+            // which frontend originated the call. Used by auth flows for redirects
+            // and email links. Value is the configured frontend service identity.
+            config.headers[WildoHeaderKeys.FRONTEND_SERVICE_NAME] = this.frontendServiceName;
+            // W7.3a: Inject anonymous session headers when no auth token is present.
+            // First request uses x-anonymous-session-init (raw UUID), subsequent use x-anonymous-session (JWT).
+            if (!this.authToken && this.anonymousUserId) {
+                if (this.anonymousSessionToken) {
+                    config.headers[WildoHeaderKeys.ANONYMOUS_SESSION] = this.anonymousSessionToken;
+                }
+                else if (this.anonymousSessionInitPending) {
+                    config.headers[WildoHeaderKeys.ANONYMOUS_SESSION_INIT] = this.anonymousUserId;
+                }
+            }
+            // W7.3b: Inject consumable token header for ADDITIVE policy operations.
+            if (this.consumableToken) {
+                config.headers[WildoHeaderKeys.CONSUMABLE_TOKEN] = this.consumableToken;
+            }
+            return config;
+        }
+        catch (error) {
+            this.logger.error('Authentication interceptor error', { error });
+            return config;
+        }
+    }
+    /**
+     * Request interceptor: emit LOADING_*_START if loading config is present.
+     * Marks the config so the response interceptor knows to emit END.
+     */
+    /**
+     * Request interceptor: emit LOADING_*_START if loading config is present.
+     * Guards against double-emission on retries via _loadingEmitted flag —
+     * retried requests reuse the same config object, so START fires only once.
+     */
+    loadingRequestInterceptor(config) {
+        const options = config;
+        if (options.loading && !config._loadingEmitted) {
+            const isCustom = !!options.loading.customIdentifier;
+            const event = isCustom
+                ? FrontendEvents.LOADING_CUSTOM_START
+                : FrontendEvents.LOADING_RESOURCE_START;
+            const payload = isCustom
+                ? {
+                    identifier: options.loading.customIdentifier,
+                    data: undefined,
+                    tier: options.loading.tier,
+                    phase: options.loading.phase,
+                }
+                : {
+                    resourceType: options.resourceType ?? '',
+                    operationIdentifier: options.operationIdentifier ?? '',
+                    variantKey: options.variantKey,
+                    isBulkOperation: options.isBulkOperation,
+                    isOperationDefault: options.isOperationDefault,
+                    optionalDiscriminator: undefined,
+                    contextResourceIdentifiers: {},
+                    tier: options.loading.tier,
+                    phase: options.loading.phase,
+                };
+            frontendEventBus.emit(event, payload);
+            config._loadingEmitted = true;
+        }
+        return config;
+    }
+    /**
+     * Emit LOADING_*_END for a completed request (success or error).
+     * Only fires if _loadingEmitted was set by the request interceptor.
+     */
+    emitLoadingEnd(config) {
+        const options = config;
+        if (config._loadingEmitted && options.loading) {
+            const isCustom = !!options.loading.customIdentifier;
+            const event = isCustom
+                ? FrontendEvents.LOADING_CUSTOM_END
+                : FrontendEvents.LOADING_RESOURCE_END;
+            const payload = isCustom
+                ? {
+                    identifier: options.loading.customIdentifier,
+                    data: undefined,
+                    tier: options.loading.tier,
+                }
+                : {
+                    resourceType: options.resourceType ?? '',
+                    operationIdentifier: options.operationIdentifier ?? '',
+                    variantKey: options.variantKey,
+                    isBulkOperation: options.isBulkOperation,
+                    isOperationDefault: options.isOperationDefault,
+                    optionalDiscriminator: undefined,
+                    contextResourceIdentifiers: {},
+                    tier: options.loading.tier,
+                };
+            frontendEventBus.emit(event, payload);
+        }
+    }
+    /**
+     * Request error handler
+     */
+    requestErrorHandler(error) {
+        return Promise.reject(error);
+    }
+    /**
+     * Response success interceptor - extracts data and manages concurrency
+     */
+    responseSuccessInterceptor(response) {
+        this.currentConcurrency--;
+        this.emitLoadingEnd(response.config);
+        const anonToken = response.headers?.[WildoHeaderKeys.ANONYMOUS_SESSION_TOKEN];
+        if (anonToken && this.anonymousSessionTokenHandler) {
+            this.anonymousSessionToken = anonToken;
+            this.anonymousSessionInitPending = false;
+            this.anonymousSessionTokenHandler(anonToken);
+        }
+        if (response.headers?.[WildoHeaderKeys.CONSUMABLE_TOKEN_CONSUMED] === 'true' && this.consumableToken) {
+            this.consumableToken = null;
+        }
+        return response.data;
+    }
+    /**
+     * Check if error should be retried (500 errors or network errors)
+     * Note: Retries are disabled in development mode by default (retryAttempts=0)
+     * to avoid log spam during debugging. This can be overridden via config.
+     */
+    shouldRetry(error) {
+        // Don't retry if no config (can't retry without request config)
+        if (!error.config) {
+            return false;
+        }
+        // Check retry count
+        const retryCount = error.config.__retryCount || 0;
+        const maxRetries = this.config.retryAttempts ?? 0;
+        this.logDebug('shouldRetry check', {
+            url: error.config?.url,
+            retryCount,
+            maxRetries,
+            status: error.response?.status,
+            willRetry: retryCount < maxRetries
+        });
+        if (retryCount >= maxRetries) {
+            return false;
+        }
+        // Retry on 500-level server errors
+        if (error.response) {
+            const status = error.response.status;
+            if (status >= 500 && status < 600) {
+                return true;
+            }
+            // Don't retry client errors (400-499) except 408 (Request Timeout)
+            if (status >= 400 && status < 500 && status !== 408) {
+                return false;
+            }
+        }
+        // Retry on network errors (no response)
+        if (!error.response) {
+            // Network errors: ECONNABORTED, ETIMEDOUT, ENOTFOUND, ECONNREFUSED, etc.
+            const networkErrorCodes = [
+                'ECONNABORTED',
+                'ETIMEDOUT',
+                'ENOTFOUND',
+                'ECONNREFUSED',
+                'ENETUNREACH',
+                'EAI_AGAIN',
+            ];
+            if (error.code && networkErrorCodes.includes(error.code)) {
+                return true;
+            }
+            // Also retry if error message indicates network issue
+            if (error.message && (error.message.includes('Network Error') ||
+                error.message.includes('timeout') ||
+                error.message.includes('network'))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Calculate exponential backoff delay
+     */
+    calculateRetryDelay(retryCount) {
+        const baseDelay = this.config.retryDelay || 1000;
+        return baseDelay * Math.pow(2, retryCount);
+    }
+    /**
+     * Response error interceptor - handles errors, token renewal, and retries
+     */
+    async responseErrorInterceptor(error) {
+        this.currentConcurrency--;
+        this.logDebug('Response error interceptor', {
+            url: error.config?.url,
+            status: error.response?.status,
+            statusText: error.response?.statusText,
+            data: error.response?.data,
+            code: error.code,
+            retryCount: error.config?.__retryCount || 0,
+        });
+        if (error.response) {
+            const { status, data: errorData } = error.response;
+            // Handle 401 Unauthorized errors
+            if (status === HttpStatusCode.UNAUTHORIZED) {
+                // Backend error response format: { error: { type, message, customMessage, ... } }
+                // Extract error code from nested error object (customMessage or message field)
+                // or from legacy flat format (code field at top level)
+                const errorCode = errorData?.code || errorData?.error?.customMessage || errorData?.error?.message;
+                this.logDebug('Received 401 error', {
+                    code: errorCode,
+                    message: errorData?.message,
+                });
+                // JWT failure codes that indicate an expired/invalid access token
+                // where a refresh token exchange should be attempted
+                const refreshableErrorCodes = [
+                    'authentication_jwt_token_failed', // Backend: JWT verification failed (expired, invalid sig, etc.)
+                    'jwt_verification_failed', // Backend: Lower-level JWT verification error
+                    'jwt_token_expired', // Backend: Explicit token expiry
+                ];
+                // If it's a JWT failure and we have a renewal handler, try to renew
+                if (refreshableErrorCodes.includes(errorCode) && this.tokenRenewalHandler) {
+                    try {
+                        const newToken = await this.tokenRenewalHandler();
+                        this.setAuthToken(newToken);
+                        // Retry the original request with new token
+                        if (error.config) {
+                            error.config.headers[WildoHeaderKeys.AUTHORIZATION] = `Bearer ${newToken}`;
+                            return this.axiosInstance(error.config);
+                        }
+                    }
+                    catch (renewalError) {
+                        this.logger.error('Token renewal failed', { error: renewalError });
+                        this.clearAuthToken();
+                        if (error.config)
+                            this.emitLoadingEnd(error.config);
+                        return Promise.reject(error);
+                    }
+                }
+                // Only clear token for errors that indicate the token itself is invalid
+                // Don't clear for: missing token, authorization failures, or other 401s
+                const tokenInvalidErrors = [
+                    'authentication_jwt_token_failed',
+                    'jwt_verification_failed',
+                    'jwt_token_expired',
+                    'authentication_invalid_token',
+                    'authentication_token_expired',
+                ];
+                if (tokenInvalidErrors.includes(errorCode)) {
+                    this.logDebug('Clearing auth token due to invalid token error', { errorCode });
+                    this.clearAuthToken();
+                }
+                // Continue to error handler below (don't return early)
+                // The error handler will process the 401 and trigger logout if needed
+            }
+            // W7.1: Handle 403 STEP_UP_REQUIRED — prompt re-auth dialog and retry (once per request)
+            if (status === HttpStatusCode.FORBIDDEN && this.stepUpAuthHandler) {
+                const customRef = errorData?.error?.customMessage ?? errorData?.customMessage;
+                if (customRef === 'step_up_required' && !error.config?.__stepUpAttempted) {
+                    try {
+                        const reAuthToken = await this.stepUpAuthHandler();
+                        if (error.config) {
+                            error.config.headers[WildoHeaderKeys.REAUTH_TOKEN] = reAuthToken;
+                            error.config.__stepUpAttempted = true;
+                            return this.axiosInstance(error.config);
+                        }
+                    }
+                    catch {
+                        if (error.config)
+                            this.emitLoadingEnd(error.config);
+                        return Promise.reject(error);
+                    }
+                }
+            }
+            // Enhance error with response data
+            // Backend sends nested format: { error: { type, message, validationErrors, details, ... } }
+            // Also handle legacy flat format for backward compatibility
+            if (errorData) {
+                const nested = errorData.error; // Standard backend ErrorResponse format
+                if (nested && typeof nested === 'object') {
+                    // Nested format (standard): { error: { type, message, validationErrors, ... } }
+                    if (nested.message) {
+                        error.message = nested.message;
+                    }
+                    if (nested.validationErrors) {
+                        error.validationErrors = nested.validationErrors;
+                    }
+                    if (nested.details) {
+                        error.context = nested.details;
+                    }
+                    if (nested.type) {
+                        error.errorType = nested.type;
+                    }
+                    if (nested.customMessageReference) {
+                        error.customMessageReference = nested.customMessageReference;
+                    }
+                }
+                else {
+                    // Flat format (legacy fallback)
+                    if (errorData.message) {
+                        error.message = errorData.message;
+                    }
+                    if (errorData.context) {
+                        error.context = errorData.context;
+                    }
+                }
+                // Always set numeric HTTP status for downstream consumers
+                error.httpStatus = status;
+            }
+        }
+        // Retry logic with exponential backoff
+        if (this.shouldRetry(error)) {
+            const retryCount = (error.config.__retryCount || 0) + 1;
+            error.config.__retryCount = retryCount;
+            const delay = this.calculateRetryDelay(retryCount - 1);
+            const maxRetries = this.config.retryAttempts ?? 0;
+            this.logDebug(`Retrying request (attempt ${retryCount}/${maxRetries})`, {
+                url: error.config.url,
+                delay: `${delay}ms`,
+                status: error.response?.status,
+                code: error.code,
+            });
+            // Wait for exponential backoff delay
+            await new Promise(resolve => setTimeout(resolve, delay));
+            // Retry the request
+            return this.axiosInstance(error.config);
+        }
+        // ─────────────────────────────────────────────────────────────────────────
+        // All retries exhausted - process error through HttpErrorHandler
+        // This emits ERROR_OCCURED event for global error handling
+        // ─────────────────────────────────────────────────────────────────────────
+        // Extract error handling context from axios config
+        // These are passed via RequestOptions from resource operations
+        const config = error.config;
+        const errorContext = {
+            url: config?.url,
+            method: config?.method,
+            // Extract risk level and other context passed via RequestOptions
+            riskLevel: config?.riskLevel,
+            resourceType: config?.resourceType,
+            operationIdentifier: config?.operationIdentifier,
+            silent: config?.silent,
+        };
+        const errorResult = errorManagement.handleHttpError(error, errorContext);
+        // Attach wildoError to the error object for callers to access
+        error.wildoError = errorResult.wildoError;
+        error.httpErrorBehavior = errorResult.behavior;
+        if (error.config)
+            this.emitLoadingEnd(error.config);
+        return Promise.reject(error);
+    }
+    /**
+     * Validate response with Zod schema
+     */
+    validateResponse(schema, response) {
+        if (!response) {
+            throw new Error('No data found in response');
+        }
+        try {
+            return schema.parse(response);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                throw new Error(`Response validation failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    // Public API methods
+    /**
+     * Set authentication token
+     */
+    setAuthToken(token) {
+        this.authToken = token;
+    }
+    /**
+     * Get current authentication token
+     */
+    getAuthToken() {
+        return this.authToken;
+    }
+    /**
+     * Clear authentication token
+     */
+    clearAuthToken() {
+        this.authToken = null;
+    }
+    /**
+     * Set token renewal handler
+     */
+    setTokenRenewalHandler(handler) {
+        this.tokenRenewalHandler = handler;
+    }
+    /**
+     * Check if token renewal handler is set
+     */
+    hasTokenRenewalHandler() {
+        return this.tokenRenewalHandler !== null;
+    }
+    setStepUpAuthHandler(handler) {
+        this.stepUpAuthHandler = handler;
+    }
+    setAnonymousSession(userId, token) {
+        this.anonymousUserId = userId;
+        this.anonymousSessionToken = token;
+        this.anonymousSessionInitPending = !token;
+    }
+    updateAnonymousSessionToken(token) {
+        this.anonymousSessionToken = token;
+        this.anonymousSessionInitPending = false;
+    }
+    clearAnonymousSession() {
+        this.anonymousUserId = null;
+        this.anonymousSessionToken = null;
+        this.anonymousSessionInitPending = false;
+    }
+    getAnonymousSessionToken() {
+        return this.anonymousSessionToken;
+    }
+    setAnonymousSessionTokenHandler(handler) {
+        this.anonymousSessionTokenHandler = handler;
+    }
+    setConsumableToken(token) {
+        this.consumableToken = token;
+    }
+    getConsumableToken() {
+        return this.consumableToken;
+    }
+    /**
+     * Get current concurrent request count
+     */
+    getConcurrentRequestCount() {
+        return this.currentConcurrency;
+    }
+    /**
+     * Get current base URL
+     */
+    getBaseURL() {
+        return this.config.baseURL || '';
+    }
+    /**
+     * Update base URL (useful when environment changes)
+     */
+    updateBaseURL(baseURL) {
+        // If no baseURL provided, reload from environment
+        if (!baseURL) {
+            const envConfig = envLoader.loadEnvironmentConfig();
+            baseURL = envConfig.apiBaseUrl;
+        }
+        this.config.baseURL = baseURL;
+        this.axiosInstance.defaults.baseURL = baseURL;
+        // Update readiness checker with new URL
+        this.readinessChecker = getReadinessChecker(baseURL);
+    }
+    /**
+     * Build full URL with base URL
+     */
+    buildURL(path) {
+        const baseURL = this.getBaseURL();
+        if (!baseURL)
+            return path;
+        const cleanBase = baseURL.endsWith('/') ? baseURL.slice(0, -1) : baseURL;
+        const cleanPath = path.startsWith('/') ? path : `/${path}`;
+        return `${cleanBase}${cleanPath}`;
+    }
+    // Readiness check
+    /**
+     * Ensure API is ready before making requests
+     * Waits for /health/ready to return healthy status
+     * Uses exponential backoff and never stops retrying
+     */
+    async ensureReady() {
+        await this.readinessChecker.waitForReady();
+    }
+    // HTTP Methods
+    /**
+     * GET request
+     */
+    async get(url, options) {
+        await this.ensureReady();
+        this.logDebug('GET request initiated', { url });
+        const response = await this.axiosInstance.get(url, options);
+        if (options?.schema) {
+            return this.validateResponse(options.schema, response);
+        }
+        return response;
+    }
+    /**
+     * POST request
+     */
+    async post(url, data, options) {
+        await this.ensureReady();
+        this.logDebug('POST request initiated', { url });
+        const response = await this.axiosInstance.post(url, data, options);
+        if (options?.schema) {
+            return this.validateResponse(options.schema, response);
+        }
+        return response;
+    }
+    /**
+     * PUT request
+     */
+    async put(url, data, options) {
+        await this.ensureReady();
+        const response = await this.axiosInstance.put(url, data, options);
+        if (options?.schema) {
+            return this.validateResponse(options.schema, response);
+        }
+        return response;
+    }
+    /**
+     * DELETE request
+     */
+    async delete(url, options) {
+        await this.ensureReady();
+        const response = await this.axiosInstance.delete(url, options);
+        if (options?.schema) {
+            return this.validateResponse(options.schema, response);
+        }
+        return response;
+    }
+    /**
+     * PATCH request
+     */
+    async patch(url, data, options) {
+        await this.ensureReady();
+        const response = await this.axiosInstance.patch(url, data, options);
+        if (options?.schema) {
+            return this.validateResponse(options.schema, response);
+        }
+        return response;
+    }
+    /**
+     * Upload a file with progress tracking.
+     *
+     * CRITICAL: Content-Type handling for multipart/form-data
+     *
+     * The Axios instance is created with default `Content-Type: application/json`.
+     * When the body is FormData, Axios's `transformRequest` checks Content-Type:
+     * - If `application/json` → it calls `formDataToJSON(data)` and JSON-serializes the
+     *   FormData, DESTROYING the binary file data. The server receives `{"file":"[object File]"}`
+     *   instead of the actual multipart payload.
+     * - If NOT `application/json` (e.g., `multipart/form-data`) → it passes FormData
+     *   through as-is, and the browser correctly sets the boundary parameter.
+     *
+     * Therefore we MUST override Content-Type to `multipart/form-data` on upload requests.
+     * Axios will auto-append the correct boundary from the FormData object.
+     *
+     * The `Accept: application/json` default header is fine — upload endpoints return JSON
+     * responses (fileId + metadata).
+     *
+     * Auth headers are attached automatically by the authentication interceptor, just
+     * like any other request through this client.
+     *
+     * @param url - Upload endpoint URL (relative to baseURL)
+     * @param formData - FormData containing the file(s) and metadata fields
+     * @param options - Upload options (progress callback, abort signal)
+     * @returns Parsed response data from the server
+     */
+    async uploadFile(url, formData, options) {
+        await this.ensureReady();
+        this.logDebug('File upload request initiated', { url });
+        const response = await this.axiosInstance.post(url, formData, {
+            headers: {
+                // Override the instance default 'application/json' to prevent FormData
+                // JSON serialization. Axios detects FormData + 'multipart/form-data' and
+                // auto-appends the correct boundary parameter.
+                [WildoHeaderKeys.CONTENT_TYPE]: 'multipart/form-data',
+            },
+            onUploadProgress: options?.onUploadProgress
+                ? (progressEvent) => {
+                    if (progressEvent.total && progressEvent.total > 0) {
+                        const percent = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+                        options.onUploadProgress(percent);
+                    }
+                    else if (progressEvent.loaded > 0) {
+                        // Server didn't send Content-Length (chunked or streaming).
+                        // Report -1 so the UI can show an indeterminate progress state
+                        // instead of being stuck at 0%.
+                        options.onUploadProgress(-1);
+                    }
+                }
+                : undefined,
+            signal: options?.signal,
+            // Extended timeout for file uploads (5 minutes) — files can be large
+            timeout: 300000,
+        });
+        return response;
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.queueInterval) {
+            clearInterval(this.queueInterval);
+            this.queueInterval = null;
+        }
+    }
+}
+//# sourceMappingURL=wildo-http-client.frontend.service.js.map