@eid-easy/eideasy-browser-client 2.7.0 → 2.10.1

package/src/apiClient/createApiEndpoints.js

@@ -1,71 +0,0 @@
-/* eslint-disable max-len */
-
-import modes from '../modes';
-
-const createEndpoint = function createEndpoint(endpointFn, baseConfig) {
-  // eslint-disable-next-line func-names
-  return function (config) {
-    const mergedConfig = {
-      ...baseConfig,
-      ...config,
-    };
-    return endpointFn(mergedConfig);
-  };
-};
-
-const provideEndpointsWithBaseConfig = function provideEndpointsWithBaseConfig(endpoints, baseConfig) {
-  const newEndpoints = {};
-  Object.keys(endpoints).forEach((key) => {
-    newEndpoints[key] = createEndpoint(endpoints[key], baseConfig);
-  });
-  return newEndpoints;
-};
-
-const createApiEndpoints = function createApiEndpoints(settings = {}, overrides = {}) {
-  const apiEndpoints = {
-    base: ({ baseUrl }) => baseUrl,
-    readCard: ({
-      countryCode = settings.countryCode.toLowerCase(),
-      clientId,
-    }) => `https://${countryCode}.eideasy.com/api/identity/${clientId}/read-card`,
-    eParakstsMobile: ({ baseUrl, clientId, redirectUri }) => `${baseUrl}/oauth/start/lv-eparaksts-mobile-login?client_id=${clientId}&redirect_uri=${redirectUri}&response_type=code`,
-    zealIdIframeUrl: ({ baseUrl, clientId }) => `${baseUrl}/api/identity/${clientId}/zealid/get_iframe_url`,
-    mojeId: ({ baseUrl, clientId, redirectUri }) => `${baseUrl}/oauth/start/mojeid?client_id=${clientId}&redirect_uri=${redirectUri}&response_type=code`,
-    finnishTrustNetwork: ({
-      baseUrl, clientId, redirectUri, language,
-    }) => `${baseUrl}/oauth/start/finnish-ftn-login?client_id=${clientId}&redirect_uri=${redirectUri}&response_type=code&lang=${language}`,
-    atHandy: ({ baseUrl, clientId, redirectUri }) => `${baseUrl}/oauth/authorize?client_id=${clientId}&redirect_uri=${redirectUri}&response_type=code&method=at-handy-signatur-login`,
-    idCardIframe: ({ baseUrl, clientId, actionType }) => `${baseUrl}/signatures/integration/${clientId}/${actionType}`,
-    startSigning: ({ baseUrl }) => `${baseUrl}/api/signatures/start-signing`,
-    completeSignatureIdCard: ({ baseUrl }) => `${baseUrl}/api/signatures/id-card/complete`,
-    completeSignatureMobileId: ({ baseUrl }) => `${baseUrl}/api/signatures/sk-mobile-id/complete`,
-    completeSignatureSmartId: ({ baseUrl }) => `${baseUrl}/api/signatures/sk-smart-id/complete`,
-    completeSignatureEvrotrust: ({ baseUrl }) => `${baseUrl}/api/signatures/evrotrust-signature/complete`,
-    completeOtp: ({ baseUrl }) => `${baseUrl}/api/signatures/non-qualified/complete`,
-    eideasyMonitoring: ({ baseUrl }) => `${baseUrl}/confirm_progress`,
-    startZealIdSignature: ({ baseUrl, clientId, docId }) => `${baseUrl}/zealid/signature/start?client_id=${clientId}&doc_id=${docId}`,
-    ...overrides,
-  };
-
-  const apiEndpointsByModes = {
-    [modes.production]: {
-      ...provideEndpointsWithBaseConfig(apiEndpoints, {
-        baseUrl: overrides.base ? overrides.base() : 'https://id.eideasy.com',
-      }),
-    },
-    [modes.sandbox]: {
-      ...provideEndpointsWithBaseConfig(apiEndpoints, {
-        baseUrl: overrides.base ? overrides.base() : 'https://test.eideasy.com',
-      }),
-    },
-  };
-
-  return {
-    get inCurrentMode() {
-      const mode = settings.sandbox ? modes.sandbox : modes.production;
-      return apiEndpointsByModes[mode];
-    },
-  };
-};
-
-export default createApiEndpoints;

package/src/cloneDeep.js

