@aligent/microservice-util-lib 1.2.2 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aligent/microservice-util-lib",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "description": "A set of utility functions for Aligent Microservices",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/openapi-fetch-middlewares/retry.d.ts

@@ -1,5 +1,6 @@
 import type { Middleware } from 'openapi-fetch';
 import type { RetryConfig, RetryContext, RetryDelayFn } from './types/retry';
+import { HttpResponseError, isHttpResponseError } from './utils/http-response-error';
 /**
  * This middleware implements retry logic with support for:
  * - Configurable number of retry attempts
@@ -50,5 +51,5 @@ import type { RetryConfig, RetryContext, RetryDelayFn } from './types/retry';
  * });
  */
 declare function retryMiddleware(config?: RetryConfig): Middleware;
-export { retryMiddleware };
+export { HttpResponseError, isHttpResponseError, retryMiddleware };
 export type { RetryConfig, RetryContext, RetryDelayFn };

package/src/openapi-fetch-middlewares/retry.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpResponseError = exports.HttpResponseError = void 0;
 exports.retryMiddleware = retryMiddleware;
+const http_response_error_1 = require("./utils/http-response-error");
+Object.defineProperty(exports, "HttpResponseError", { enumerable: true, get: function () { return http_response_error_1.HttpResponseError; } });
+Object.defineProperty(exports, "isHttpResponseError", { enumerable: true, get: function () { return http_response_error_1.isHttpResponseError; } });
 const is_network_error_1 = require("./utils/is-network-error");
 const IDEMPOTENT_HTTP_METHODS = ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE'];
 /**
@@ -85,14 +89,15 @@ function shouldRetryOnStatus(status, retryOn) {
     return retryOn.includes(status);
 }
 /**
- * Checks the response status and throw error if it's not "ok".
+ * Checks the response status and throws HttpResponseError if it's not "ok".
  *
  * @param {Response} response - The HTTP response object.
- * @throws {Error} When the response is not an "ok" response.
+ * @param {Request} request - The HTTP request object.
+ * @throws {HttpResponseError} When the response is not an "ok" response.
  */
