@aligent/microservice-util-lib 1.2.1 → 1.3.0

package/package.json

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

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

@@ -64,27 +64,18 @@ function combineUrlAndPathParams(url, pathParams) {
  *
  * @param {string} baseURL - The base URL.
  * @param {string} url - The URL to process.
- * @returns {{ baseUri: string, searchParams: URLSearchParams | null }} The processed URL and its search parameters.
+ * @returns The processed URL.
  */
-function handleOAuthUrl(baseURL, url) {
+function getOAuthUrl(baseURL, url) {
     const oauthUrl = new URL(!baseURL || isAbsoluteURL(url) ? url : combineURLs(baseURL, url));
-    let searchParams = null;
-    // Query parameters are hashed as part of params rather than as part of the URL
-    if (oauthUrl.search) {
-        searchParams = new URLSearchParams(oauthUrl.search);
-        oauthUrl.search = '';
-    }
-    // Do not include hash in signature
-    oauthUrl.hash = '';
+    oauthUrl.search = ''; // Query parameters are hashed as part of params rather than as part of the URL
+    oauthUrl.hash = ''; // Do not include hash in signature
     // Remove port if it is the default for that protocol
     if ((oauthUrl.protocol === 'https:' && oauthUrl.port === '443') ||
         (oauthUrl.protocol === 'http:' && oauthUrl.port === '80')) {
         oauthUrl.port = '';
     }
-    return {
-        baseUri: oauthUrl.toString(),
-        searchParams,
-    };
+    return oauthUrl.toString();
 }
 /**
  * Adds a parameter to the list of parameters to sign.
@@ -174,10 +165,6 @@ async function generateOauthParams(request, options, params, config) {
     if (params.query) {
         addParamsToSign(paramsToSign, params.query);
     }
-    const { baseUri, searchParams } = handleOAuthUrl(options.baseUrl, url);
-    if (searchParams) {
-        addParamsToSign(paramsToSign, searchParams);
-    }
     const body = await request.text();
     // If user submit a form, then include form parameters in the
     // signature as parameters rather than the body hash
@@ -195,7 +182,8 @@ async function generateOauthParams(request, options, params, config) {
             addParamToSign(paramsToSign, 'oauth_body_hash', bodyHash);
         }
     }
-    oauthParams.oauth_signature = (0, oauth_sign_1.sign)(algorithm, method, baseUri, paramsToSign, consumerSecret, tokenSecret);
+    const oauthUrl = getOAuthUrl(options.baseUrl, url);
+    oauthParams.oauth_signature = (0, oauth_sign_1.sign)(algorithm, method, oauthUrl, paramsToSign, consumerSecret, tokenSecret);
     // realm should not be included in the signature calculation
     // but is optional in the OAuth 1.0 Authorization header
     // so we need to add it after signing the request

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);
         },
@@ -214,18 +219,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));
+}