@@ -1,3 +0,0 @@
-import cloneDeep from 'lodash/cloneDeep';
-
-export default cloneDeep;

package/src/config.js

@@ -1,260 +0,0 @@
-const methodTypes = {
-  IDENTIFICATION: 'identification',
-  SIGNATURE: 'signature',
-};
-
-const methodActionTypes = {
-  BE_ID_LOGIN: 'be-id-login',
-  EE_ID_LOGIN: 'ee-id-login',
-  FI_ID_LOGIN: 'fi-id-login',
-  PT_ID_LOGIN: 'pt-id-login',
-  LV_ID_LOGIN: 'lv-id-login',
-  LT_ID_LOGIN: 'lt-id-login',
-  RS_ID_LOGIN: 'rs-id-login',
-  EE_MOBILE_ID: 'mid-login',
-  LV_EPARAKSTS_MOBILE_LOGIN: 'lv-eparaksts-mobile-login',
-  LT_MOBILE_ID: 'lt-mobile-id',
-  SMART_ID: 'smartid',
-  FREJA_EID_LOGIN: 'freja-eid-login',
-  ZEALID_LOGIN: 'zealid-login',
-  CZ_MOJEID: 'mojeid',
-  AT_HANDY_SIGNATUR_LOGIN: 'at-handy-signatur-login',
-  FI_FTN_LOGIN: 'finnish-ftn-login',
-
-  ZEAL_ID_SIGNATURE: 'zealid-signature',
-  EE_IDCARD_SIGNATURE: 'id-signature',
-  EE_MOBILEID_SIGNATURE: 'mid-signature',
-  LT_MOBILEID_SIGNATURE: 'lt-mid-signature',
-  SMARTID_SIGNATURE: 'smart-id-signature',
-  BE_IDCARD_SIGNATURE: 'be-id-signature',
-  LV_IDCARD_SIGNATURE: 'lv-id-signature',
-  LT_IDCARD_SIGNATURE: 'lt-id-signature',
-  FI_IDCARD_SIGNATURE: 'fi-id-signature',
-  LU_IDCARD_SIGNATURE: 'lu-id-signature',
-  PT_IDCARD_SIGNATURE: 'pt-id-signature',
-  LV_EPARAKSTS_MOBILE_SIGNATURE: 'lv-eparaksts-mobile-signature',
-  AT_HANDY_SIGNATUR_SIGNATURE: 'at-handy-signatur-signature',
-  REGISTRU_CENTRAS_SIGNATURE: 'registru-centras-signature',
-  OTP_EMAIL: 'otp-email-non-qualified',
-  FI_FTN_ADVANCED_SIGNATURE: 'fi-ftn-advanced-signature',
-  EVROTRUST_SIGNATURE: 'evrotrust-signature',
-};
-
-const moduleNames = {
-  idCard: 'idCard',
-  mobileId: 'mobileId',
-  eParakstsMobile: 'eParakstsMobile',
-  smartId: 'smartId',
-  frejaEid: 'frejaEid',
-  zealId: 'zealId',
-  mojeId: 'mojeId',
-  finnishTrustNetwork: 'finnishTrustNetwork',
-  atHandy: 'atHandy',
-
-  idCardSignature: 'idCardSignature',
-  mobileIdSignature: 'mobileIdSignature',
-  smartIdSignature: 'smartIdSignature',
-  evroTrustSignature: 'evroTrustSignature',
-  otpSignature: 'otpSignature',
-  eParakstsMobileSignature: 'eParakstsMobileSignature',
-  ftnSignature: 'ftnSignature',
-  atHandySignature: 'atHandySignature',
-  zealIdSignature: 'zealIdSignature',
-};
-
-const allMethods = Object.freeze({
-  [methodTypes.IDENTIFICATION]: [
-    {
-      actionType: methodActionTypes.BE_ID_LOGIN,
-      handlingModule: moduleNames.idCard,
-      supportedCountries: ['BE'],
-    },
-    {
-      actionType: methodActionTypes.EE_ID_LOGIN,
-      handlingModule: moduleNames.idCard,
-      supportedCountries: ['EE'],
-    },
-    {
-      actionType: methodActionTypes.FI_ID_LOGIN,
-      handlingModule: moduleNames.idCard,
-      supportedCountries: ['FI'],
-    },
-    {
-      actionType: methodActionTypes.LV_ID_LOGIN,
-      handlingModule: moduleNames.idCard,
-      supportedCountries: ['LV'],
-    },
-    {
-      actionType: methodActionTypes.LT_ID_LOGIN,
-      handlingModule: moduleNames.idCard,
-      supportedCountries: ['LT'],
-    },
-    {
-      actionType: methodActionTypes.PT_ID_LOGIN,
-      handlingModule: moduleNames.idCard,
-      supportedCountries: ['PT'],
-    },
-    {
-      actionType: methodActionTypes.RS_ID_LOGIN,
-      handlingModule: moduleNames.idCard,
-      supportedCountries: ['RS'],
-    },
-    {
-      actionType: methodActionTypes.LV_EPARAKSTS_MOBILE_LOGIN,
-      handlingModule: moduleNames.eParakstsMobile,
-      supportedCountries: ['LV'],
-    },
-    {
-      actionType: methodActionTypes.LT_MOBILE_ID,
-      handlingModule: moduleNames.mobileId,
-      supportedCountries: ['LT'],
-    },
-    {
-      actionType: methodActionTypes.EE_MOBILE_ID,
-      handlingModule: moduleNames.mobileId,
-      supportedCountries: ['EE'],
-    },
-    {
-      actionType: methodActionTypes.SMART_ID,
-      handlingModule: moduleNames.smartId,
-      supportedCountries: ['EE', 'LV', 'LT'],
-    },
-    {
-      actionType: methodActionTypes.FREJA_EID_LOGIN,
-      handlingModule: moduleNames.frejaEid,
-      supportedCountries: ['FI', 'SE', 'NO', 'DK'],
-    },
-    {
-      actionType: methodActionTypes.ZEALID_LOGIN,
-      handlingModule: moduleNames.zealId,
-      supportedCountries: [
-        'AT', 'BE', 'BG', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GB', 'GR', 'HR', 'HU', 'IE', 'IT', 'LV', 'LT',
-        'NL', 'NO', 'PL', 'PT', 'RO', 'RS', 'SE', 'SI', 'SK',
-      ],
-    },
-    {
-      actionType: methodActionTypes.CZ_MOJEID,
-      handlingModule: moduleNames.mojeId,
-      supportedCountries: ['CZ'],
-    },
-    {
-      actionType: methodActionTypes.FI_FTN_LOGIN,
-      handlingModule: moduleNames.finnishTrustNetwork,
-      supportedCountries: ['FI'],
-    },
-    {
-      actionType: methodActionTypes.AT_HANDY_SIGNATUR_LOGIN,
-      handlingModule: moduleNames.atHandy,
-      supportedCountries: ['AT'],
-    },
-  ],
-  [methodTypes.SIGNATURE]: [
-    {
-      actionType: methodActionTypes.EE_IDCARD_SIGNATURE,
-      handlingModule: moduleNames.idCardSignature,
-      supportedCountries: ['EE'],
-    },
-    {
-      actionType: methodActionTypes.LV_IDCARD_SIGNATURE,
-      handlingModule: moduleNames.idCardSignature,
-      supportedCountries: ['LV'],
-    },
-    {
-      actionType: methodActionTypes.LT_IDCARD_SIGNATURE,
-      handlingModule: moduleNames.idCardSignature,
-      supportedCountries: ['LT'],
-    },
-    {
-      actionType: methodActionTypes.FI_IDCARD_SIGNATURE,
-      handlingModule: moduleNames.idCardSignature,
-      supportedCountries: ['FI'],
-    },
-    {
-      actionType: methodActionTypes.PT_IDCARD_SIGNATURE,
-      handlingModule: moduleNames.idCardSignature,
-      supportedCountries: ['PT'],
-    },
-    {
-      actionType: methodActionTypes.BE_IDCARD_SIGNATURE,
-      handlingModule: moduleNames.idCardSignature,
-      supportedCountries: ['BE'],
-    },
-    {
-      actionType: methodActionTypes.EE_MOBILEID_SIGNATURE,
-      handlingModule: moduleNames.mobileIdSignature,
-      supportedCountries: ['EE'],
-    },
-    {
-      actionType: methodActionTypes.LT_MOBILEID_SIGNATURE,
-      handlingModule: moduleNames.mobileIdSignature,
-      supportedCountries: ['LT'],
-    },
-    {
-      actionType: methodActionTypes.SMARTID_SIGNATURE,
-      handlingModule: moduleNames.smartIdSignature,
-      supportedCountries: ['EE', 'LV', 'LT'],
-    },
-    {
-      actionType: methodActionTypes.EVROTRUST_SIGNATURE,
-      handlingModule: moduleNames.evroTrustSignature,
-      supportedCountries: [
-        'AL', 'AD', 'AM', 'AU', 'AT', 'AZ', 'BY', 'BE', 'BA', 'BG', 'CA', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR',
-        'GE', 'DE', 'GR', 'HU', 'IS', 'IE', 'IT', 'IL', 'KZ', 'KE', 'XK', 'LV', 'LI', 'LT', 'LU', 'MT', 'MD', 'MC',
-        'ME', 'NL', 'NZ', 'NO', 'MK', 'PL', 'PT', 'RO', 'RU', 'SM', 'RS', 'SK', 'SI', 'ES', 'SE', 'CH', 'TW', 'TR',
-        'UA', 'GB', 'US', 'VA',
-      ],
-    },
-    {
-      actionType: methodActionTypes.OTP_EMAIL,
-      handlingModule: moduleNames.otpSignature,
-      supportedCountries: ['WORLD'],
-    },
-    {
-      actionType: methodActionTypes.LV_EPARAKSTS_MOBILE_SIGNATURE,
-      handlingModule: moduleNames.eParakstsMobileSignature,
-      supportedCountries: ['LV'],
-    },
-    {
-      actionType: methodActionTypes.FI_FTN_ADVANCED_SIGNATURE,
-      handlingModule: moduleNames.ftnSignature,
-      supportedCountries: ['FI'],
-    },
-    {
-      actionType: methodActionTypes.AT_HANDY_SIGNATUR_SIGNATURE,
-      handlingModule: moduleNames.atHandySignature,
-      supportedCountries: ['AT'],
-    },
-    {
-      actionType: methodActionTypes.ZEAL_ID_SIGNATURE,
-      handlingModule: moduleNames.zealIdSignature,
-      supportedCountries: [
-        'AT', 'BE', 'BG', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GB', 'GR', 'HR', 'HU', 'IE', 'IT', 'LV', 'LT',
-        'NL', 'NO', 'PL', 'PT', 'RO', 'RS', 'SE', 'SI', 'SK',
-      ],
-    },
-  ],
-});
-
-const getMethodByHandlingModule = function getMethodByHandlingModule(methodType, handlingModule, country) {
-  const methods = allMethods[methodType];
-  if (handlingModule && country) {
-    const match = methods.find((method) => method.handlingModule === handlingModule
-      && (method.supportedCountries.includes(country) || method.supportedCountries.includes('WORLD')));
-
-    if (!match) {
-      const matchingMethods = methods.filter((method) => method.handlingModule === handlingModule);
-      if (matchingMethods.length === 0) {
-        throw new Error(`Could not find matching method configuration for ${methodType} module "${handlingModule}"`);
-      }
-
-      throw new Error(`Country "${country}" is not supported for ${methodType}
-        module "${handlingModule}".`);
-    }
-    return match;
-  }
-  return methods.find((method) => method.handlingModule === handlingModule);
-};
-
-export {
-  methodTypes, methodActionTypes, moduleNames, allMethods, getMethodByHandlingModule,
-};

