@elliemae/pui-app-sdk 2.21.1 → 3.0.0-beta.12

package/dist/es/api/helpers.js

@@ -1,85 +1,12 @@
-import _get from "lodash/get";
-import { createAction } from '@reduxjs/toolkit';
-
-/**
- * @function
- * @description Creates API Redux Action Creators
- * ## Examples
- * ```javascript
- * import { getApiActionCreator } from '@elliemae/pui-app-sdk';
- *  const loansActionCreator = getApiActionCreator('loans');
- *
- *  export const loans = {
- *    ...loansActionCreator('create'),
- *    ...loansActionCreator('get'),
- *    ...loansActionCreator('save'),
- *  };
- *
- *  const loansSlice = createSlice({
- *    name: 'loans',
- *    initialState: [],
- *    reducers: {
- *      getSuccess: (state, { payload }) => {
- *        state.push(...payload);
- *      },
- *      saveSuccess: (state, { payload }) => {
- *        state.push(payload);
- *      },
- *    },
- *  });
- * ```
- * @param {string} api API name for which Redux Action Creators are required
- * @returns {Function} Redux Action Creators util function
- */
-export const getApiActionCreator = api => operation => ({
+import { createAction } from "@reduxjs/toolkit";
+import { get } from "lodash";
+const getApiActionCreator = (api) => (operation) => ({
   [operation]: createAction(`${api}/${operation}`),
   [`${operation}Success`]: createAction(`${api}/${operation}Success`),
   [`${operation}Error`]: createAction(`${api}/${operation}Error`)
 });
-/**
- * Why use this? It will prevent unnecessary rerenders hence improving performance, it also reduces the amount of code needed to select data from the store
- * hence making it easier and keeping your codebase smaller and easier to maintain.
- *
- * For this to work as expected, ensure you always select ONLY what you need. Don't select state objects that contain fields that you won't use, if you do so
- * then everytime any of those gets updated it will trigger a rerender even though you're not actually using that field.
- *
- * @description Generic Redux State Selector Helper.
- * ### Example
- * ```javascript
- * // reducer.js
- * import { getSelectField } from 'elliemae/pui-app-sdk';
- *
- * const name = 'someState';
- * export selectSomeState = getSelectField(name);
- *
- * // use-some-state.js hook. NOTE: You can create a hook for each main state
- * import { selectSomeState } from 'slices/some-slice';
- * import { useSelector, shallowEqual } from 'react-redux';
- *
- * export const useSelectSomeState = (fieldName, defaultValue) => useSelector(selectSomeState(fieldName, defaultValue), shallowEqual);
- *
- * // some-component.js
- * import { useSelectSomeState } from 'custom-hooks/state-selectors.js'
- *
- * export const SomeComponent = () => {
- *   const someField = useSelectSomeState('someField');
- *   ...
- * }
- * export const SomeOtherComponent = () => {
- *   const someSubField = useSelectSomeState('someField.someSubField');
- *   ...
- * }
- * export const AnotherComponent = () => {
- *   const [firstField, secondField, thirdField] = useSelectSomeState(['firstField', 'secondField', 'thirdField']);
- *   ...
- * }
- *
- * ```
- * @param {string} stateName the redux store's state name of the state you want to access.
- * @returns {Function} A *selectField* function that returns a selector function to be used inside a *useSelector* hook or a *select* side effect
- */
-
-/* eslint-disable prettier/prettier */
-
-export const getSelectField = stateName => (fieldName = '', defaultValue) => (state = {}, stateValue = _get(state, stateName)) => Array.isArray(fieldName) ? fieldName.map((field, i) => _get(stateValue, field, Array.isArray(defaultValue) ? defaultValue[i] : defaultValue)) : _get(stateValue, fieldName, defaultValue);
-/* eslint-enable prettier/prettier */
+const getSelectField = (stateName) => (fieldName = "", defaultValue) => (state = {}, stateValue = get(state, stateName)) => Array.isArray(fieldName) ? fieldName.map((field, i) => get(stateValue, field, Array.isArray(defaultValue) ? defaultValue[i] : defaultValue)) : get(stateValue, fieldName, defaultValue);
+export {
+  getApiActionCreator,
+  getSelectField
+};

package/dist/es/api/users/index.js

@@ -1,9 +1,8 @@
 import { getAuthHTTPClient } from "../../communication/http-client/index.js";
-export const getUser = async ({
-  userName
-}) => {
-  const {
-    data
-  } = await getAuthHTTPClient().get(`/encompass/v1/users/${userName}`);
+const getUser = async ({ userName }) => {
+  const { data } = await getAuthHTTPClient().get(`/encompass/v1/users/${userName}`);
   return data;
-};
+};
+export {
+  getUser
+};

package/dist/es/communication/http-client/index.js

@@ -1,41 +1,35 @@
-import axios from 'axios';
+import axios from "axios";
 import { getAppConfigValue } from "../../utils/app-config/config.js";
 import { getAuthorizationHeader } from "../../utils/auth/helper.js";
 import setupRetry from "./retry.js";
 import { requestInterceptor } from "./request-interceptor.js";
 import { handleSuccess, handleFailure } from "./response-interceptor.js";
-const REQUEST_TIMEOUT = 2 * 60 * 1000; // 2 mins
-
-export const getHTTPClient = ({
-  baseURL = getAppConfigValue('serviceEndpoints.api', ''),
+const REQUEST_TIMEOUT = 2 * 60 * 1e3;
+const getHTTPClient = ({
+  baseURL = getAppConfigValue("serviceEndpoints.api", ""),
   headers = {}
 } = {}) => {
-  var _client$defaults;
-
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const client = axios.create({
-    baseURL,
-    headers
-  });
-  if (client !== null && client !== void 0 && (_client$defaults = client.defaults) !== null && _client$defaults !== void 0 && _client$defaults.timeout) client.defaults.timeout = REQUEST_TIMEOUT;
+  const client = axios.create({ baseURL, headers });
+  if (client?.defaults?.timeout)
+    client.defaults.timeout = REQUEST_TIMEOUT;
   setupRetry(client);
-  const {
-    request,
-    response
-  } = (client === null || client === void 0 ? void 0 : client.interceptors) || {};
-  if (request) request.use(requestInterceptor);
-  if (response) response.use(handleSuccess, handleFailure);
+  const { request, response } = client?.interceptors || {};
+  if (request)
+    request.use(requestInterceptor);
+  if (response)
+    response.use(handleSuccess, handleFailure);
   return client;
 };
-export const getAuthHTTPClient = ({
+const getAuthHTTPClient = ({
   baseURL,
   headers = {},
   ...rest
 } = {}) => getHTTPClient({
   baseURL,
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  headers: { ...headers,
-    Authorization: getAuthorizationHeader()
-  },
+  headers: { ...headers, Authorization: getAuthorizationHeader() },
   ...rest
-});
+});
+export {
+  getAuthHTTPClient,
+  getHTTPClient
+};

package/dist/es/communication/http-client/request-interceptor.js

@@ -1,5 +1,8 @@
 import { resetUserIdleTime } from "../../utils/session.js";
-export const requestInterceptor = config => {
+const requestInterceptor = (config) => {
   resetUserIdleTime();
   return config;
-};
+};
+export {
+  requestInterceptor
+};

package/dist/es/communication/http-client/response-interceptor.js

@@ -1,33 +1,32 @@
-import axios from 'axios';
+import axios from "axios";
 const HTTP_UNAUTHORIZED = 401;
 let unAuthorizedFailureHandler = null;
-export const onAuthorizationFailure = callback => {
+const onAuthorizationFailure = (callback) => {
   unAuthorizedFailureHandler = callback;
 };
-export const handleSuccess = response => response;
-export const handleFailure = error => {
-  const {
-    status
-  } = (error || {}).response || {}; // incase of authorization issues give a chance to the sdk consumer to refresh the authroization token and resubmit the request
-
-  if (status === HTTP_UNAUTHORIZED && unAuthorizedFailureHandler && typeof unAuthorizedFailureHandler === 'function') {
-    return unAuthorizedFailureHandler(error).then(authorizationHeader => {
-      const {
-        config
-      } = error;
-      if (config.headers) config.headers.Authorization = authorizationHeader;
+const handleSuccess = (response) => response;
+const handleFailure = (error) => {
+  const { status } = (error || {}).response || {};
+  if (status === HTTP_UNAUTHORIZED && unAuthorizedFailureHandler && typeof unAuthorizedFailureHandler === "function") {
+    return unAuthorizedFailureHandler(error).then((authorizationHeader) => {
+      const { config } = error;
+      if (config.headers)
+        config.headers.Authorization = authorizationHeader;
       return new Promise((resolve, reject) => {
-        axios.request(config).then(response => {
+        axios.request(config).then((response) => {
           resolve(response);
-        }).catch(exception => {
+        }).catch((exception) => {
           reject(exception);
         });
       });
-    }).catch(exception => Promise.reject(exception));
-  } // Return any error which is not due to authentication back to the calling service
-
-
+    }).catch((exception) => Promise.reject(exception));
+  }
   return new Promise((resolve, reject) => {
     reject(error);
   });
-};
+};
+export {
+  handleFailure,
+  handleSuccess,
+  onAuthorizationFailure
+};

package/dist/es/communication/http-client/retry-axios.js

@@ -1,148 +1,88 @@
-/* eslint-disable no-param-reassign,jsdoc/require-returns,jsdoc/require-param-type,jsdoc/require-returns-type,max-lines,@typescript-eslint/no-non-null-assertion */
-import axios from 'axios';
-
-const onFulfilled = res => res;
-/**
- * Eject the Axios interceptor that is providing retry capabilities.
- *
- * @param interceptorId The interceptorId provided in the config.
- * @param instance The axios instance using this interceptor.
- */
-
-
-export const detach = (interceptorId, instance) => {
-  var _instance, _instance$interceptor;
-
+import axios from "axios";
+const onFulfilled = (res) => res;
+const detach = (interceptorId, instance) => {
   instance = instance || axios;
-  if ((_instance = instance) !== null && _instance !== void 0 && (_instance$interceptor = _instance.interceptors) !== null && _instance$interceptor !== void 0 && _instance$interceptor.response) instance.interceptors.response.eject(interceptorId);
+  if (instance?.interceptors?.response)
+    instance.interceptors.response.eject(interceptorId);
 };
-/**
- * Determine based on config if we should retry the request.
- *
- * @param err The AxiosError passed to the interceptor.
- */
-// eslint-disable-next-line complexity
-
-const shouldRetryRequest = err => {
-  const config = err.config.retryConfig; // If there's no config, or retries are disabled, return.
-
+const shouldRetryRequest = (err) => {
+  const config = err.config.retryConfig;
   if (!config || config.retry === 0) {
     return false;
-  } // Check if this error has no response (ETIMEDOUT, ENOTFOUND, etc)
-
-
+  }
   if (!err.response && (config.currentRetryAttempt || 0) >= config.noResponseRetries) {
     return false;
-  } // Only retry with configured HttpMethods.
-
-
+  }
   if (!err.config.method || config.httpMethodsToRetry.indexOf(err.config.method.toUpperCase()) < 0) {
     return false;
-  } // If this wasn't in the list of status codes where we want
-  // to automatically retry, return.
-
-
+  }
   if (err.response && err.response.status) {
-    let isInRange = false; // eslint-disable-next-line no-restricted-syntax
-
+    let isInRange = false;
     for (const [min, max] of config.statusCodesToRetry) {
-      const {
-        status
-      } = err.response;
-
+      const { status } = err.response;
       if (status >= min && status <= max) {
         isInRange = true;
         break;
       }
     }
-
     if (!isInRange) {
       return false;
     }
-  } // If we are out of retry attempts, return
-
-
+  }
   config.currentRetryAttempt = config.currentRetryAttempt || 0;
-
   if (config.currentRetryAttempt >= config.retry) {
     return false;
   }
-
   return true;
-}; // eslint-disable-next-line complexity
-
-
-const onError = err => {
+};
+const onError = (err) => {
   if (!err.config) {
     return Promise.reject(err);
   }
-
   const config = err.config.retryConfig || {};
   config.currentRetryAttempt = config.currentRetryAttempt || 0;
-  config.retry = config.retry === undefined || config.retry === null ? 3 : config.retry;
+  config.retry = config.retry === void 0 || config.retry === null ? 3 : config.retry;
   config.retryDelay = config.retryDelay || 100;
   config.instance = config.instance || axios;
-  config.httpMethodsToRetry = config.httpMethodsToRetry || ['GET', 'HEAD', 'PUT', 'OPTIONS', 'DELETE'];
-  config.noResponseRetries = config.noResponseRetries === undefined || config.noResponseRetries === null ? 2 : config.noResponseRetries; // If this wasn't in the list of status codes where we want
-  // to automatically retry, return.
-
-  const retryRanges = [// https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
-  // 1xx - Retry (Informational, request still processing)
-  // 2xx - Do not retry (Success)
-  // 3xx - Do not retry (Redirect)
-  // 4xx - Do not retry (Client errors)
-  // 429 - Retry ("Too Many Requests")
-  // 5xx - Retry (Server errors)
-  [100, 199], [429, 429], [500, 599]];
-  config.statusCodesToRetry = config.statusCodesToRetry || retryRanges; // Put the config back into the err
-
-  err.config.retryConfig = config; // Determine if we should retry the request
-
+  config.httpMethodsToRetry = config.httpMethodsToRetry || [
+    "GET",
+    "HEAD",
+    "PUT",
+    "OPTIONS",
+    "DELETE"
+  ];
+  config.noResponseRetries = config.noResponseRetries === void 0 || config.noResponseRetries === null ? 2 : config.noResponseRetries;
+  const retryRanges = [
+    [100, 199],
+    [429, 429],
+    [500, 599]
+  ];
+  config.statusCodesToRetry = config.statusCodesToRetry || retryRanges;
+  err.config.retryConfig = config;
   const shouldRetryFn = config.shouldRetry || shouldRetryRequest;
-
   if (!shouldRetryFn(err)) {
     return Promise.reject(err);
-  } // Create a promise that invokes the retry after the backOffDelay
-
-
-  const onBackoffPromise = new Promise(resolve => {
-    // Calculate time to wait with exponential backoff.
-    // Formula: (2^c - 1 / 2) * 1000
-    // eslint-disable-next-line no-restricted-properties
-    const delay = (Math.pow(2, config.currentRetryAttempt) - 1) / 2 * 1000;
+  }
+  const onBackoffPromise = new Promise((resolve) => {
+    const delay = (Math.pow(2, config.currentRetryAttempt) - 1) / 2 * 1e3;
     err.config.retryConfig.currentRetryAttempt += 1;
     setTimeout(resolve, delay);
-  }); // Notify the user if they added an `onRetryAttempt` handler
-
-  const onRetryAttemptPromise = config.onRetryAttempt ? Promise.resolve(config.onRetryAttempt(err)) : Promise.resolve(); // Return the promise in which recalls axios to retry the request
-
+  });
+  const onRetryAttemptPromise = config.onRetryAttempt ? Promise.resolve(config.onRetryAttempt(err)) : Promise.resolve();
   return Promise.resolve().then(() => onBackoffPromise).then(() => onRetryAttemptPromise).then(() => config.instance.request(err.config));
 };
-/**
- * Attach the interceptor to the Axios instance.
- *
- * @param instance The optional Axios instance on which to attach the
- * interceptor.
- * @returns The id of the interceptor attached to the axios instance.
- */
-
-
-export const attach = instance => {
-  var _instance2, _instance2$intercepto;
-
+const attach = (instance) => {
   instance = instance || axios;
-  return (_instance2 = instance) !== null && _instance2 !== void 0 && (_instance2$intercepto = _instance2.interceptors) !== null && _instance2$intercepto !== void 0 && _instance2$intercepto.response ? instance.interceptors.response.use(onFulfilled, onError) : null;
+  return instance?.interceptors?.response ? instance.interceptors.response.use(onFulfilled, onError) : null;
 };
-/**
- * Acquire the retryConfig object from an AxiosError if available.
- *
- * @param err The Axios error with a config object.
- */
-
-export const getConfig = err => {
+const getConfig = (err) => {
   if (err && err.config) {
     return err.config.retryConfig;
   }
-
   return null;
-};
+};
+export {
+  attach,
+  detach,
+  getConfig
+};

package/dist/es/communication/http-client/retry.js

@@ -1,34 +1,31 @@
-import { attach, getConfig } from "./retry-axios.js";
-export const getRaxConfig = httpClient => ({
-  // Retry 3 times on requests that return a response (500, etc) before giving up.  Defaults to 3.
+import {
+  attach,
+  getConfig
+} from "./retry-axios.js";
+const getRaxConfig = (httpClient) => ({
   retry: 3,
-  // Retry twice on errors that don't return a response (ENOTFOUND, ETIMEDOUT, etc).
   noResponseRetries: 2,
-  // Milliseconds to delay at first.  Defaults to 100.
   retryDelay: 100,
-  // HTTP methods to automatically retry.  Defaults to:
-  // ['GET', 'HEAD', 'OPTIONS', 'DELETE', 'PUT']
-  httpMethodsToRetry: ['GET', 'HEAD', 'OPTIONS', 'DELETE', 'PUT'],
-  // The response status codes to retry.  Supports a double
-  // array with a list of ranges.  Defaults to:
-  // [[100, 199], [429, 429], [500, 599]]
-  statusCodesToRetry: [[100, 199], [429, 429], [500, 599]],
-  // If you are using a non static instance of Axios you need
-  // to pass that instance here (const ax = axios.create())
+  httpMethodsToRetry: ["GET", "HEAD", "OPTIONS", "DELETE", "PUT"],
+  statusCodesToRetry: [
+    [100, 199],
+    [429, 429],
+    [500, 599]
+  ],
   instance: httpClient,
-  // You can detect when a retry is happening, and figure out how many
-  // retry attempts have been made
-  onRetryAttempt: err => {
-    const cfg = getConfig(err); // eslint-disable-next-line no-console
-
-    if (cfg && cfg.currentRetryAttempt) {}
+  onRetryAttempt: (err) => {
+    const cfg = getConfig(err);
+    if (cfg && cfg.currentRetryAttempt)
+      console.log(`Retry attempt #${cfg.currentRetryAttempt}`);
   }
 });
-
-const setupRetry = httpClient => {
-  if (httpClient !== null && httpClient !== void 0 && httpClient.defaults) // eslint-disable-next-line no-param-reassign
+const setupRetry = (httpClient) => {
+  if (httpClient?.defaults)
     httpClient.defaults.retryConfig = getRaxConfig(httpClient);
   attach(httpClient);
 };
-
-export default setupRetry;
+var retry_default = setupRetry;
+export {
+  retry_default as default,
+  getRaxConfig
+};

package/dist/es/communication/http-client/tests/index.test-disable.js

@@ -1,65 +1,46 @@
-/* Important. these test cases work only with server backend. so do not enable these test cases. */
 import enums from "../../../utils/constants.js";
 import { getAuthHTTPClient } from "../index.js";
 import { onAuthorizationFailure } from "../response-interceptor.js";
-describe('http client test cases', () => {
+describe("http client test cases", () => {
   const callApi = ({
     apiUrl,
     options = {},
-    baseURL = 'http://localhost:3001'
+    baseURL = "http://localhost:3001"
   }) => {
-    const httpClient = getAuthHTTPClient({
-      baseURL
-    });
+    const httpClient = getAuthHTTPClient({ baseURL });
     return httpClient.get(apiUrl, options);
   };
-
-  const refreshToken = () => new Promise(resolve => {
-    const authorizationHeader = 'pui';
+  const refreshToken = () => new Promise((resolve) => {
+    const authorizationHeader = "pui";
     sessionStorage.setItem(enums.AUTHORIZATION, authorizationHeader);
     resolve(authorizationHeader);
   });
-
-  it('should download large file without timing out', async () => {
-    jest.setTimeout(300000);
-    const {
-      data
-    } = await callApi({
-      apiUrl: 'annual_report_2009.pdf',
-      options: {
-        timeout: 200000
-      },
-      baseURL: 'https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en'
+  it("should download large file without timing out", async () => {
+    jest.setTimeout(3e5);
+    const { data } = await callApi({
+      apiUrl: "annual_report_2009.pdf",
+      options: { timeout: 2e5 },
+      baseURL: "https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en"
     });
     expect(data).toBeDefined();
   });
-  it('should throw connection aborted error for large file download', async () => {
-    jest.setTimeout(300000);
+  it("should throw connection aborted error for large file download", async () => {
+    jest.setTimeout(3e5);
     await expect(callApi({
-      apiUrl: 'annual_report_2009.pdf',
-      baseURL: 'https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en'
-    })).rejects.toEqual(new Error('timeout of 10000ms exceeded'));
+      apiUrl: "annual_report_2009.pdf",
+      baseURL: "https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en"
+    })).rejects.toEqual(new Error("timeout of 10000ms exceeded"));
   });
-  it('should return success response', async () => {
-    const {
-      data
-    } = await callApi({
-      apiUrl: '/hello'
-    });
-    expect(data.name).toEqual('pui-app-sdk');
+  it("should return success response", async () => {
+    const { data } = await callApi({ apiUrl: "/hello" });
+    expect(data.name).toEqual("pui-app-sdk");
   });
-  it('should return unauthorized 401 response', async () => {
-    await expect(callApi({
-      apiUrl: '/private'
-    })).rejects.toThrow('Request failed with status code 401');
+  it("should return unauthorized 401 response", async () => {
+    await expect(callApi({ apiUrl: "/private" })).rejects.toThrow("Request failed with status code 401");
   });
-  it('should return success after refreshing authorization token', async () => {
+  it("should return success after refreshing authorization token", async () => {
     onAuthorizationFailure(refreshToken);
-    const {
-      data
-    } = await callApi({
-      apiUrl: '/private'
-    });
-    expect(data.message).toEqual('you are viewing a private message');
+    const { data } = await callApi({ apiUrl: "/private" });
+    expect(data.message).toEqual("you are viewing a private message");
   });
-});
+});

package/dist/es/data/auth/actions.js

@@ -1,7 +1,7 @@
-export const LOGIN = 'auth/LOGIN';
-export const LOGIN_SUCCESS = 'auth/LOGIN_SUCCESS';
-export const LOGOUT = 'auth/LOGOUT';
-export const auth = {
+const LOGIN = "auth/LOGIN";
+const LOGIN_SUCCESS = "auth/LOGIN_SUCCESS";
+const LOGOUT = "auth/LOGOUT";
+const auth = {
   login: ({
     idpCode,
     redirectUri,
@@ -10,13 +10,7 @@ export const auth = {
     scope
   }) => ({
     type: LOGIN,
-    payload: {
-      idpCode,
-      redirectUri,
-      clientId,
-      responseType,
-      scope
-    }
+    payload: { idpCode, redirectUri, clientId, responseType, scope }
   }),
   logout: ({
     clientId,
@@ -26,12 +20,12 @@ export const auth = {
     code
   }) => ({
     type: LOGOUT,
-    payload: {
-      clientId,
-      redirectUri,
-      responseType,
-      scope,
-      code
-    }
+    payload: { clientId, redirectUri, responseType, scope, code }
   })
-};
+};
+export {
+  LOGIN,
+  LOGIN_SUCCESS,
+  LOGOUT,
+  auth
+};

package/dist/es/data/auth/reducer.js

@@ -1,14 +1,16 @@
-import produce from 'immer';
+import produce from "immer";
 import { LOGIN_SUCCESS } from "./actions.js";
-export const initialState = {
+const initialState = {
   authenticated: false
 };
-/* eslint-disable default-case, no-param-reassign */
-
-export const authReducer = produce((draft, action) => {
+const authReducer = produce((draft, action) => {
   switch (action.type) {
     case LOGIN_SUCCESS:
       draft.authenticated = true;
       break;
   }
-}, initialState);
+}, initialState);
+export {
+  authReducer,
+  initialState
+};