nurseitaly-components 0.0.13 → 0.0.14

package/dist/configs/api/apiHandledError.d.ts

@@ -0,0 +1,15 @@
+import type { AxiosError } from 'axios';
+export type ApiErrorHandled = AxiosError & {
+    apiErrorHandled?: boolean;
+    /** @deprecated use apiErrorHandled */
+    authErrorHandled?: boolean;
+};
+export declare function isServerError(status: number | undefined): boolean;
+export declare function markApiErrorHandled(error: AxiosError): void;
+export declare function isHandledApiError(reason: unknown): boolean;
+/** @deprecated use markApiErrorHandled */
+export declare const markAuthErrorHandled: typeof markApiErrorHandled;
+/** @deprecated use isHandledApiError */
+export declare const isHandledAuthError: typeof isHandledApiError;
+/** @deprecated use ApiErrorHandled */
+export type AuthErrorHandled = ApiErrorHandled;

package/dist/configs/api/apiHandledError.js

@@ -0,0 +1,21 @@
+export function isServerError(status) {
+    return status !== undefined && status >= 500 && status < 600;
+}
+export function markApiErrorHandled(error) {
+    error.apiErrorHandled = true;
+}
+export function isHandledApiError(reason) {
+    if (!reason || typeof reason !== 'object')
+        return false;
+    const error = reason;
+    if (error.apiErrorHandled || error.authErrorHandled)
+        return true;
+    const status = error.response?.status;
+    if (!error.config || status === undefined)
+        return false;
+    return isServerError(status);
+}
+/** @deprecated use markApiErrorHandled */
+export const markAuthErrorHandled = markApiErrorHandled;
+/** @deprecated use isHandledApiError */
+export const isHandledAuthError = isHandledApiError;

package/dist/configs/api/applyAuthErrorHandling.d.ts

@@ -0,0 +1,13 @@
+import type { AxiosInstance } from 'axios';
+export type AuthErrorHandling = 'toast' | 'redirect' | 'none';
+export type ApplyAuthErrorHandlingOptions = {
+    authErrorHandling?: AuthErrorHandling;
+    authStatuses?: Array<401 | 403>;
+    redirect?: {
+        on401?: string;
+        on403?: string;
+    };
+    onBeforeRedirect?: (status: 401 | 403) => void;
+    skipAuthHandlingInStorybook?: boolean;
+};
+export declare function applyAuthErrorHandling(api: AxiosInstance, options: ApplyAuthErrorHandlingOptions): AxiosInstance;

package/dist/configs/api/applyAuthErrorHandling.js

@@ -0,0 +1,70 @@
+import { markApiErrorHandled } from './apiHandledError';
+import CookieStorage from '../CookieStorage';
+import { messageAction, loggedAction } from '../sessionTypes';
+import { getCommonDispatch } from '../commonDispatch';
+import { getErrorMessageValue } from '../useMessageUtils';
+import i18n from 'i18next';
+function isStorybook() {
+    return (typeof window !== 'undefined' &&
+        (window.location.port === '6006' ||
+            Boolean(window.__STORYBOOK__)));
+}
+function defaultRedirectUrls() {
+    const publicUrl = import.meta.env.VITE_APP_PUBLIC_URL;
+    return {
+        on401: import.meta.env.VITE_APP_AUTH_URL,
+        on403: import.meta.env.VITE_APP_UNAUTHORIZED_URL ??
+            (publicUrl ? `${publicUrl}/unauthorized` : undefined),
+    };
+}
+function clearAuthStorage() {
+    CookieStorage.removeJwtToken();
+    sessionStorage.clear();
+    localStorage.clear();
+}
+function handleToastAuthError(status) {
+    if (status === 401) {
+        clearAuthStorage();
+        getCommonDispatch()?.(loggedAction(undefined));
+    }
+    const value = getErrorMessageValue({
+        err: { response: { status } },
+        t: i18n.t.bind(i18n),
+    });
+    getCommonDispatch()?.(messageAction({ value, type: 'error' }));
+}
+function handleRedirectAuthError(status, redirect, onBeforeRedirect, skipAuthHandlingInStorybook = true) {
+    if (skipAuthHandlingInStorybook && isStorybook())
+        return;
+    onBeforeRedirect?.(status);
+    if (status === 401) {
+        clearAuthStorage();
+        if (redirect.on401)
+            window.location.replace(redirect.on401);
+        return;
+    }
+    if (redirect.on403)
+        window.location.href = redirect.on403;
+}
+export function applyAuthErrorHandling(api, options) {
+    const { authErrorHandling = 'none', authStatuses = [401, 403], redirect: redirectOverrides, onBeforeRedirect, skipAuthHandlingInStorybook = true, } = options;
+    if (authErrorHandling === 'none')
+        return api;
+    const redirect = { ...defaultRedirectUrls(), ...redirectOverrides };
+    api.interceptors.response.use((response) => response, async (error) => {
+        const status = error.response?.status;
+        if (status === 401 || status === 403) {
+            if (!authStatuses.includes(status))
+                return Promise.reject(error);
+            if (authErrorHandling === 'toast') {
+                handleToastAuthError(status);
+            }
+            else if (authErrorHandling === 'redirect') {
+                handleRedirectAuthError(status, redirect, onBeforeRedirect, skipAuthHandlingInStorybook);
+            }
+            markApiErrorHandled(error);
+        }
+        return Promise.reject(error);
+    });
+    return api;
+}