package/src/coreSettingsSchema.js

@@ -1,76 +0,0 @@
-const coreSettingsSchema = {
-  countryCode: {
-    type: 'string',
-  },
-  sandbox: {
-    default: false,
-    type: 'boolean',
-  },
-  clientId: {
-    required: true,
-    type: 'string',
-  },
-  redirectUri: {
-    type: 'string',
-  },
-  docId: {
-    type: 'string',
-  },
-  contractId: {
-    type: 'string',
-  },
-  apiEndpoints: {
-    type: 'object',
-  },
-  modifyRequestSettings: {
-    type: 'function',
-  },
-  language: {
-    default: 'en',
-    type: 'string',
-  },
-  success: {
-    default: () => {},
-    type: 'function',
-  },
-  fail: {
-    default: () => {},
-    type: 'function',
-  },
-  finished: {
-    default: () => {},
-    type: 'function',
-  },
-  started: {
-    default: () => {},
-    type: 'function',
-  },
-  redirect: {
-    default: (result) => {
-      const redirectUrl = result.data && result.data.redirect_uri;
-      if (redirectUrl) {
-        if (window.location !== window.top.location) {
-          // we are inside an iframe
-          // eParaksts, Telia FTN, etc do not work inside an iframe
-          // so we need to redirect the parent window
-          window.top.location.href = redirectUrl;
-        } else {
-          window.location.href = redirectUrl;
-        }
-
-        // Return a pending promise to prevent the method module from calling success callback right after redirect.
-        // The reason for skipping success callback here is that if a redirect happens, then there are still
-        // some actions that the end user or the browser needs to perform (the redirect itself for example)
-        // so it doesn't make sense to call the success at this point.
-        return new Promise(() => {});
-      }
-      return result;
-    },
-    type: 'function',
-  },
-  remoteMonitoringEnabled: {
-    default: false,
-  },
-};
-
-export default coreSettingsSchema;

