@acontplus/ng-infrastructure 2.0.8 → 2.0.11

package/fesm2022/acontplus-ng-infrastructure.mjs

@@ -1,225 +1,169 @@
 import { HttpContextToken, HttpResponse, HttpContext, HttpClient } from '@angular/common/http';
 import * as i0 from '@angular/core';
 import { inject, Injectable, signal, computed, InjectionToken } from '@angular/core';
-import { retry, map, catchError, finalize } from 'rxjs/operators';
-import { throwError, catchError as catchError$1, switchMap, lastValueFrom } from 'rxjs';
+import { retry, timer, switchMap, throwError, of, catchError, lastValueFrom } from 'rxjs';
 import { NotificationService } from '@acontplus/ng-notifications';
 import { AUTH_TOKEN, ENVIRONMENT, CORE_CONFIG, DEFAULT_CONFIG as DEFAULT_CONFIG$1 } from '@acontplus/ng-config';
 import { Router } from '@angular/router';
+import { finalize, catchError as catchError$1 } from 'rxjs/operators';
 import { OverlayService } from '@acontplus/ng-components';
 
-// A token to use with HttpContext for skipping notifications on specific requests.
+// ---------------------------------------------------------------------------
+// HTTP Context Tokens
+// ---------------------------------------------------------------------------
+/**
+ * Skip all toast notifications for a specific request.
+ * Usage: new HttpContext().set(SKIP_NOTIFICATION, true)
+ */
 const SKIP_NOTIFICATION = new HttpContextToken(() => false);
-// A token to use with HttpContext for forcing notifications on specific requests (overrides exclusion patterns).
+/**
+ * Force-show or force-hide notifications, overriding URL/method exclusion logic.
+ * Usage: new HttpContext().set(SHOW_NOTIFICATIONS, true)
+ */
 const SHOW_NOTIFICATIONS = new HttpContextToken(() => undefined);
+// ---------------------------------------------------------------------------
+// Interceptor
+// ---------------------------------------------------------------------------
 const apiInterceptor = (req, next) => {
     const toastr = inject(NotificationService);
     const tokenProvider = inject(AUTH_TOKEN, { optional: true });
-    // Add authorization header if token is available
-    let modifiedReq = req;
+    // Attach Bearer token when available
     const token = tokenProvider?.getToken();
-    if (token) {
-        modifiedReq = req.clone({
-            setHeaders: { Authorization: `Bearer ${token}` },
-        });
-    }
+    const modifiedReq = token ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } }) : req;
     return next(modifiedReq).pipe(
-    // Retries the request up to 2 times on failure with a 1-second delay.
-    retry({ count: 2, delay: 1000 }), 
-    // Use the `map` operator to handle successful responses.
-    map((event) => {
+    // Retry only on network errors or 5xx — never on 4xx client errors.
+    // Uses exponential back-off: 1 s, 2 s.
+    retry({
+        count: 2,
+        delay: (error, attempt) => {
+            const isRetryable = error.status === 0 || (error.status >= 500 && error.status < 600);
+            if (!isRetryable)
+                throw error; // 4xx — do not retry, bubble up immediately
+            return timer(1000 * attempt); // attempt 1 → 1 s, attempt 2 → 2 s
+        },
+    }), 
+    // Handle successful responses via switchMap so we can return an Observable
+    // (needed to properly throw ApiResponse errors into the RxJS stream).
+    switchMap((event) => {
         if (event instanceof HttpResponse) {
-            return handleSuccessResponse(event, toastr, req);
+            const standardized = standardizeApiResponse(event.body);
+            handleToastNotifications(standardized, toastr, req);
+            if (standardized.status === 'error') {
+                handleApiResponseError(standardized, toastr, req);
+                return throwError(() => standardized);
+            }
+            return of(transformResponseForConsumers(standardized, event));
         }
-        return event;
+        return of(event);
     }), 
-    // Use the `catchError` operator to handle any errors that occur.
-    catchError((error) => handleErrorResponse(error, toastr)));
+    // Handle HTTP-level errors — show notification for critical errors, always re-throw.
+    catchError((error) => handleHttpError(error, toastr)));
 };
