@acontplus/ng-infrastructure 1.0.0

package/fesm2022/acontplus-ng-infrastructure.mjs

@@ -0,0 +1,1015 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, signal, computed } from '@angular/core';
+import { HttpContextToken, HttpResponse, HttpContext, HttpClient } from '@angular/common/http';
+import { retry, map, catchError, finalize } from 'rxjs/operators';
+import { throwError, catchError as catchError$1, lastValueFrom } from 'rxjs';
+import { NotificationService } from '@acontplus/ng-notifications';
+import { Router } from '@angular/router';
+import { v4 } from 'uuid';
+import { ENVIRONMENT } from '@acontplus/ng-config';
+import { OverlayService } from '@acontplus/ng-components';
+import { jwtDecode } from 'jwt-decode';
+
+const TOKEN_PROVIDER = new InjectionToken('TOKEN_PROVIDER');
+
+// A token to use with HttpContext for skipping notifications on specific requests.
+const SKIP_NOTIFICATION = new HttpContextToken(() => false);
+// A token to use with HttpContext for forcing notifications on specific requests (overrides exclusion patterns).
+const SHOW_NOTIFICATIONS = new HttpContextToken(() => undefined);
+const apiInterceptor = (req, next) => {
+    const toastr = inject(NotificationService);
+    const tokenProvider = inject(TOKEN_PROVIDER, { optional: true });
+    // Add authorization header if token is available
+    let modifiedReq = req;
+    const token = tokenProvider?.getToken();
+    if (token) {
+        modifiedReq = req.clone({
+            setHeaders: { Authorization: `Bearer ${token}` }
+        });
+    }
+    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) => {
+        if (event instanceof HttpResponse) {
+            return handleSuccessResponse(event, toastr, req);
+        }
+        return event;
+    }), 
+    // Use the `catchError` operator to handle any errors that occur.
+    catchError((error) => handleErrorResponse(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
+ */
+function standardizeApiResponse(body) {
+    // If it's already a proper ApiResponse, return as is
+    if (isValidApiResponse(body)) {
+        return 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
+    if (body !== null && body !== undefined && typeof body !== 'object') {
+        return {
+            status: 'success',
+            code: '200',
+            message: 'Operation completed successfully',
+            data: body,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // If it's null/undefined, create a success response without data
+    return {
+        status: 'success',
+        code: '200',
+        message: 'Operation completed successfully',
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Handles toast notifications based on standardized response
+ */
+function handleToastNotifications(response, notificationService, req) {
+    const shouldShowToast = shouldShowSuccessToast(req);
+    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)
+        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,
+            });
+        });
+    }
+    // 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,
+            });
+        });
+    }
+}
+/**
+ * Transforms the standardized response for consumers
+ */
+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 });
+        case 'error':
+            // Errors should be thrown, not returned
+            throw 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;
+    }
+    // Default behavior
+    return method !== 'get';
+}
+/**
+ * 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';
+    if (status >= 500)
+        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';
+}
+
+class TenantService {
+    tenantId = null;
+    getTenantId() {
+        if (!this.tenantId) {
+            // Get from localStorage, sessionStorage, or JWT token
+            this.tenantId =
+                localStorage.getItem('tenantId') ||
+                    sessionStorage.getItem('tenantId') ||
+                    this.extractTenantFromToken() ||
+                    'default-tenant';
+        }
+        return this.tenantId;
+    }
+    getCurrentTenant() {
+        return this.tenantId;
+    }
+    setTenantId(tenantId) {
+        this.tenantId = tenantId;
+        localStorage.setItem('tenantId', tenantId);
+    }
+    setTenant(tenantId) {
+        this.setTenantId(tenantId);
+    }
+    handleForbidden() {
+        console.error('Access forbidden for tenant:', this.tenantId);
+        // Redirect to tenant selection or show error message
+        // this.router.navigate(['/tenant-access-denied']);
+    }
+    extractTenantFromToken() {
+        // Implementation depends on your JWT token structure
+        // This is a placeholder
+        return null;
+    }
+    clearTenant() {
+        this.tenantId = null;
+        localStorage.removeItem('tenantId');
+        sessionStorage.removeItem('tenantId');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: TenantService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: TenantService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: TenantService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CorrelationService {
+    correlationId = signal(null, ...(ngDevMode ? [{ debugName: "correlationId" }] : []));
+    CORRELATION_KEY = 'correlation-id';
+    // Signal-based getter for reactive updates
+    currentCorrelationId = computed(() => this.correlationId(), ...(ngDevMode ? [{ debugName: "currentCorrelationId" }] : []));
+    getOrCreateCorrelationId() {
+        if (!this.correlationId()) {
+            // Try to get from sessionStorage first (for page refreshes)
+            // @ts-ignore
+            const id = sessionStorage.getItem(this.CORRELATION_KEY) || v4();
+            this.correlationId.set(id);
+            sessionStorage.setItem(this.CORRELATION_KEY, id);
+        }
+        return this.correlationId();
+    }
+    setCorrelationId(correlationId) {
+        this.correlationId.set(correlationId);
+        sessionStorage.setItem(this.CORRELATION_KEY, correlationId);
+    }
+    resetCorrelationId() {
+        this.correlationId.set(null);
+        sessionStorage.removeItem(this.CORRELATION_KEY);
+    }
+    getId() {
+        return this.getOrCreateCorrelationId();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: CorrelationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: CorrelationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: CorrelationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class LoggingService {
+    environment = inject(ENVIRONMENT);
+    log(level, message, context) {
+        if (this.environment.isProduction) {
+            // Production logging (e.g., to external service)
+            this.logToExternalService(level, message, context);
+        }
+        else {
+            // Development logging
+            console[level](`[${level.toUpperCase()}] ${message}`, context);
+        }
+    }
+    info(message, context) {
+        this.log('info', message, context);
+    }
+    warn(message, context) {
+        this.log('warn', message, context);
+    }
+    error(message, context) {
+        this.log('error', message, context);
+    }
+    // HTTP Request Logging
+    logHttpRequest(log) {
+        this.info(`HTTP Request - ${log.method} ${log.url}`, {
+            requestId: log.requestId,
+            correlationId: log.correlationId,
+            tenantId: log.tenantId,
+            headers: log.headers,
+            isCustomUrl: log.isCustomUrl,
+            timestamp: log.timestamp,
+        });
+    }
+    // HTTP Error Logging
+    logHttpError(error) {
+        this.error(`HTTP Error - ${error.method} ${error.url}`, {
+            status: error.status,
+            statusText: error.statusText,
+            requestId: error.requestId,
+            correlationId: error.correlationId,
+            tenantId: error.tenantId,
+            errorDetails: error.errorDetails,
+            environment: error.environment,
+            timestamp: error.timestamp,
+        });
+    }
+    // Network Error Logging
+    logNetworkError(correlationId) {
+        this.error('Network connection failed', {
+            type: 'network-error',
+            correlationId,
+            userAgent: navigator.userAgent,
+            online: navigator.onLine,
+        });
+    }
+    // Rate Limit Error Logging
+    logRateLimitError(correlationId, url) {
+        this.warn('Rate limit exceeded', {
+            type: 'rate-limit-error',
+            correlationId,
+            url,
+        });
+    }
+    logToExternalService(level, message, context) {
+        // Implement external logging service integration
+        // e.g., Sentry, LogRocket, etc.
+        // This is a placeholder for production logging implementation
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: LoggingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: LoggingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: LoggingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+// HTTP Context tokens
+const CUSTOM_URL = new HttpContextToken(() => false);
+const SKIP_CONTEXT_HEADERS = new HttpContextToken(() => false);
+const CUSTOM_HEADERS = new HttpContextToken(() => ({}));
+// Helper functions for HTTP context
+function customUrl() {
+    return new HttpContext().set(CUSTOM_URL, true);
+}
+function skipContextHeaders() {
+    return new HttpContext().set(SKIP_CONTEXT_HEADERS, true);
+}
+function withCustomHeaders(headers) {
+    return new HttpContext().set(CUSTOM_HEADERS, headers);
+}
+// Default configuration
+const DEFAULT_CONFIG$1 = {
+    enableCorrelationTracking: true,
+    enableRequestLogging: false, // This will be overridden by environment.isProduction
+    enableErrorLogging: true,
+    customHeaders: {},
+    clientVersion: '1.0.0',
+    tenantIdHeader: 'Tenant-Id',
+    correlationIdHeader: 'Correlation-Id',
+    requestIdHeader: 'Request-Id',
+    timestampHeader: 'Timestamp',
+    excludeUrls: [],
+    includeAuthToken: true,
+    baseUrlInjection: true,
+};
+// Injection token for configuration - FIXED
+const HTTP_CONTEXT_CONFIG = new InjectionToken('HTTP_CONTEXT_CONFIG', {
+    factory: () => DEFAULT_CONFIG$1, // Provide a default factory in case it's not provided
+});
+const httpContextInterceptor = (req, next) => {
+    const tokenProvider = inject(TOKEN_PROVIDER, { optional: true });
+    const router = inject(Router);
+    const tenantService = inject(TenantService);
+    const correlationService = inject(CorrelationService);
+    const loggingService = inject(LoggingService);
+    const environment = inject(ENVIRONMENT);
+    // Get configuration (with fallback to default) - FIXED
+    const config = {
+        ...DEFAULT_CONFIG$1,
+        // 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
+    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) {
+        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) {
+        return next(req);
+    }
+    // Handle URL transformation
+    const baseUrl = environment.apiBaseUrl;
+    const finalUrl = isCustomUrl || !config.baseUrlInjection ? req.url : `${baseUrl}${req.url}`;
+    // Generate or get correlation context
+    const correlationId = config.enableCorrelationTracking
+        ? correlationService.getOrCreateCorrelationId()
+        : v4();
+    const tenantId = tenantService.getTenantId();
+    const requestId = v4();
+    // Build dynamic headers
+    const headers = {};
+    // Core context headers
+    headers[config.requestIdHeader] = requestId;
+    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) {
+        const authToken = tokenProvider?.getToken();
+        if (authToken) {
+            headers['Authorization'] = `Bearer ${authToken}`;
+        }
+    }
+    // Process custom headers from configuration (can be static values or dynamic functions)
+    Object.entries(config.customHeaders).forEach(([key, value]) => {
+        headers[key] = typeof value === 'function' ? value() : value;
+    });
+    // Add headers from HTTP context
+    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')) {
+        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
+    if (config.enableRequestLogging) {
+        loggingService.logHttpRequest({
+            method: req.method,
+            url: finalUrl,
+            originalUrl: req.url,
+            requestId,
+            correlationId,
+            tenantId,
+            timestamp: new Date().toISOString(),
+            headers: Object.keys(headers),
+            isCustomUrl,
+        });
+    }
+    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:
+                console.error('Unauthorized access - token expired or invalid');
+                // Note: Token clearing should be handled by the auth service, not infrastructure
+                router.navigate(['/login']);
+                break;
+            case 403:
+                tenantService.handleForbidden();
+                break;
+            case 0:
+                loggingService.logNetworkError(correlationId);
+                break;
+            case 429:
+                loggingService.logRateLimitError(correlationId, finalUrl);
+                break;
+        }
+        return throwError(() => error);
+    }));
+};
+// Helper function to create configuration
+function createHttpContextConfig(overrides = {}) {
+    return {
+        ...DEFAULT_CONFIG$1,
+        ...overrides,
+    };
+}
+// Provider function for easy setup
+function provideHttpContext(config = {}) {
+    return [
+        {
+            provide: HTTP_CONTEXT_CONFIG,
+            useValue: createHttpContextConfig(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 {
+    get count() {
+        return requests.length;
+    }
+    add(request) {
+        requests.push(request);
+    }
+    remove(request) {
+        const index = requests.indexOf(request);
+        if (index >= 0) {
+            requests.splice(index, 1);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: ActiveRequestsTracker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: ActiveRequestsTracker, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: ActiveRequestsTracker, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+/**
+ * Interceptor that shows/hides a loading spinner based on active HTTP requests
+ */
+const spinnerInterceptor = (req, next) => {
+    // Track active requests requiring spinner
+    console.log(requests);
+    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) {
+        overlayService.showSpinner();
+    }
+    return next(req).pipe(finalize(() => {
+        // Remove request and hide spinner if no more active requests
+        activeRequests.remove(req);
+        if (activeRequests.count === 0) {
+            overlayService.hideSpinner();
+        }
+    }));
+};
+
+class BaseHttpRepository {
+    http = inject(HttpClient);
+    buildUrl(path = '') {
+        const baseUrl = this.config.baseUrl || '/api';
+        const version = this.config.version ? `/v${this.config.version}` : '';
+        const endpoint = path ? `${this.config.endpoint}/${path}` : this.config.endpoint;
+        return `${baseUrl}${version}/${endpoint}`.replace(/\/+/g, '/');
+    }
+    get(path = '', params) {
+        return this.http.get(this.buildUrl(path), { params });
+    }
+    post(path = '', body) {
+        return this.http.post(this.buildUrl(path), body);
+    }
+    put(path = '', body) {
+        return this.http.put(this.buildUrl(path), body);
+    }
+    patch(path = '', body) {
+        return this.http.patch(this.buildUrl(path), body);
+    }
+    delete(path = '') {
+        return this.http.delete(this.buildUrl(path));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: BaseHttpRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: BaseHttpRepository });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: BaseHttpRepository, decorators: [{
+            type: Injectable
+        }] });
+
+// Create an injection token for RepositoryConfig
+const REPOSITORY_CONFIG = new InjectionToken('REPOSITORY_CONFIG');
+class GenericRepository extends BaseHttpRepository {
+    config;
+    constructor() {
+        const config = inject(REPOSITORY_CONFIG);
+        super();
+        this.config = config;
+    }
+    getById(id) {
+        return this.get(id.toString());
+    }
+    getAll(pagination) {
+        const params = this.buildParams(pagination);
+        return this.get('', params);
+    }
+    create(entity) {
+        return this.post('', entity);
+    }
+    update(id, entity) {
+        return this.put(id.toString(), entity);
+    }
+    remove(id) {
+        return super.delete(id.toString());
+    }
+    buildParams(pagination, filters) {
+        const params = {};
+        if (pagination) {
+            params.pageIndex = pagination.pageIndex?.toString() || '1';
+            params.pageSize = pagination.pageSize?.toString() || '20';
+            if (pagination.sortBy)
+                params.sortBy = pagination.sortBy;
+            if (pagination.sortDirection)
+                params.sortDirection = pagination.sortDirection;
+        }
+        if (filters) {
+            Object.assign(params, filters);
+        }
+        return params;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: GenericRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: GenericRepository });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: GenericRepository, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+class SearchableGenericRepository extends GenericRepository {
+    search(query, pagination) {
+        const searchFilters = { q: query };
+        const params = this.buildParams(pagination, searchFilters);
+        return this.get('search', params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: SearchableGenericRepository, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: SearchableGenericRepository });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: SearchableGenericRepository, decorators: [{
+            type: Injectable
+        }] });
+
+class RepositoryFactory {
+    http = inject(HttpClient);
+    create(config) {
+        const buildUrl = (path = '') => {
+            const baseUrl = config.baseUrl || '/api';
+            const version = config.version ? `/v${config.version}` : '';
+            const endpoint = path ? `${config.endpoint}/${path}` : config.endpoint;
+            return `${baseUrl}${version}/${endpoint}`.replace(/\/+/g, '/');
+        };
+        const buildParams = (pagination) => {
+            const params = {};
+            if (pagination) {
+                params.page = pagination.pageIndex?.toString() || '1';
+                params.pageSize = pagination.pageSize?.toString() || '20';
+                if (pagination.sortBy)
+                    params.sortBy = pagination.sortBy;
+                if (pagination.sortDirection)
+                    params.sortDirection = pagination.sortDirection;
+            }
+            return params;
+        };
+        // Safe ID conversion function
+        const idToString = (id) => {
+            if (typeof id === 'string' || typeof id === 'number' || typeof id === 'bigint') {
+                return id.toString();
+            }
+            // Fallback for other types - you might want to handle this differently
+            return String(id);
+        };
+        return {
+            getById: (id) => this.http.get(buildUrl(idToString(id))),
+            getAll: (pagination) => this.http.get(buildUrl(), {
+                params: buildParams(pagination),
+            }),
+            create: (entity) => this.http.post(buildUrl(), entity),
+            update: (id, entity) => this.http.put(buildUrl(idToString(id)), entity),
+            remove: (id) => this.http.delete(buildUrl(idToString(id))),
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: RepositoryFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: RepositoryFactory, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: RepositoryFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class UserRepository {
+    tokenProvider = inject(TOKEN_PROVIDER);
+    getCurrentUser() {
+        const token = this.tokenProvider.getToken();
+        if (!token) {
+            return null;
+        }
+        try {
+            const decodedToken = jwtDecode(token);
+            const email = decodedToken['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress'] ??
+                decodedToken['email'] ??
+                decodedToken['sub'] ??
+                decodedToken['user_id'];
+            const name = decodedToken['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname'] ??
+                decodedToken['name'] ??
+                decodedToken['given_name'] ??
+                decodedToken['display_name'];
+            if (!email) {
+                return null;
+            }
+            const userData = {
+                email: email.toString(),
+                name: name?.toString() ?? 'Unknown User',
+            };
+            return userData;
+        }
+        catch {
+            return null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: UserRepository, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: UserRepository, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: UserRepository, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+function mergeUrl(baseURL, endpoint) {
+    if (!baseURL)
+        return endpoint;
+    return `${baseURL.replace(/\/+$/, '')}/${endpoint.replace(/^\/+/, '')}`;
+}
+class AngularHttpAdapter {
+    http;
+    baseURL;
+    constructor(http, baseURL) {
+        this.http = http;
+        this.baseURL = baseURL;
+    }
+    buildOptions(options) {
+        return {
+            headers: options?.headers ?? {},
+            params: options?.params ?? {},
+        };
+    }
+    async request(params) {
+        const fullUrl = mergeUrl(this.baseURL, params.url);
+        const httpOptions = this.buildOptions(params.options);
+        const observable = this.http.request(params.method, fullUrl, {
+            body: params.data,
+            ...httpOptions,
+        });
+        return await lastValueFrom(observable);
+    }
+    /** GET */
+    get(url, options) {
+        return this.request({ method: 'get', url, options });
+    }
+    /** POST */
+    post(url, data, options) {
+        return this.request({ method: 'post', url, data, options });
+    }
+    /** PUT */
+    put(url, data, options) {
+        return this.request({ method: 'put', url, data, options });
+    }
+    /** DELETE */
+    delete(url, options) {
+        return this.request({ method: 'delete', url, options });
+    }
+}
+
+// Default configuration
+const DEFAULT_CONFIG = {
+    apiBaseUrl: '',
+    apiTimeout: 30000,
+    retryAttempts: 2,
+    retryDelay: 1000,
+    enableCorrelationTracking: true,
+    enableRequestLogging: false,
+    enableErrorLogging: true,
+    enableToastNotifications: true,
+    includeAuthToken: true,
+    authTokenHeader: 'Authorization',
+    enableMultiTenancy: true,
+    tenantIdHeader: 'Tenant-Id',
+    logLevel: 'info',
+    enableConsoleLogging: true,
+    customHeaders: {},
+    excludeUrls: [],
+    excludeMethods: [],
+};
+// Injection token for configuration
+const CORE_CONFIG = new InjectionToken('CORE_CONFIG', {
+    factory: () => DEFAULT_CONFIG,
+});
+class CoreConfigService {
+    config;
+    environment = inject(ENVIRONMENT);
+    constructor() {
+        // Initialize with default config and environment overrides
+        this.config = this.initializeConfig();
+    }
+    /**
+     * Initialize configuration with defaults and environment overrides
+     */
+    initializeConfig() {
+        const injectedConfig = inject(CORE_CONFIG, { optional: true });
+        return {
+            ...DEFAULT_CONFIG,
+            // Environment overrides
+            apiBaseUrl: this.environment.apiBaseUrl || DEFAULT_CONFIG.apiBaseUrl,
+            enableRequestLogging: !this.environment.isProduction,
+            // Injected config overrides
+            ...injectedConfig,
+        };
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration at runtime
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+    /**
+     * Get a specific configuration value
+     */
+    get(key) {
+        return this.config[key];
+    }
+    /**
+     * Check if a feature is enabled
+     */
+    isFeatureEnabled(feature) {
+        const value = this.config[feature];
+        return typeof value === 'boolean' ? value : false;
+    }
+    /**
+     * Get API URL for a specific entity
+     */
+    getApiUrl(entityName) {
+        const baseUrl = this.config.apiBaseUrl;
+        if (!entityName)
+            return baseUrl;
+        return `${baseUrl}/${entityName}`.replace(/\/+/g, '/');
+    }
+    /**
+     * Check if a URL should be excluded from processing
+     */
+    shouldExcludeUrl(url) {
+        return this.config.excludeUrls.some(excludePattern => url.includes(excludePattern) || new RegExp(excludePattern).test(url));
+    }
+    /**
+     * Check if a method should be excluded from processing
+     */
+    shouldExcludeMethod(method) {
+        return this.config.excludeMethods.some(excludeMethod => excludeMethod.toLowerCase() === method.toLowerCase());
+    }
+    /**
+     * Get custom headers with dynamic values resolved
+     */
+    getCustomHeaders() {
+        const headers = {};
+        Object.entries(this.config.customHeaders).forEach(([key, value]) => {
+            headers[key] = typeof value === 'function' ? value() : value;
+        });
+        return headers;
+    }
+    /**
+     * Reset configuration to defaults
+     */
+    resetConfig() {
+        this.config = this.initializeConfig();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: CoreConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: CoreConfigService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.2", ngImport: i0, type: CoreConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+// Provider function for easy setup
+function provideCoreConfig(config = {}) {
+    return [
+        {
+            provide: CORE_CONFIG,
+            useValue: config,
+        },
+    ];
+}
+// Helper function to create configuration
+function createCoreConfig(overrides = {}) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...overrides,
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActiveRequestsTracker, AngularHttpAdapter, BaseHttpRepository, CORE_CONFIG, CoreConfigService, CorrelationService, GenericRepository, HTTP_CONTEXT_CONFIG, LoggingService, REPOSITORY_CONFIG, RepositoryFactory, SHOW_NOTIFICATIONS, SKIP_NOTIFICATION, SearchableGenericRepository, TOKEN_PROVIDER, UserRepository, apiInterceptor, createCoreConfig, createHttpContextConfig, customUrl, httpContextInterceptor, provideCoreConfig, provideHttpContext, skipContextHeaders, spinnerInterceptor, withCustomHeaders, withoutSpinner };
+//# sourceMappingURL=acontplus-ng-infrastructure.mjs.map