package/src/createApiPoller.js

@@ -1,54 +0,0 @@
-import poll from './poll';
-import { isCancel } from './request';
-
-function isBelowAttemptsLimit(currentCount, limit) {
-  if (!limit) {
-    return true;
-  }
-
-  return currentCount < limit;
-}
-
-const createApiPoller = function createApiPoller({
-  pollInterval = 2000,
-  maxPollDuration,
-  fn,
-  fnArgs,
-}) {
-  let maxPollAttempts;
-  if (maxPollDuration) {
-    maxPollAttempts = maxPollDuration / pollInterval;
-  }
-  let totalFails = 0;
-
-  const start = function start() {
-    return poll({
-      fn: () => fn(...fnArgs),
-      shouldContinue: (pollContext) => {
-        const { result } = pollContext;
-        const responseStatus = result
-          && result.data
-          && result.data.status;
-
-        const cancelled = isCancel(pollContext.error);
-        // probably a network error
-        const networkFail = pollContext.error && !pollContext.error.response && !cancelled;
-        if (networkFail) {
-          totalFails += 1;
-        }
-        let keepGoing = false;
-        if (isBelowAttemptsLimit(pollContext.attempts, maxPollAttempts) && totalFails < 3) {
-          keepGoing = networkFail || responseStatus === 'RUNNING';
-        }
-        return keepGoing;
-      },
-      interval: pollInterval,
-    });
-  };
-
-  return {
-    start,
-  };
-};
-
-export default createApiPoller;