-// --- Helper Functions ---
-/**
- * Handles successful HTTP responses, standardizes them, shows notifications, and transforms for consumers.
- */
-function handleSuccessResponse(event, notificationService, req) {
-    const body = event.body;
-    // Standardize the response to always have ApiResponse structure
-    const standardizedResponse = standardizeApiResponse(body);
-    // Handle toast notifications based on standardized response
-    handleToastNotifications(standardizedResponse, notificationService, req);
-    // Return the appropriate data based on response type
-    return transformResponseForConsumers(standardizedResponse, event);
-}
-/**
- * Handles HTTP errors (from the interceptor chain, not backend ApiResponse).
- */
-function handleErrorResponse(error, notificationService) {
-    const status = error.status;
-    // Only show notifications for critical HTTP-level errors.
-    // We avoid showing toasts for 4xx errors, which are handled by the component.
-    if (status !== null && shouldShowCriticalErrorNotification(status)) {
-        const message = getCriticalErrorMessage(error);
-        const title = getErrorTitle(status);
-        notificationService.error({
-            message: message,
-            title: title,
-            config: { duration: 5000 },
-        });
-    }
-    // Always re-throw the error so components/services can handle it.
-    return throwError(() => error);
-}
-/**
- * Standardizes any response to follow the ApiResponse structure
- */
+// ---------------------------------------------------------------------------
+// Standardisation
+// ---------------------------------------------------------------------------
 function standardizeApiResponse(body) {
-    // If it's already a proper ApiResponse, return as is
-    if (isValidApiResponse(body)) {
+    if (isValidApiResponse(body))
         return body;
+    // Raw object without ApiResponse wrapper
+    if (body !== null && body !== undefined && typeof body === 'object' && !('status' in body)) {
+        return wrapSuccess(body);
     }
-    // If it's a raw data response (no wrapper), wrap it
-    if (body && typeof body === 'object' && !('status' in body)) {
-        return {
-            status: 'success',
-            code: '200',
-            message: 'Operation completed successfully',
-            data: body,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    // If it's a primitive value, wrap it
+    // Primitive value
     if (body !== null && body !== undefined && typeof body !== 'object') {
-        return {
-            status: 'success',
-            code: '200',
-            message: 'Operation completed successfully',
-            data: body,
-            timestamp: new Date().toISOString(),
-        };
+        return wrapSuccess(body);
     }
-    // If it's null/undefined, create a success response without data
+    // null / undefined
+    return wrapSuccess(undefined);
+}
+function wrapSuccess(data) {
     return {
         status: 'success',
         code: '200',
         message: 'Operation completed successfully',
+        data,
         timestamp: new Date().toISOString(),
     };
 }
-/**
- * Handles toast notifications based on standardized response
- */
+function isValidApiResponse(response) {
+    if (response === null || typeof response !== 'object')
+        return false;
+    const r = response;
+    return ('status' in r &&
+        'code' in r &&
+        typeof r['status'] === 'string' &&
+        ['success', 'error', 'warning'].includes(r['status']));
+}
+// ---------------------------------------------------------------------------
+// Notifications
+// ---------------------------------------------------------------------------
 function handleToastNotifications(response, notificationService, req) {
-    const shouldShowToast = shouldShowSuccessToast(req);
+    // SKIP_NOTIFICATION always wins — even over SHOW_NOTIFICATIONS
+    if (req.context.get(SKIP_NOTIFICATION))
+        return;
     const forceShow = req.context.get(SHOW_NOTIFICATIONS);
-    const skipNotification = req.context.get(SKIP_NOTIFICATION);
-    // Determine if we should show notifications, considering overrides
-    const showNotifications = forceShow !== undefined ? forceShow : shouldShowToast;
-    if (skipNotification)
+    const autoShow = shouldShowSuccessToast(req);
+    const showNotifications = forceShow !== undefined ? forceShow : autoShow;
+    if (!showNotifications)
         return;
-    // Dynamic handling: Use show() for runtime type selection
-    if (response.message &&
-        showNotifications &&
-        ['success', 'warning', 'error'].includes(response.status)) {
-        notificationService.show({
-            type: response.status,
-            message: response.message,
-        });
-    }
-    // Handle warnings separately if needed
-    if (response.status === 'warning' && response.warnings && response.warnings.length > 0) {
-        response.warnings.forEach((warning) => {
-            notificationService.show({
-                type: 'warning',
-                message: warning.message,
-            });
-        });
+    if (!response.message)
+        return;
+    if (!['success', 'warning', 'error'].includes(response.status))
+        return;
+    // Primary notification — show main message once
+    notificationService.show({
+        type: response.status,
+        message: response.message,
+    });
+    // Secondary: show individual warnings only when no primary message covered them
+    if (response.status === 'warning' && response.warnings?.length && !response.message) {
+        response.warnings.forEach((w) => notificationService.show({ type: 'warning', message: w.message }));
     }
-    // Handle errors separately if needed
-    if (response.status === 'error' && response.errors && response.errors.length > 0) {
-        response.errors.forEach((error) => {
-            notificationService.show({
-                type: 'error',
-                message: error.message,
-            });
-        });
+    // Secondary: show individual errors only when no primary message covered them
+    if (response.status === 'error' && response.errors?.length && !response.message) {
+        response.errors.forEach((e) => notificationService.show({ type: 'error', message: e.message }));
     }
 }
-/**
- * Transforms the standardized response for consumers
- */
+function handleApiResponseError(response, notificationService, req) {
+    if (req.context.get(SKIP_NOTIFICATION))
+        return;
+    const message = response.message || response.errors?.[0]?.message || 'An unexpected error occurred';
+    notificationService.error({ message, config: { duration: 5000 } });
+}
+// ---------------------------------------------------------------------------
+// Response transformation
+// ---------------------------------------------------------------------------
 function transformResponseForConsumers(response, originalEvent) {
     switch (response.status) {
         case 'success':
-            // For success responses, return the data if it exists, otherwise the full response
-            if (response.data !== undefined && response.data !== null) {
-                return originalEvent.clone({ body: response.data });
-            }
-            // For message-only success responses, return the full response
-            return originalEvent.clone({ body: response });
         case 'warning':
-            // For warnings, return data if it exists, otherwise the full response
-            if (response.data !== undefined && response.data !== null) {
-                return originalEvent.clone({ body: response.data });
-            }
-            return originalEvent.clone({ body: response });
+            // Unwrap data for consumers; fall back to full envelope when no data
+            return response.data !== undefined && response.data !== null
+                ? originalEvent.clone({ body: response.data })
+                : originalEvent.clone({ body: response });
         case 'error':
-            // Errors should be thrown, not returned
-            throw response;
+            // Already handled in switchMap — this is a safety fallback
+            return originalEvent.clone({ body: response });
         default:
             return originalEvent.clone({ body: response });
     }
 }
-/**
- * Checks if a response is a valid ApiResponse
- */
-function isValidApiResponse(response) {
-    if (response === null || typeof response !== 'object')
-        return false;
-    const r = response;
-    return ('status' in r &&
-        'code' in r &&
-        typeof r['status'] === 'string' &&
-        ['success', 'error', 'warning'].includes(r['status']));
-}
-/**
- * Determines whether to show success toast notifications based on the request type.
- */
-function shouldShowSuccessToast(req) {
-    const url = req.url?.toLowerCase() || '';
-    const method = req.method?.toLowerCase() || '';
-    // Never show for these cases
-    const excludedPatterns = [
-        'get',
-        '/list',
-        '/search',
-        '/query',
-        '/page',
-        '/paginated',
-        '/health',
-        '/status',
-        '/ping',
-    ];
-    if (excludedPatterns.some((pattern) => method === pattern || url.includes(pattern))) {
-        return false;
-    }
-    // Always show for these methods
-    if (['post', 'put', 'patch', 'delete'].includes(method)) {
-        return true;
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+function handleHttpError(error, notificationService) {
+    if (shouldShowCriticalErrorNotification(error.status)) {
+        notificationService.error({
+            message: getCriticalErrorMessage(error),
+            title: getErrorTitle(error.status),
+            config: { duration: 5000 },
+        });
     }
-    // Default behavior
-    return method !== 'get';
+    return throwError(() => error);
 }
-/**
- * Determines if we should show a notification for this HTTP error.
- */
 function shouldShowCriticalErrorNotification(status) {
-    // Show notifications for:
-    // - Network errors (status 0)
-    // - Server errors (5xx)
     return status === 0 || (status >= 500 && status < 600);
 }
-/**
- * Gets the appropriate title for error notifications.
- */
 function getErrorTitle(status) {
     if (status === 0)
         return 'Connection Error';
@@ -227,17 +171,37 @@ function getErrorTitle(status) {
         return 'Server Error';
     return 'Error';
 }
-/**
- * Gets the appropriate message for critical errors.
- */
 function getCriticalErrorMessage(error) {
     if (error.status === 0) {
         return 'Unable to connect to the server. Please check your network connection.';
     }
     if (error.status >= 500) {
-        return (error.error?.message || error.message || 'A server error occurred. Please try again later.');
-    }
-    return error.error?.message || error.message || 'An unexpected error occurred';
+        return (error.error?.message ?? error.message ?? 'A server error occurred. Please try again later.');
+    }
+    return error.error?.message ?? error.message ?? 'An unexpected error occurred';
+}
+// ---------------------------------------------------------------------------
+// Utility: decide whether to auto-show toast
+// ---------------------------------------------------------------------------
+const MUTABLE_METHODS = new Set(['post', 'put', 'patch', 'delete']);
+const EXCLUDED_URL_PATTERNS = [
+    '/list',
+    '/search',
+    '/query',
+    '/page',
+    '/paginated',
+    '/health',
+    '/status',
+    '/ping',
+];
+function shouldShowSuccessToast(req) {
+    const method = req.method.toLowerCase();
+    const url = req.url.toLowerCase();
+    if (!MUTABLE_METHODS.has(method))
+        return false;
+    if (EXCLUDED_URL_PATTERNS.some((p) => url.includes(p)))
+        return false;
+    return true;
 }
 
 class LoggingService {
@@ -309,10 +273,10 @@ class LoggingService {
         // e.g., Sentry, LogRocket, etc.
         // This is a placeholder for production logging implementation
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: LoggingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: LoggingService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: LoggingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: LoggingService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: LoggingService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: LoggingService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -358,10 +322,10 @@ class TenantInfo {
         localStorage.removeItem('tenantId');
         sessionStorage.removeItem('tenantId');
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: TenantInfo, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: TenantInfo, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: TenantInfo, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: TenantInfo, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: TenantInfo, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: TenantInfo, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -393,21 +357,25 @@ class CorrelationInfo {
     getId() {
         return this.getOrCreateCorrelationId();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: CorrelationInfo, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: CorrelationInfo, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: CorrelationInfo, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: CorrelationInfo, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: CorrelationInfo, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: CorrelationInfo, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
-// HTTP Context tokens
+// ---------------------------------------------------------------------------
+// HTTP Context Tokens & helpers
+// ---------------------------------------------------------------------------
+/** Mark a request as using an absolute URL (skip base-URL injection). */
 const CUSTOM_URL = new HttpContextToken(() => false);
+/** Skip all context headers (correlation, tenant, etc.) for this request. */
 const SKIP_CONTEXT_HEADERS = new HttpContextToken(() => false);
+/** Merge additional headers into the request at call-site. */
 const CUSTOM_HEADERS = new HttpContextToken(() => ({}));
-// Helper functions for HTTP context
 function customUrl() {
     return new HttpContext().set(CUSTOM_URL, true);
 }
@@ -417,10 +385,9 @@ function skipContextHeaders() {
 function withCustomHeaders(headers) {
     return new HttpContext().set(CUSTOM_HEADERS, headers);
 }
-// Default configuration
 const DEFAULT_CONFIG = {
     enableCorrelationTracking: true,
-    enableRequestLogging: false, // This will be overridden by environment.isProduction
+    enableRequestLogging: false,
     enableErrorLogging: true,
     customHeaders: {},
     clientVersion: '1.0.0',
@@ -429,100 +396,94 @@ const DEFAULT_CONFIG = {
     requestIdHeader: 'Request-Id',
     timestampHeader: 'Timestamp',
     excludeUrls: [],
+    skipAuthUrls: ['/login', '/register', '/refresh'],
     includeAuthToken: true,
     baseUrlInjection: true,
     refreshTokenCallback: undefined,
     logoutCallback: undefined,
 };
-// Injection token for configuration - FIXED
 const HTTP_CONTEXT_CONFIG = new InjectionToken('HTTP_CONTEXT_CONFIG', {
-    factory: () => DEFAULT_CONFIG, // Provide a default factory in case it's not provided
+    factory: () => DEFAULT_CONFIG,
 });
+// ---------------------------------------------------------------------------
+// Interceptor
+// ---------------------------------------------------------------------------
 const httpContextInterceptor = (req, next) => {
     const tokenProvider = inject(AUTH_TOKEN, { optional: true });
-    console.log(tokenProvider);
     const router = inject(Router);
     const tenantService = inject(TenantInfo);
     const correlationService = inject(CorrelationInfo);
     const loggingService = inject(LoggingService);
     const environment = inject(ENVIRONMENT);
-    // Get configuration (with fallback to default) - FIXED
     const config = {
         ...DEFAULT_CONFIG,
-        // The default enableRequestLogging needs to be set based on environment here,
-        // as it's dynamic, and DEFAULT_CONFIG is static.
         enableRequestLogging: !environment.isProduction,
         ...inject(HTTP_CONTEXT_CONFIG, { optional: true }),
     };
-    // Check HTTP context tokens
+    // ── Context token flags ──────────────────────────────────────────────────
     const isCustomUrl = req.context.get(CUSTOM_URL);
     const skipHeaders = req.context.get(SKIP_CONTEXT_HEADERS);
     const contextHeaders = req.context.get(CUSTOM_HEADERS);
-    // Skip processing if headers are disabled for this request
-    if (skipHeaders) {
+    if (skipHeaders)
         return next(req);
-    }
-    // Check if URL should be excluded
-    const shouldExclude = config.excludeUrls.some((url) => req.url.includes(url) || new RegExp(url).test(req.url));
-    if (shouldExclude) {
+    // ── URL exclusion (with ReDoS protection) ────────────────────────────────
+    const shouldExclude = config.excludeUrls.some((pattern) => {
+        try {
+            return req.url.includes(pattern) || new RegExp(pattern).test(req.url);
+        }
+        catch {
+            return false; // malformed regex — skip safely
+        }
+    });
+    if (shouldExclude)
         return next(req);
-    }
-    // Skip auth for login, register, and refresh endpoints
-    const skipAuth = req.url.includes('/login') || req.url.includes('/register') || req.url.includes('/refresh');
-    // Handle URL transformation
+    // ── Auth skip check ──────────────────────────────────────────────────────
+    const skipAuth = config.skipAuthUrls.some((u) => req.url.includes(u));
+    // ── URL resolution ───────────────────────────────────────────────────────
     const baseUrl = environment.apiBaseUrl;
     const finalUrl = isCustomUrl || !config.baseUrlInjection ? req.url : `${baseUrl}${req.url}`;
-    // Generate or get correlation context
+    // ── Header construction ──────────────────────────────────────────────────
     const correlationId = config.enableCorrelationTracking
         ? correlationService.getOrCreateCorrelationId()
         : crypto.randomUUID();
     const tenantId = tenantService.getTenantId();
     const requestId = crypto.randomUUID();
-    // Build dynamic headers
-    const headers = {};
-    // Core context headers
-    headers[config.requestIdHeader] = requestId;
+    const headers = {
+        [config.requestIdHeader]: requestId,
+        [config.timestampHeader]: new Date().toISOString(),
+    };
     if (config.enableCorrelationTracking) {
         headers[config.correlationIdHeader] = correlationId;
     }
     if (tenantId) {
         headers[config.tenantIdHeader] = tenantId;
     }
-    headers[config.timestampHeader] = new Date().toISOString();
-    // Client information
     if (config.clientVersion) {
         headers['Client-Version'] = config.clientVersion;
     }
-    // Environment client ID
     if (environment.clientId) {
         headers['Client-Id'] = environment.clientId;
     }
-    // Add authorization header if configured and available
     if (config.includeAuthToken && !skipAuth) {
         const authToken = tokenProvider?.getToken();
-        if (authToken) {
+        if (authToken)
             headers['Authorization'] = `Bearer ${authToken}`;
-        }
     }
-    // Process custom headers from configuration (can be static values or dynamic functions)
+    // Static and dynamic custom headers from config
     Object.entries(config.customHeaders).forEach(([key, value]) => {
         headers[key] = typeof value === 'function' ? value() : value;
     });
-    // Add headers from HTTP context
+    // Per-request headers from HttpContext
     Object.entries(contextHeaders).forEach(([key, value]) => {
         headers[key] = value;
     });
-    // Add content-type for data requests if not already set
-    if (['POST', 'PUT', 'PATCH'].includes(req.method.toUpperCase()) &&
-        !req.headers.has('Content-Type')) {
+    // Content-Type for mutation requests (do not override if already set)
+    if (['POST', 'PUT', 'PATCH'].includes(req.method) && !req.headers.has('Content-Type')) {
         headers['Content-Type'] = 'application/json';
     }
-    // Clone request with enhanced headers and URL
-    const enhancedReq = req.clone({
-        url: finalUrl,
-        setHeaders: headers,
-    });
-    // Log outgoing request if enabled
+    // ── Clone request ────────────────────────────────────────────────────────
+    const enhancedReq = req.clone({ url: finalUrl, setHeaders: headers });
+    // ── Request logging ──────────────────────────────────────────────────────
     if (config.enableRequestLogging) {
         loggingService.logHttpRequest({
             method: req.method,
@@ -536,113 +497,107 @@ const httpContextInterceptor = (req, next) => {
             isCustomUrl,
         });
     }
-    // If request has auth header, handle with refresh logic
-    if (headers['Authorization'] && config.refreshTokenCallback) {
-        return next(enhancedReq).pipe(catchError$1((error) => {
-            // If 401 Unauthorized, try to refresh token
-            if (error.status === 401) {
-                const refreshToken = tokenProvider?.getRefreshToken?.();
-                if (refreshToken && refreshToken.trim().length > 0) {
-                    return config.refreshTokenCallback().pipe(switchMap((newTokens) => {
-                        // Retry the original request with new token
-                        const retryReq = req.clone({
-                            url: finalUrl,
-                            setHeaders: { ...headers, Authorization: `Bearer ${newTokens.token}` },
-                        });
-                        return next(retryReq);
-                    }), catchError$1((refreshError) => {
-                        // Refresh failed, logout user
-                        config.logoutCallback?.();
-                        return throwError(() => refreshError);
-                    }));
-                }
-            }
-            // Enhanced error logging with context
-            if (config.enableErrorLogging) {
-                loggingService.logHttpError({
-                    method: req.method,
-                    url: finalUrl,
-                    originalUrl: req.url,
-                    requestId,
-                    correlationId,
-                    tenantId,
-                    status: error.status,
-                    statusText: error.statusText,
-                    message: error.message,
-                    timestamp: new Date().toISOString(),
-                    errorDetails: error.error,
-                    environment: environment.clientId,
-                    isCustomUrl,
-                    headers: [], // Headers are not included in HttpErrorResponse by default, adjust if needed
-                });
-            }
-            // Handle other error scenarios
-            switch (error.status) {
-                case 403:
-                    tenantService.handleForbidden();
-                    break;
-                case 0:
-                    loggingService.logNetworkError(correlationId);
-                    break;
-                case 429:
-                    loggingService.logRateLimitError(correlationId, finalUrl);
-                    break;
-            }
+    // ── Execute request with unified error handling ──────────────────────────
+    const hasAuth = !!headers['Authorization'];
+    // Shared error context for both handlers below
+    const errorCtx = {
+        req,
+        finalUrl,
+        requestId,
+        correlationId,
+        tenantId,
+        isCustomUrl,
+        hasAuth,
+        config,
+        router,
+        loggingService,
+        tenantService,
+        tokenProvider,
+        environment,
+    };
+    // Base pipeline — always present
+    const base$ = next(enhancedReq).pipe(catchError((error) => handleContextError(error, errorCtx)));
+    // When auth + refresh callback are available, prepend a 401-refresh layer
+    if (!hasAuth || !config.refreshTokenCallback) {
+        return base$;
+    }
+    return next(enhancedReq).pipe(
+    // Intercept 401 first — attempt token refresh before general error handling
+    catchError((error) => {
+        if (error.status !== 401)
             return throwError(() => error);
-        }));
-    }
-    else {
-        // No auth header, use standard error handling
-        return next(enhancedReq).pipe(catchError$1((error) => {
-            // Enhanced error logging with context
-            if (config.enableErrorLogging) {
-                loggingService.logHttpError({
-                    method: req.method,
-                    url: finalUrl,
-                    originalUrl: req.url,
-                    requestId,
-                    correlationId,
-                    tenantId,
-                    status: error.status,
-                    statusText: error.statusText,
-                    message: error.message,
-                    timestamp: new Date().toISOString(),
-                    errorDetails: error.error,
-                    environment: environment.clientId,
-                    isCustomUrl,
-                    headers: [], // Headers are not included in HttpErrorResponse by default, adjust if needed
-                });
-            }
-            // Handle specific error scenarios
-            switch (error.status) {
-                case 401: {
-                    loggingService.error('Unauthorized access - token expired or invalid');
-                    // Note: Token clearing should be handled by the auth service, not infrastructure
-                    router.navigate([`/${environment.loginRoute}`]);
-                    break;
-                }
-                case 403:
-                    tenantService.handleForbidden();
-                    break;
-                case 0:
-                    loggingService.logNetworkError(correlationId);
-                    break;
-                case 429:
-                    loggingService.logRateLimitError(correlationId, finalUrl);
-                    break;
-            }
+        const refreshToken = tokenProvider?.getRefreshToken?.();
+        if (!refreshToken?.trim())
             return throwError(() => error);
+        return config.refreshTokenCallback().pipe(switchMap(({ token }) => next(req.clone({
+            url: finalUrl,
+            setHeaders: { ...headers, Authorization: `Bearer ${token}` },
+        }))), catchError((refreshError) => {
+            config.logoutCallback?.();
+            return throwError(() => refreshError);
         }));
-    }
+    }), 
+    // General error handling (logs, redirects, tenant, rate-limit, etc.)
+    catchError((error) => handleContextError(error, errorCtx)));
 };
-// Helper function to create configuration
+function handleContextError(error, ctx) {
+    const { req, finalUrl, requestId, correlationId, tenantId, isCustomUrl, config, router, loggingService, tenantService, environment, } = ctx;
+    if (config.enableErrorLogging) {
+        loggingService.logHttpError({
+            method: req.method,
+            url: finalUrl,
+            originalUrl: req.url,
+            requestId,
+            correlationId,
+            tenantId,
+            status: error.status,
+            statusText: error.statusText,
+            message: error.message,
+            timestamp: new Date().toISOString(),
+            errorDetails: error.error,
+            environment: environment.clientId,
+            isCustomUrl,
+            headers: [],
+        });
+    }
+    switch (error.status) {
+        case 401:
+            loggingService.error('Unauthorized — redirecting to login');
+            // Let auth service clear tokens before navigation
+            config.logoutCallback?.();
+            router.navigate([`/${environment.loginRoute}`]);
+            break;
+        case 403:
+            tenantService.handleForbidden();
+            break;
+        case 0:
+            loggingService.logNetworkError(correlationId);
+            break;
+        case 429:
+            loggingService.logRateLimitError(correlationId, finalUrl);
+            break;
+    }
+    return throwError(() => error);
+}
+// ---------------------------------------------------------------------------
+// Public helpers for library consumers
+// ---------------------------------------------------------------------------
 function createHttpContextConfig(overrides = {}) {
-    return {
-        ...DEFAULT_CONFIG,
-        ...overrides,
-    };
+    return { ...DEFAULT_CONFIG, ...overrides };
 }
-// Provider function for easy setup
+/**
+ * Register the interceptor configuration in your app providers.
+ *
+ * @example
+ * // app.config.ts
+ * provideHttpClient(
+ *   withInterceptors([
+ *     httpContextInterceptor,  // 1st — adds headers, handles 401 refresh
+ *     apiInterceptor,          // 2nd — normalises response, shows toasts
+ *   ])
+ * ),
+ * ...provideHttpContext({ clientVersion: '2.0.0' }),
+ */
 function provideHttpContext(config = {}) {
     return [
         {
@@ -652,65 +607,50 @@ function provideHttpContext(config = {}) {
     ];
 }
 
-/**
- * Token to determine if a request should show spinner
- * Default is true (show spinner for all requests)
- */
 const SHOW_SPINNER = new HttpContextToken(() => true);
-const requests = [];
-/**
- * Helper function to disable spinner for specific requests
- * @returns HttpContext with spinner disabled
- */
 function withoutSpinner() {
     return new HttpContext().set(SHOW_SPINNER, false);
 }
-/**
- * Service to track active HTTP requests
- */
 class ActiveRequestsTracker {
+    requests = [];
     get count() {
-        return requests.length;
+        return this.requests.length;
     }
+    /** Retorna true si se pasa de 0 → 1 (primera request activa). */
     add(request) {
-        requests.push(request);
+        this.requests.push(request);
+        return this.requests.length === 1;
     }
+    /** Retorna true si se pasa de 1 → 0 (última request completada). */
     remove(request) {
-        const index = requests.indexOf(request);
+        const index = this.requests.indexOf(request);
         if (index >= 0) {
-            requests.splice(index, 1);
+            this.requests.splice(index, 1);
         }
+        return this.requests.length === 0;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: ActiveRequestsTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: ActiveRequestsTracker, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ActiveRequestsTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ActiveRequestsTracker, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: ActiveRequestsTracker, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ActiveRequestsTracker, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+            args: [{ providedIn: 'root' }]
         }] });
-/**
- * Interceptor that shows/hides a loading spinner based on active HTTP requests
- */
 const spinnerInterceptor = (req, next) => {
-    // Track active requests requiring spinner
     const activeRequests = inject(ActiveRequestsTracker);
     const overlayService = inject(OverlayService);
-    // Skip spinner if disabled for this request
     if (!req.context.get(SHOW_SPINNER)) {
         return next(req);
     }
-    // Add request to tracking
-    activeRequests.add(req);
-    // Show spinner if this is the first active request
-    if (activeRequests.count === 1) {
+    // showSpinner solo cuando pasamos de 0 → 1 requests
+    const isFirst = activeRequests.add(req);
+    if (isFirst) {
         overlayService.showSpinner();
     }
     return next(req).pipe(finalize(() => {
-        // Remove request and hide spinner if no more active requests
-        activeRequests.remove(req);
-        if (activeRequests.count === 0) {
+        // hideSpinner solo cuando pasamos de 1 → 0 requests
+        const isEmpty = activeRequests.remove(req);
+        if (isEmpty) {
             overlayService.hideSpinner();
         }
     }));
@@ -739,10 +679,10 @@ class BaseHttpRepository {
     delete(path = '') {
         return this.http.delete(this.buildUrl(path));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: BaseHttpRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: BaseHttpRepository });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: BaseHttpRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: BaseHttpRepository });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: BaseHttpRepository, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: BaseHttpRepository, decorators: [{
             type: Injectable
         }] });
 
@@ -786,10 +726,10 @@ class GenericRepository extends BaseHttpRepository {
         }
         return params;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: GenericRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: GenericRepository });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: GenericRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: GenericRepository });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: GenericRepository, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: GenericRepository, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 class SearchableGenericRepository extends GenericRepository {
@@ -798,10 +738,10 @@ class SearchableGenericRepository extends GenericRepository {
         const params = this.buildParams(pagination, searchFilters);
         return this.get('search', params);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: SearchableGenericRepository, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: SearchableGenericRepository });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: SearchableGenericRepository, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: SearchableGenericRepository });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: SearchableGenericRepository, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: SearchableGenericRepository, decorators: [{
             type: Injectable
         }] });
 
@@ -844,10 +784,10 @@ class RepositoryFactory {
             remove: (id) => this.http.delete(buildUrl(idToString(id))),
         };
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: RepositoryFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: RepositoryFactory, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: RepositoryFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: RepositoryFactory, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: RepositoryFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: RepositoryFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -979,10 +919,10 @@ class CoreConfigService {
     resetConfig() {
         this.config = this.initializeConfig();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: CoreConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: CoreConfigService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: CoreConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: CoreConfigService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.1", ngImport: i0, type: CoreConfigService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: CoreConfigService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1025,7 +965,7 @@ class Command extends BaseUseCase {
                 timestamp: new Date().toISOString(),
             }));
         }
-        return this.executeInternal(request).pipe(catchError((error) => {
+        return this.executeInternal(request).pipe(catchError$1((error) => {
             // Log the error for debugging
             const logger = inject(LoggingService);
             logger.error('An error occurred during command execution:', error);
@@ -1037,7 +977,7 @@ class Command extends BaseUseCase {
 
 class Query extends BaseUseCase {
     execute(request) {
-        return this.executeInternal(request).pipe(catchError((error) => {
+        return this.executeInternal(request).pipe(catchError$1((error) => {
             const logger = inject(LoggingService);
             logger.error('An error occurred during query execution:', error);
             return throwError(() => error);
@@ -1049,5 +989,5 @@ class Query extends BaseUseCase {
  * Generated bundle index. Do not edit.
  */
 
-export { ActiveRequestsTracker, AngularHttpAdapter, BaseHttpRepository, BaseUseCase, Command, CoreConfigService, CorrelationInfo, GenericRepository, HTTP_CONTEXT_CONFIG, LoggingService, Query, REPOSITORY_CONFIG, RepositoryFactory, SHOW_NOTIFICATIONS, SKIP_NOTIFICATION, SearchableGenericRepository, apiInterceptor, createCoreConfig, createHttpContextConfig, customUrl, httpContextInterceptor, provideCoreConfig, provideHttpContext, skipContextHeaders, spinnerInterceptor, withCustomHeaders, withoutSpinner };
+export { ActiveRequestsTracker, AngularHttpAdapter, BaseHttpRepository, BaseUseCase, Command, CoreConfigService, CorrelationInfo, GenericRepository, HTTP_CONTEXT_CONFIG, LoggingService, Query, REPOSITORY_CONFIG, RepositoryFactory, SHOW_NOTIFICATIONS, SHOW_SPINNER, SKIP_NOTIFICATION, SearchableGenericRepository, apiInterceptor, createCoreConfig, createHttpContextConfig, customUrl, httpContextInterceptor, provideCoreConfig, provideHttpContext, skipContextHeaders, spinnerInterceptor, withCustomHeaders, withoutSpinner };
 //# sourceMappingURL=acontplus-ng-infrastructure.mjs.map