@hmcts/opal-frontend-common 0.0.89 → 0.0.90

package/fesm2022/hmcts-opal-frontend-common-interceptors-http-retry-constants.mjs

@@ -0,0 +1,16 @@
+const MAX_HTTP_RETRY_BACKOFF_MULTIPLIER = 10;
+
+const MAX_HTTP_RETRY_COUNT = 2;
+
+const MAX_HTTP_RETRY_DELAY_MS = 30000;
+
+const HTTP_NON_RETRYABLE_STATUS_CODES = Object.freeze([400, 401, 403, 404, 409, 422]);
+
+const HTTP_RETRYABLE_STATUS_CODES = Object.freeze([0, 408, 502, 503, 504]);
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { HTTP_NON_RETRYABLE_STATUS_CODES, HTTP_RETRYABLE_STATUS_CODES, MAX_HTTP_RETRY_BACKOFF_MULTIPLIER, MAX_HTTP_RETRY_COUNT, MAX_HTTP_RETRY_DELAY_MS };
+//# sourceMappingURL=hmcts-opal-frontend-common-interceptors-http-retry-constants.mjs.map

package/fesm2022/hmcts-opal-frontend-common-interceptors-http-retry-interfaces.mjs

@@ -0,0 +1,4 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=hmcts-opal-frontend-common-interceptors-http-retry-interfaces.mjs.map

package/fesm2022/hmcts-opal-frontend-common-interceptors-http-retry.mjs