package/src/createClientCore.js

@@ -1,84 +0,0 @@
-import { allMethods } from './config';
-import createApiClient from './apiClient/createApiClient';
-// we can't get the client config directly from the API client-side because
-// the /api/client-config/ endpoint requires secret
-// import createGetClientConfig from './createGetClientConfig';
-
-const createClientCore = function createClientCore({
-  identificationModules = [],
-  signingModules = [],
-  settings = {},
-  i18n,
-  apiEndpoints,
-  monitoringService,
-} = {}) {
-  const config = { ...settings };
-
-  config.apiEndpoints = apiEndpoints;
-  i18n.setLanguage(config.language);
-
-  const setCountryCode = function setCountryCode(countryCode) {
-    config.countryCode = countryCode;
-  };
-  const getCountryCode = function getCountryCode() {
-    return config.countryCode;
-  };
-  /*
-  const getClientConfig = createGetClientConfig({
-    apiClient: createApiClient(),
-    coreContext: {
-      config,
-    },
-  });
-   */
-
-  const getAllMethods = function getAllMethods() {
-    return allMethods;
-  };
-
-  const installedAuthenticationModules = {};
-  identificationModules.forEach((module) => {
-    const instance = module({
-      coreContext: {
-        config,
-        i18n,
-        monitoringService,
-      },
-      apiClient: createApiClient({
-        modifyRequestSettings: config.modifyRequestSettings,
-      }),
-    });
-    installedAuthenticationModules[instance.MODULE_NAME] = instance;
-  });
-
-  const installedSigningModules = {};
-  signingModules.forEach((module) => {
-    const instance = module({
-      coreContext: {
-        config,
-        i18n,
-        monitoringService,
-      },
-      apiClient: createApiClient({
-        modifyRequestSettings: config.modifyRequestSettings,
-      }),
-    });
-    installedSigningModules[instance.MODULE_NAME] = instance;
-  });
-
-  return Object.freeze({
-    identification: {
-      ...installedAuthenticationModules,
-    },
-    signature: {
-      ...installedSigningModules,
-    },
-    // getClientConfig,
-    getAllMethods,
-    setLanguage: i18n.setLanguage,
-    setCountryCode,
-    getCountryCode,
-  });
-};
-
-export default createClientCore;