-function throwErrorIfNotOkResponse(response) {
+function throwErrorIfNotOkResponse(response, request) {
     if (!response.ok) {
-        throw new Error(`${response.status}: ${response.statusText}`);
+        throw new http_response_error_1.HttpResponseError(response, request);
     }
 }
 /**
@@ -158,17 +163,17 @@ function retryMiddleware(config) {
             const context = { attempt: 1, request, response, error: null };
             // If retryOn is specified, only use that list
             if (config?.retryOn && config.retryOn.length > 0) {
-                if (!shouldRetryOnStatus(context.response.status, config.retryOn)) {
-                    throwErrorIfNotOkResponse(context.response);
-                    return context.response;
+                if (!shouldRetryOnStatus(response.status, config.retryOn)) {
+                    throwErrorIfNotOkResponse(response, request);
+                    return response;
                 }
                 return await performRetries(normalisedConfig, context);
             }
             // Otherwise, check if we should retry based on retry condition
             const shouldRetry = await normalisedConfig.retryCondition(context, normalisedConfig.idempotentOnly);
             if (!shouldRetry) {
-                throwErrorIfNotOkResponse(context.response);
-                return context.response;
+                throwErrorIfNotOkResponse(response, request);
+                return response;
             }
             return await performRetries(normalisedConfig, context);
         },
@@ -199,8 +204,10 @@ async function performRetries(config, context) {
             await config.onRetry({ ...context, attempt, response });
         }
         try {
-            const signal = config.shouldResetTimeout ? undefined : context.request.signal;
-            response = await config.fetch(new Request(context.request, { signal }));
+            const request = config.shouldResetTimeout
+                ? new Request(context.request)
+                : new Request(context.request, { signal: context.request.signal });
+            response = await config.fetch(request);
             context = { ...context, attempt: attempt + 1, response, error: null };
             attempt++;
         }
@@ -214,18 +221,18 @@ async function performRetries(config, context) {
             continue;
         }
         if (config.retryOn && !shouldRetryOnStatus(response?.status, config.retryOn)) {
-            throwErrorIfNotOkResponse(response);
+            throwErrorIfNotOkResponse(response, context.request);
             return response;
         }
         const shouldRetry = await config.retryCondition(context, config.idempotentOnly);
         if (!shouldRetry) {
-            throwErrorIfNotOkResponse(response);
+            throwErrorIfNotOkResponse(response, context.request);
             return response;
         }
     } while (attempt <= maxRetries);
     if (!response) {
         throw context.error;
     }
-    throwErrorIfNotOkResponse(response);
+    throwErrorIfNotOkResponse(response, context.request);
     return response;
 }

package/src/openapi-fetch-middlewares/utils/http-response-error.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Custom error class for HTTP response errors, similar to Axios Error.
+ * Provides detailed information about the failed request and response.
+ */
+export declare class HttpResponseError extends Error {
+    readonly name = "HttpResponseError";
+    readonly status: number;
+    readonly statusText: string;
+    readonly response: Response;
+    readonly request: Request;
+    readonly isHttpResponseError = true;
+    constructor(response: Response, request: Request);
+    /**
+     * Returns a JSON representation of the error for logging/debugging.
+     */
+    toJson(): {
+        name: string;
+        message: string;
+        status: number;
+        statusText: string;
+        method: string;
+        url: string;
+    };
+}
+/**
+ * Type guard to check if an error is an HttpResponseError.
+ * Useful for narrowing error types in catch blocks.
+ *
+ * @param {unknown} error - The error to check.
+ * @returns {boolean} True if the error is an HttpResponseError.
+ *
+ * @example
+ * try {
+ *     await fetchData();
+ * } catch (error) {
+ *     if (isHttpResponseError(error)) {
+ *         console.log(`Request failed with status ${error.status}`);
+ *         console.log(`URL: ${error.request.url}`);
+ *     }
+ * }
+ */
+export declare function isHttpResponseError(error: unknown): error is HttpResponseError;

package/src/openapi-fetch-middlewares/utils/http-response-error.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponseError = void 0;
+exports.isHttpResponseError = isHttpResponseError;
+/**
+ * Custom error class for HTTP response errors, similar to Axios Error.
+ * Provides detailed information about the failed request and response.
+ */
+class HttpResponseError extends Error {
+    name = 'HttpResponseError';
+    status;
+    statusText;
+    response;
+    request;
+    isHttpResponseError = true;
+    constructor(response, request) {
+        super(`${response.status}: ${response.statusText}`);
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.response = response;
+        this.request = request;
+        // Maintains proper stack trace for where error was thrown (V8 engines)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, HttpResponseError);
+        }
+    }
+    /**
+     * Returns a JSON representation of the error for logging/debugging.
+     */
+    toJson() {
+        return {
+            name: this.name,
+            message: this.message,
+            status: this.status,
+            statusText: this.statusText,
+            method: this.request.method,
+            url: this.request.url,
+        };
+    }
+}
+exports.HttpResponseError = HttpResponseError;
+/**
+ * Type guard to check if an error is an HttpResponseError.
+ * Useful for narrowing error types in catch blocks.
+ *
+ * @param {unknown} error - The error to check.
+ * @returns {boolean} True if the error is an HttpResponseError.
+ *
+ * @example
+ * try {
+ *     await fetchData();
+ * } catch (error) {
+ *     if (isHttpResponseError(error)) {
+ *         console.log(`Request failed with status ${error.status}`);
+ *         console.log(`URL: ${error.request.url}`);
+ *     }
+ * }
+ */
+function isHttpResponseError(error) {
+    return (error instanceof HttpResponseError ||
+        (typeof error === 'object' &&
+            error !== null &&
+            'isHttpResponseError' in error &&
+            error.isHttpResponseError === true));
+}

package/src/remap/remap.d.ts

@@ -33,7 +33,11 @@ type GetKeyType<Key extends string, O extends {
  * Given an ObjectMap, return a new ObjectMap with the first index of each
  * tuple replaced with the value of the second index
  */
-type OverrideIndex<M extends ObjectMap[number], V extends string> = readonly [M[0], V, M[2]];
+type OverrideIndex<M extends ObjectMap[number], V extends string> = M extends readonly [
+    unknown,
+    unknown,
+    infer T
+] ? readonly [M[0], V, T] : readonly [M[0], V];
 /**
  * Given a key and a base object, return the type of the property referencable
  * by the key on the base object
@@ -48,7 +52,7 @@ type OverrideIndex<M extends ObjectMap[number], V extends string> = readonly [M[
  */
 type ConstructTypeFromPropertiesInternal<M extends ObjectMap[number], O extends {
     [key: string]: any;
-}> = M[1] extends `${infer P}.${infer Rest}` ? {
+}> = M[1] extends `${infer P extends string}.${infer Rest extends string}` ? {
     [key in P]: ConstructTypeFromPropertiesInternal<OverrideIndex<M, Rest>, O>;
 } : {
     [key in M[1]]: GetKeyType<M[0], O, M>;