@@ -0,0 +1,162 @@
+import { retry, throwError, timer, of } from 'rxjs';
+import { HttpContextToken, HttpErrorResponse, HttpContext } from '@angular/common/http';
+
+/**
+ * Stores per-request HTTP retry policy options in an Angular HTTP context.
+ */
+const HTTP_RETRY_POLICY = new HttpContextToken(() => ({}));
+
+const MAX_HTTP_RETRY_BACKOFF_MULTIPLIER = 10;
+
+const HTTP_NON_RETRYABLE_STATUS_CODES = Object.freeze([400, 401, 403, 404, 409, 422]);
+
+const HTTP_RETRYABLE_STATUS_CODES = Object.freeze([0, 408, 502, 503, 504]);
+
+const MAX_HTTP_RETRY_COUNT = 2;
+
+const MAX_HTTP_RETRY_DELAY_MS = 30000;
+
+/**
+ * Returns whether the request is eligible for retry under the supplied policy.
+ */
+function canRetryRequest(req, policy) {
+    return policy.retryCount > 0 && isGetRequest(req);
+}
+/**
+ * Calculates the delay before the next retry attempt, including backoff and maximum delay bounds.
+ */
+function getRetryDelayMs(policy, retryAttempt) {
+    const retryDelayMs = policy.delayMs * Math.pow(policy.backoffMultiplier, Math.max(retryAttempt - 1, 0));
+    return Math.min(Math.round(retryDelayMs), policy.maxDelayMs);
+}
+/**
+ * Returns whether the error status is retryable and has not been explicitly marked non-retriable.
+ */
+function isRetryableError(error, policy) {
+    if (isApiNonRetriableError(error)) {
+        return false;
+    }
+    const statusCode = getStatusCode(error);
+    if (statusCode === undefined || HTTP_NON_RETRYABLE_STATUS_CODES.includes(statusCode)) {
+        return false;
+    }
+    return policy.retryableStatusCodes.includes(statusCode);
+}
+/**
+ * Normalizes partial retry options into a bounded retry policy with default values.
+ */
+function normalizeHttpRetryPolicy(policy = {}) {
+    const delayMs = getBoundedInteger(policy.delayMs, 0, MAX_HTTP_RETRY_DELAY_MS);
+    return {
+        retryCount: getBoundedInteger(policy.retryCount, 0, MAX_HTTP_RETRY_COUNT),
+        delayMs,
+        backoffMultiplier: getBoundedNumber(policy.backoffMultiplier, 1, 1, MAX_HTTP_RETRY_BACKOFF_MULTIPLIER),
+        maxDelayMs: getBoundedInteger(policy.maxDelayMs, delayMs, MAX_HTTP_RETRY_DELAY_MS),
+        retryableStatusCodes: getRetryableStatusCodes(policy.retryableStatusCodes),
+    };
+}
+/**
+ * Returns whether the request uses the GET method.
+ */
+function isGetRequest(req) {
+    return req.method.toUpperCase() === 'GET';
+}
+/**
+ * Extracts an HTTP status code from an Angular error response or compatible error shape.
+ */
+function getStatusCode(error) {
+    if (!(error instanceof HttpErrorResponse) && (typeof error !== 'object' || error === null)) {
+        return undefined;
+    }
+    if (typeof error === 'object' && error !== null && 'status' in error) {
+        const statusError = error;
+        if (typeof statusError.status === 'number') {
+            return statusError.status;
+        }
+    }
+    if (typeof error === 'object' && error !== null && 'error' in error) {
+        const nestedError = error;
+        if (typeof nestedError.error?.status === 'number') {
+            return nestedError.error.status;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns whether the API response body explicitly marks the error as non-retriable.
+ */
+function isApiNonRetriableError(error) {
+    if (typeof error !== 'object' || error === null || !('error' in error)) {
+        return false;
+    }
+    const responseError = error.error;
+    return typeof responseError === 'object' && responseError !== null && 'retriable' in responseError
+        ? responseError.retriable === false
+        : false;
+}
+/**
+ * Returns a finite integer clamped between zero and the supplied maximum.
+ */
+function getBoundedInteger(value, fallback, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(Math.max(Math.floor(value), 0), max);
+}
+/**
+ * Returns a finite number clamped between the supplied minimum and maximum.
+ */
+function getBoundedNumber(value, fallback, min, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * Filters and de-duplicates configured retryable status codes against the supported retryable list.
+ */
+function getRetryableStatusCodes(statusCodes) {
+    const codes = statusCodes ?? HTTP_RETRYABLE_STATUS_CODES;
+    return [...new Set(codes.filter((statusCode) => HTTP_RETRYABLE_STATUS_CODES.includes(statusCode)))];
+}
+
+/**
+ * Retries opted-in GET requests when they fail with configured transient HTTP errors.
+ */
+const httpRetryInterceptor = (req, next) => {
+    const retryPolicy = normalizeHttpRetryPolicy(req.context.get(HTTP_RETRY_POLICY));
+    if (!canRetryRequest(req, retryPolicy)) {
+        return next(req);
+    }
+    return next(req).pipe(retry({
+        count: retryPolicy.retryCount,
+        delay: (error, retryAttempt) => {
+            if (!isRetryableError(error, retryPolicy)) {
+                return throwError(() => error);
+            }
+            const delayMs = getRetryDelayMs(retryPolicy, retryAttempt);
+            return delayMs > 0 ? timer(delayMs) : of(0);
+        },
+    }));
+};
+
+/**
+ * Enables HTTP retry for a request by adding the normalized retry policy to its context.
+ */
+function withHttpRetry(policy, context = new HttpContext()) {
+    return context.set(HTTP_RETRY_POLICY, normalizeHttpRetryPolicy(policy));
+}
+
+/**
+ * Disables HTTP retry for a request by setting a zero retry count on its context.
+ */
+function withoutHttpRetry(context = new HttpContext()) {
+    return context.set(HTTP_RETRY_POLICY, { retryCount: 0 });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { httpRetryInterceptor, withHttpRetry, withoutHttpRetry };
+//# sourceMappingURL=hmcts-opal-frontend-common-interceptors-http-retry.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmcts/opal-frontend-common",
-  "version": "0.0.89",
+  "version": "0.0.90",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -671,6 +671,21 @@
       "types": "./types/hmcts-opal-frontend-common-interceptors-http-error-interfaces.d.ts",
       "default": "./fesm2022/hmcts-opal-frontend-common-interceptors-http-error-interfaces.mjs"
     },
+    "./interceptors/http-retry": {
+      "import": "./fesm2022/hmcts-opal-frontend-common-interceptors-http-retry.mjs",
+      "types": "./types/hmcts-opal-frontend-common-interceptors-http-retry.d.ts",
+      "default": "./fesm2022/hmcts-opal-frontend-common-interceptors-http-retry.mjs"
+    },
+    "./interceptors/http-retry/constants": {
+      "import": "./fesm2022/hmcts-opal-frontend-common-interceptors-http-retry-constants.mjs",
+      "types": "./types/hmcts-opal-frontend-common-interceptors-http-retry-constants.d.ts",
+      "default": "./fesm2022/hmcts-opal-frontend-common-interceptors-http-retry-constants.mjs"
+    },
+    "./interceptors/http-retry/interfaces": {
+      "import": "./fesm2022/hmcts-opal-frontend-common-interceptors-http-retry-interfaces.mjs",
+      "types": "./types/hmcts-opal-frontend-common-interceptors-http-retry-interfaces.d.ts",
+      "default": "./fesm2022/hmcts-opal-frontend-common-interceptors-http-retry-interfaces.mjs"
+    },
     "./pages/dashboard-page": {
       "import": "./fesm2022/hmcts-opal-frontend-common-pages-dashboard-page.mjs",
       "types": "./types/hmcts-opal-frontend-common-pages-dashboard-page.d.ts",

package/types/hmcts-opal-frontend-common-interceptors-http-retry-constants.d.ts

@@ -0,0 +1,11 @@
+declare const MAX_HTTP_RETRY_BACKOFF_MULTIPLIER = 10;
+
+declare const MAX_HTTP_RETRY_COUNT = 2;
+
+declare const MAX_HTTP_RETRY_DELAY_MS = 30000;
+
+declare const HTTP_NON_RETRYABLE_STATUS_CODES: readonly number[];
+
+declare const HTTP_RETRYABLE_STATUS_CODES: readonly number[];
+
+export { HTTP_NON_RETRYABLE_STATUS_CODES, HTTP_RETRYABLE_STATUS_CODES, MAX_HTTP_RETRY_BACKOFF_MULTIPLIER, MAX_HTTP_RETRY_COUNT, MAX_HTTP_RETRY_DELAY_MS };

package/types/hmcts-opal-frontend-common-interceptors-http-retry-interfaces.d.ts

@@ -0,0 +1,10 @@
+interface IHttpRetryPolicy {
+    retryCount: number;
+    delayMs: number;
+    backoffMultiplier: number;
+    maxDelayMs: number;
+    retryableStatusCodes: readonly number[];
+}
+type IHttpRetryPolicyOptions = Partial<IHttpRetryPolicy>;
+
+export type { IHttpRetryPolicy, IHttpRetryPolicyOptions };

package/types/hmcts-opal-frontend-common-interceptors-http-retry.d.ts

@@ -0,0 +1,27 @@
+import { HttpInterceptorFn, HttpContext } from '@angular/common/http';
+
+/**
+ * Retries opted-in GET requests when they fail with configured transient HTTP errors.
+ */
+declare const httpRetryInterceptor: HttpInterceptorFn;
+
+interface IHttpRetryPolicy {
+    retryCount: number;
+    delayMs: number;
+    backoffMultiplier: number;
+    maxDelayMs: number;
+    retryableStatusCodes: readonly number[];
+}
+type IHttpRetryPolicyOptions = Partial<IHttpRetryPolicy>;
+
+/**
+ * Enables HTTP retry for a request by adding the normalized retry policy to its context.
+ */
+declare function withHttpRetry(policy: IHttpRetryPolicyOptions, context?: HttpContext): HttpContext;
+
+/**
+ * Disables HTTP retry for a request by setting a zero retry count on its context.
+ */
+declare function withoutHttpRetry(context?: HttpContext): HttpContext;
+
+export { httpRetryInterceptor, withHttpRetry, withoutHttpRetry };