package/src/createGetClientConfig.js

@@ -1,14 +0,0 @@
-const createGetClientConfig = function createGetServiceConfig({
-  coreContext,
-  apiClient,
-}) {
-  const { clientId } = coreContext.config;
-  return function getClientConfig() {
-    return apiClient.post({
-      url: `${coreContext.config.apiEndpoints.inCurrentMode.base()}/api/client-config/${clientId}`,
-      withCredentials: false,
-    });
-  };
-};
-
-export default createGetClientConfig;

package/src/createModuleCreator.js

@@ -1,66 +0,0 @@
-import formatError from './formatError';
-import createSettings from './createSettings';
-import coreSettingsSchema from './coreSettingsSchema';
-
-const createModuleCreator = function createModuleCreator(moduleName, executable, methodSettingsSchema = {}) {
-  return function create({
-    coreContext,
-    apiClient,
-  }) {
-    const { i18n, config: coreConfig, monitoringService } = coreContext;
-    const start = function start(userSettings = {}) {
-      const schema = { ...coreSettingsSchema, ...methodSettingsSchema };
-      const fullSettings = { ...coreConfig, ...userSettings };
-      const config = createSettings({
-        rawSettings: fullSettings,
-        schema,
-      });
-
-      const {
-        success,
-        fail,
-        finished,
-      } = config;
-
-      const language = userSettings.language || i18n.getCurrentLanguage();
-      const source = apiClient.CancelToken.source();
-      const cancelToken = source.token;
-
-      const execute = async function execute() {
-        await executable({
-          ...config,
-          language,
-          i18n,
-          monitoringService,
-          cancelToken,
-          apiClient,
-        })
-          .then((result) => {
-            success(result);
-          })
-          .catch((error) => {
-            if (console && console.error) {
-              console.error(error);
-            }
-            fail(formatError(error));
-          })
-          .finally(finished);
-      };
-
-      execute().catch(console.error);
-
-      return Object.freeze({
-        cancel: function cancel() {
-          source.cancel();
-        },
-      });
-    };
-
-    return Object.freeze({
-      MODULE_NAME: moduleName,
-      start,
-    });
-  };
-};
-
-export default createModuleCreator;

package/src/createMonitoringService.js

@@ -1,33 +0,0 @@
-import request from './request';
-
-const createMonitoringService = function createMonitoringService({ remoteMonitoringEnabled, apiEndpoints }) {
-  const dispatch = function dispatch({ message, data = {} }) {
-    if (!remoteMonitoringEnabled) {
-      return;
-    }
-
-    // confirm_progress endpoint doesn't support cors currently
-    // this means we need to avoid OPTIONS request, since if the options request response
-    // has no Access-Control-Allow-Origin, the following POST request gets cancelled and the remote server won't see it
-    // https://stackoverflow.com/questions/29954037/why-is-an-options-request-sent-and-can-i-disable-it
-    const params = new URLSearchParams();
-    params.append('message', message);
-    request({
-      url: apiEndpoints.inCurrentMode.eideasyMonitoring(),
-      method: 'post',
-      cache: 'no-cache',
-      withCredentials: false,
-      headers: {
-        Accept: '*/*',
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      data: params,
-    });
-  };
-
-  return {
-    dispatch,
-  };
-};
-
-export default createMonitoringService;

package/src/createRequestError.js

@@ -1,24 +0,0 @@
-// we're using axios behind the scenes
-// so it makes sense to use a similar request error format
-// for our own api errors as well
-// https://github.com/axios/axios/blob/master/lib/core/createError.js
-const createRequestError = function createRequestError({
-  message,
-  config,
-  code,
-  request,
-  response,
-}) {
-  const error = new Error(message);
-  error.config = config;
-  if (code) {
-    error.code = code;
-  }
-
-  error.request = request;
-  error.response = response;
-  error.isRequestError = true;
-  return error;
-};
-
-export default createRequestError;