package/dist/configs/api/createApiClient.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance, InternalAxiosRequestConfig } from 'axios';
+export type ServerErrorHandling = 'toast' | 'none';
+export type CreateApiClientOptions = {
+    baseURL: string;
+    attachJwt?: boolean;
+    serverErrorHandling?: ServerErrorHandling;
+    augmentRequest?: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig;
+};
+export declare function createApiClient(options: CreateApiClientOptions): AxiosInstance;

package/dist/configs/api/createApiClient.js

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import CookieStorage from '../CookieStorage';
+import { dispatchServerApiError } from './dispatchApiError';
+import { isServerError, markApiErrorHandled } from './apiHandledError';
+const DEFAULT_HEADERS = {
+    'Cache-Control': 'no-cache, no-store, must-revalidate',
+    Pragma: 'no-cache',
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+};
+function toHandledServerErrorResponse(error) {
+    return {
+        data: null,
+        status: error.response?.status ?? 500,
+        statusText: error.response?.statusText ?? 'Internal Server Error',
+        headers: error.response?.headers ?? {},
+        config: error.config,
+    };
+}
+export function createApiClient(options) {
+    const { baseURL, attachJwt = true, serverErrorHandling = 'toast', augmentRequest, } = options;
+    const api = axios.create({
+        headers: DEFAULT_HEADERS,
+        baseURL,
+    });
+    api.interceptors.response.use((response) => response, async (error) => {
+        const status = error.response?.status;
+        if (isServerError(status) && serverErrorHandling === 'toast') {
+            dispatchServerApiError({ err: error });
+            markApiErrorHandled(error);
+            return toHandledServerErrorResponse(error);
+        }
+        if (error.status === null) {
+            console.log(JSON.stringify(error));
+        }
+        return Promise.reject(error);
+    });
+    api.interceptors.request.use((config) => {
+        if (!config?.headers) {
+            throw new Error('no header available');
+        }
+        if (attachJwt) {
+            const token = CookieStorage.getJwtToken();
+            if (token) {
+                config.headers.Authorization = `Bearer ${token}`;
+            }
+        }
+        return augmentRequest ? augmentRequest(config) : config;
+    });
+    return api;
+}

package/dist/configs/api/dispatchApiError.d.ts

@@ -0,0 +1,10 @@
+import type { TFunction } from 'i18next';
+export declare function dispatchApiError({ err, t, key, }: {
+    err: unknown;
+    t?: TFunction;
+    key?: string;
+}): void;
+export declare function dispatchServerApiError({ err, t, }: {
+    err: unknown;
+    t?: TFunction;
+}): void;

package/dist/configs/api/dispatchApiError.js

@@ -0,0 +1,16 @@
+import i18n from 'i18next';
+import { getErrorMessageValue } from '../useMessageUtils';
+import { messageAction } from '../sessionTypes';
+import { getCommonDispatch } from '../commonDispatch';
+export function dispatchApiError({ err, t, key, }) {
+    const translate = t ?? i18n.t.bind(i18n);
+    const value = getErrorMessageValue({ err, t: translate, key });
+    getCommonDispatch()?.(messageAction({ value, type: 'error' }));
+}
+export function dispatchServerApiError({ err, t, }) {
+    dispatchApiError({
+        err,
+        t,
+        key: 'common',
+    });
+}

package/dist/configs/api/index.d.ts

@@ -0,0 +1,16 @@
+export declare const platformApi: {
+    base: string;
+    revision: string;
+    catalog: string;
+    editor: string;
+};
+export declare const parserApiBase: string;
+declare const api: import("axios").AxiosInstance;
+export { createApiClient } from './createApiClient';
+export type { CreateApiClientOptions, ServerErrorHandling, } from './createApiClient';
+export { applyAuthErrorHandling } from './applyAuthErrorHandling';
+export type { ApplyAuthErrorHandlingOptions, AuthErrorHandling, } from './applyAuthErrorHandling';
+export { isHandledApiError, isHandledAuthError, markApiErrorHandled, markAuthErrorHandled, } from './apiHandledError';
+export type { ApiErrorHandled, AuthErrorHandled } from './apiHandledError';
+export { dispatchApiError, dispatchServerApiError } from './dispatchApiError';
+export default api;

