@aligent/microservice-util-lib 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aligent/microservice-util-lib",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "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.js

@@ -84,6 +84,17 @@ function getRetryDelayFn(config) {
 function shouldRetryOnStatus(status, retryOn) {
     return retryOn.includes(status);
 }
+/**
+ * Checks the response status and throw error if it's not "ok".
+ *
+ * @param {Response} response - The HTTP response object.
+ * @throws {Error} When the response is not an "ok" response.
+ */
+function throwErrorIfNotOkResponse(response) {
+    if (!response.ok) {
+        throw new Error(`${response.status}: ${response.statusText}`);
+    }
+}
 /**
  * This middleware implements retry logic with support for:
  * - Configurable number of retry attempts
@@ -147,7 +158,8 @@ 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(response.status, config.retryOn)) {
+                if (!shouldRetryOnStatus(context.response.status, config.retryOn)) {
+                    throwErrorIfNotOkResponse(context.response);
                     return context.response;
                 }
                 return await performRetries(normalisedConfig, context);
@@ -155,6 +167,7 @@ function retryMiddleware(config) {
             // 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;
             }
             return await performRetries(normalisedConfig, context);
@@ -201,18 +214,18 @@ async function performRetries(config, context) {
             continue;
         }
         if (config.retryOn && !shouldRetryOnStatus(response?.status, config.retryOn)) {
+            throwErrorIfNotOkResponse(response);
             return response;
         }
         const shouldRetry = await config.retryCondition(context, config.idempotentOnly);
         if (!shouldRetry) {
+            throwErrorIfNotOkResponse(response);
             return response;
         }
     } while (attempt <= maxRetries);
     if (!response) {
         throw context.error;
     }
-    if (!response.ok) {
-        throw new Error(`${response.status}: ${response.statusText}`);
-    }
+    throwErrorIfNotOkResponse(response);
     return response;
 }