@alba-cars/common-modules 1.10.3 → 1.10.4

package/dist/core/network/fetch-api.d.ts

@@ -4,5 +4,53 @@ interface ApiRequestOptions extends RequestInit {
     timeout?: number;
     signal?: AbortSignal;
 }
+type RequestInterceptor = (config: RequestInit & {
+    url: string;
+    options: ApiRequestOptions;
+}) => Promise<RequestInit & {
+    url: string;
+    options: ApiRequestOptions;
+}> | (RequestInit & {
+    url: string;
+    options: ApiRequestOptions;
+});
+type ResponseInterceptor = (response: Response, requestConfig: RequestInit & {
+    url: string;
+}) => Promise<Response> | Response;
+type ResponseErrorInterceptor = (error: any, requestConfig: RequestInit & {
+    url: string;
+}) => Promise<Response> | Response | Promise<any> | any;
+declare class InterceptorManager {
+    private requestInterceptors;
+    private responseInterceptors;
+    private responseErrorInterceptors;
+    addRequestInterceptor(interceptor: RequestInterceptor): number;
+    addResponseInterceptor(interceptor: ResponseInterceptor): number;
+    addResponseErrorInterceptor(interceptor: ResponseErrorInterceptor): number;
+    removeRequestInterceptor(index: number): void;
+    removeResponseInterceptor(index: number): void;
+    removeResponseErrorInterceptor(index: number): void;
+    clearRequestInterceptors(): void;
+    clearResponseInterceptors(): void;
+    clearResponseErrorInterceptors(): void;
+    clearAllInterceptors(): void;
+    applyRequestInterceptors(config: RequestInit & {
+        url: string;
+        options: ApiRequestOptions;
+    }): Promise<RequestInit & {
+        url: string;
+        options: ApiRequestOptions;
+    }>;
+    applyResponseInterceptors(response: Response, requestConfig: RequestInit & {
+        url: string;
+    }): Promise<Response>;
+    applyResponseErrorInterceptors(error: any, requestConfig: RequestInit & {
+        url: string;
+    }): Promise<any>;
+    retryRequest<T>(config: RequestInit & {
+        url: string;
+    }): Promise<T>;
+}
+export declare const interceptors: InterceptorManager;
 export declare function apiRequest<T>(endpoint: string, options?: ApiRequestOptions): Promise<T>;
 export {};

package/dist/core/network/fetch-api.js

@@ -3,12 +3,115 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiRequest = void 0;
+exports.apiRequest = exports.interceptors = void 0;
 const qs_1 = __importDefault(require("qs"));
 const enums_1 = require("../enums");
 const utils_1 = require("../utils");
 const BASE_URL = process.env.NEXT_PUBLIC_API_URL;
 const DEFAULT_TIMEOUT = (0, utils_1.timeAsMilliseconds)({ seconds: 30 });
+// Interceptor manager
+class InterceptorManager {
+    constructor() {
+        this.requestInterceptors = [];
+        this.responseInterceptors = [];
+        this.responseErrorInterceptors = [];
+    }
+    addRequestInterceptor(interceptor) {
+        return this.requestInterceptors.push(interceptor) - 1;
+    }
+    addResponseInterceptor(interceptor) {
+        return this.responseInterceptors.push(interceptor) - 1;
+    }
+    addResponseErrorInterceptor(interceptor) {
+        return this.responseErrorInterceptors.push(interceptor) - 1;
+    }
+    removeRequestInterceptor(index) {
+        if (index >= 0) {
+            this.requestInterceptors.splice(index, 1);
+        }
+    }
+    removeResponseInterceptor(index) {
+        if (index >= 0) {
+            this.responseInterceptors.splice(index, 1);
+        }
+    }
+    removeResponseErrorInterceptor(index) {
+        if (index >= 0) {
+            this.responseErrorInterceptors.splice(index, 1);
+        }
+    }
+    clearRequestInterceptors() {
+        this.requestInterceptors = [];
+    }
+    clearResponseInterceptors() {
+        this.responseInterceptors = [];
+    }
+    clearResponseErrorInterceptors() {
+        this.responseErrorInterceptors = [];
+    }
+    clearAllInterceptors() {
+        this.clearRequestInterceptors();
+        this.clearResponseInterceptors();
+        this.clearResponseErrorInterceptors();
+    }
+    async applyRequestInterceptors(config) {
+        let modifiedConfig = { ...config };
+        for (const interceptor of this.requestInterceptors) {
+            modifiedConfig = await interceptor(modifiedConfig);
+        }
+        return modifiedConfig;
+    }
+    async applyResponseInterceptors(response, requestConfig) {
+        let modifiedResponse = response;
+        for (const interceptor of this.responseInterceptors) {
+            modifiedResponse = await interceptor(modifiedResponse, requestConfig);
+        }
+        return modifiedResponse;
+    }
+    async applyResponseErrorInterceptors(error, requestConfig) {
+        let modifiedError = error;
+        for (const interceptor of this.responseErrorInterceptors) {
+            try {
+                // If an interceptor resolves the error, return the resolved value
+                const result = await interceptor(modifiedError, requestConfig);
+                if (result instanceof Response) {
+                    return result;
+                }
+                modifiedError = result;
+            }
+            catch (newError) {
+                // If an interceptor rejects, continue with the new error
+                modifiedError = newError;
+            }
+        }
+        // If no interceptor handled the error, throw it
+        throw modifiedError;
+    }
+    async retryRequest(config) {
+        try {
+            // Make a new request with the updated config
+            const response = await fetch(config.url, config);
+            // Apply response interceptors
+            const interceptedResponse = await this.applyResponseInterceptors(response, config);
+            const contentType = interceptedResponse.headers.get("content-type");
+            const responseData = (contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json"))
+                ? await interceptedResponse.json()
+                : await interceptedResponse.text();
+            if (interceptedResponse.ok) {
+                return responseData;
+            }
+            // Handle errors
+            const apiError = createApiError(interceptedResponse.status, responseData);
+            throw apiError;
+        }
+        catch (error) {
+            // Apply response error interceptors
+            return this.applyResponseErrorInterceptors(error, config);
+        }
+    }
+}
+// Create the interceptor manager instance
+exports.interceptors = new InterceptorManager();
 const buildUrl = (endpoint, query) => {
     let url = `${BASE_URL}${endpoint}`;
     if (query && Object.keys(query).length > 0) {
@@ -28,8 +131,8 @@ async function apiRequest(endpoint, options = {}) {
     // If timeout is specified, create a timeout abort controller
     if (options.timeout && controller) {
         timeoutId = setTimeout(() => {
-            controller.abort('Request timeout');
-        }, options.timeout);
+            controller.abort("Request timeout");
+        }, options.timeout || DEFAULT_TIMEOUT);
     }
     // Use provided signal or timeout controller's signal
     const signal = options.signal || (controller === null || controller === void 0 ? void 0 : controller.signal);
@@ -51,20 +154,46 @@ async function apiRequest(endpoint, options = {}) {
     catch (error) {
         return Promise.reject(error);
     }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
 }
 exports.apiRequest = apiRequest;
 async function makeRequest(endpoint, config, options = {}) {
     const url = buildUrl(endpoint, options.query);
-    const response = await fetch(url, config);
-    const contentType = response.headers.get("content-type");
-    const responseData = (contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json"))
-        ? await response.json()
-        : await response.text();
-    if (response.ok) {
-        return responseData;
-    }
-    // Handle other errors
-    throw createApiError(response.status, responseData);
+    // Apply request interceptors
+    let requestConfig = await exports.interceptors.applyRequestInterceptors({
+        ...config,
+        url,
+        options,
+    });
+    // Extract the URL after interceptors may have modified it
+    const interceptedUrl = requestConfig.url;
+    try {
+        // Make the actual request
+        const response = await fetch(interceptedUrl, requestConfig);
+        // Apply response interceptors
+        const interceptedResponse = await exports.interceptors.applyResponseInterceptors(response, { ...requestConfig, url: interceptedUrl });
+        const contentType = interceptedResponse.headers.get("content-type");
+        const responseData = (contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json"))
+            ? await interceptedResponse.json()
+            : await interceptedResponse.text();
+        if (interceptedResponse.ok) {
+            return responseData;
+        }
+        // Handle other errors
+        const apiError = createApiError(interceptedResponse.status, responseData);
+        throw apiError;
+    }
+    catch (error) {
+        // Apply response error interceptors
+        return exports.interceptors.applyResponseErrorInterceptors(error, {
+            ...requestConfig,
+            url: interceptedUrl,
+        });
+    }
 }
 function createApiError(status, responseData) {
     const error = new Error(typeof responseData === "object"

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.10.3",
+  "version": "1.10.4",
   "description": "A package containing DTOs, validation classes and common modules and interfaces for Alba Cars",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",