package/dist/configs/api/index.js

@@ -0,0 +1,16 @@
+import { applyAuthErrorHandling } from './applyAuthErrorHandling';
+import { createApiClient } from './createApiClient';
+const platformApiBase = import.meta.env.VITE_APP_PLATFORM_API;
+export const platformApi = {
+    base: platformApiBase,
+    revision: `${platformApiBase}/revision`,
+    catalog: `${platformApiBase}/catalog`,
+    editor: `${platformApiBase}/editor`,
+};
+export const parserApiBase = import.meta.env.VITE_APP_PARSER_API;
+const api = applyAuthErrorHandling(createApiClient({ baseURL: platformApiBase }), { authErrorHandling: 'redirect' });
+export { createApiClient } from './createApiClient';
+export { applyAuthErrorHandling } from './applyAuthErrorHandling';
+export { isHandledApiError, isHandledAuthError, markApiErrorHandled, markAuthErrorHandled, } from './apiHandledError';
+export { dispatchApiError, dispatchServerApiError } from './dispatchApiError';
+export default api;

package/dist/configs/api.d.ts

@@ -1,10 +1,2 @@
-/** Platform API roots (formerly separate env vars per service). */
-export declare const platformApi: {
-    base: string;
-    revision: string;
-    catalog: string;
-    editor: string;
-};
-export declare const parserApiBase: string;
-declare const api: import("axios").AxiosInstance;
-export default api;
+export * from './api/index';
+export { default } from './api/index';

package/dist/configs/api.js

@@ -1,52 +1,2 @@
-import axios from 'axios';
-import CookieStorage from './CookieStorage';
-const platformApiBase = import.meta.env.VITE_APP_PLATFORM_API;
-/** Platform API roots (formerly separate env vars per service). */
-export const platformApi = {
-    base: platformApiBase,
-    revision: `${platformApiBase}/revision`,
-    catalog: `${platformApiBase}/catalog`,
-    editor: `${platformApiBase}/editor`,
-};
-export const parserApiBase = import.meta.env.VITE_APP_PARSER_API;
-const api = axios.create({
-    headers: {
-        'Cache-Control': 'no-cache, no-store, must-revalidate',
-        Pragma: 'no-cache',
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
-    },
-    baseURL: platformApiBase,
-});
-const isStorybook = () => typeof window !== 'undefined' &&
-    (window.location.port === '6006' ||
-        window.__STORYBOOK__);
-api.interceptors.response.use((response) => response, async (error) => {
-    if (error.response?.status === 401) {
-        CookieStorage.removeJwtToken();
-        sessionStorage.clear();
-        localStorage.clear();
-        if (!isStorybook()) {
-            window.location.replace(import.meta.env.VITE_APP_AUTH_URL);
-        }
-    }
-    else if (error.response?.status === 403 && !isStorybook()) {
-        window.location.href = import.meta.env.VITE_APP_UNAUTHORIZED_URL;
-    }
-    else if (error.status === null) {
-        console.log(JSON.stringify(error));
-    }
-    return Promise.reject(error);
-});
-api.interceptors.request.use((config) => {
-    if (!config?.headers) {
-        throw new Error('no header available');
-    }
-    const token = CookieStorage.getJwtToken();
-    if (!token)
-        return config;
-    // eslint-disable-next-line no-param-reassign
-    config.headers.Authorization = `Bearer ${token}`;
-    return config;
-});
-export default api;
+export * from './api/index';
+export { default } from './api/index';

package/dist/configs/index.d.ts

@@ -1,5 +1,6 @@
 export { default as CommonContext, CommonProvider } from './CommonContext';
 export { default as CommonDispatchBridge } from './CommonDispatchBridge';
+export * from './api/index';
 export { getCommonDispatch, registerCommonDispatch, } from './commonDispatch';
 export { default as CookieStorage } from './CookieStorage';
 export { commonLocalization, commonResources, featureResources, mergeResources, } from './Localization';

package/dist/configs/index.js

@@ -1,5 +1,6 @@
 export { default as CommonContext, CommonProvider } from './CommonContext';
 export { default as CommonDispatchBridge } from './CommonDispatchBridge';
+export * from './api/index';
 export { getCommonDispatch, registerCommonDispatch, } from './commonDispatch';
 export { default as CookieStorage } from './CookieStorage';
 export { commonLocalization, commonResources, featureResources, mergeResources, } from './Localization';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nurseitaly-components",
   "private": false,
-  "version": "0.0.13",
+  "version": "0.0.14",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {