@openedx/frontend-base 1.0.0-alpha.12 → 1.0.0-alpha.13

package/dist/runtime/auth/MockAuthService.js

@@ -0,0 +1,256 @@
+import axios from 'axios';
+import PropTypes from 'prop-types';
+const userPropTypes = PropTypes.shape({
+    userId: PropTypes.string.isRequired,
+    username: PropTypes.string.isRequired,
+    roles: PropTypes.arrayOf(PropTypes.string),
+    administrator: PropTypes.boolean,
+});
+const optionsPropTypes = {
+    config: PropTypes.shape({
+        baseUrl: PropTypes.string.isRequired,
+        lmsBaseUrl: PropTypes.string.isRequired,
+        loginUrl: PropTypes.string.isRequired,
+        logoutUrl: PropTypes.string.isRequired,
+        refreshAccessTokenApiPath: PropTypes.string.isRequired,
+        accessTokenCookieName: PropTypes.string.isRequired,
+        csrfTokenApiPath: PropTypes.string.isRequired,
+    }).isRequired,
+    loggingService: PropTypes.shape({
+        logError: PropTypes.func.isRequired,
+        logInfo: PropTypes.func.isRequired,
+    }).isRequired,
+    // The absence of authenticatedUser means the user is anonymous.
+    authenticatedUser: userPropTypes,
+    // Must be at least a valid user, but may have other fields.
+    hydratedAuthenticatedUser: userPropTypes,
+};
+/**
+ * The MockAuthService class mocks authenticated user-fetching logic and allows for manually
+ * setting user data.  It is compatible with axios-mock-adapter to wrap its HttpClients so that
+ * they can be mocked for testing.
+ *
+ * It wraps all methods of the service with Jest mock functions (jest.fn()).  This allows test code
+ * to assert expectations on all functions of the service while preserving sensible behaviors.  For
+ * instance, the login/logout methods related to redirecting maintain their real behavior.
+ *
+ * This service is NOT suitable for use in an application itself - only tests.  It depends on Jest,
+ * which should only be a dev dependency of your project.  You don't want to pull the entire suite
+ * of test dependencies into your application at runtime, probably even in your dev server.
+ *
+ * In a test where you would like to mock out API requests - perhaps from a redux-thunk function -
+ * you could do the following to set up a MockAuthService for your test:
+ *
+ * ```
+ * import { getSiteConfig, mergeSiteConfig, configureAuth, MockAuthService } from '@openedx/frontend-base';
+ * import MockAdapter from 'axios-mock-adapter';
+ *
+ * const mockLoggingService = {
+ *   logInfo: jest.fn(),
+ *   logError: jest.fn(),
+ * };
+ * mergeSiteConfig({
+ *   authenticatedUser: {
+ *     userId: 'abc123',
+ *     username: 'Mock User',
+ *     roles: [],
+ *     administrator: false,
+ *   },
+ * });
+ * configureAuth(MockAuthService, { config: getSiteConfig(), loggingService: mockLoggingService });
+ * const mockAdapter = new MockAdapter(getAuthenticatedHttpClient());
+ * // Mock calls for your tests.  This configuration can be done in any sort of test setup.
+ * mockAdapter.onGet(...);
+ * ```
+ *
+ * Also see the `initializeMockApp` function which also automatically uses mock services for
+ * Logging and Analytics.
+ *
+ * @implements {AuthService}
+ * @memberof module:Auth
+ */
+class MockAuthService {
+    /**
+     * @param {Object} options
+     * @param {Object} options.config
+     * @param {string} options.config.baseUrl
+     * @param {string} options.config.lmsBaseUrl
+     * @param {string} options.config.loginUrl
+     * @param {string} options.config.logoutUrl
+     * @param {string} options.config.refreshAccessTokenApiPath
+     * @param {string} options.config.accessTokenCookieName
+     * @param {string} options.config.csrfTokenApiPath
+     * @param {Object} options.loggingService requires logError and logInfo methods
+     */
+    constructor(options) {
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Gets the authenticated HTTP client instance, which is an axios client wrapped in
+         * MockAdapter from axios-mock-adapter.
+         *
+         * @returns {HttpClient} An HttpClient wrapped in MockAdapter.
+         */
+        this.getAuthenticatedHttpClient = jest.fn(() => this.authenticatedHttpClient);
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Gets the unauthenticated HTTP client instance, which is an axios client wrapped in
+         * MockAdapter from axios-mock-adapter.
+         *
+         * @returns {HttpClient} An HttpClient wrapped in MockAdapter.
+         */
+        this.getHttpClient = jest.fn(() => this.httpClient);
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Builds a URL to the login page with a post-login redirect URL attached as a query parameter.
+         *
+         * ```
+         * const url = getLoginRedirectUrl('http://localhost/mypage');
+         * console.log(url); // http://localhost/login?next=http%3A%2F%2Flocalhost%2Fmypage
+         * ```
+         *
+         * @param {string} redirectUrl The URL the user should be redirected to after logging in.
+         */
+        this.getLoginRedirectUrl = jest.fn((redirectUrl = this.config.baseUrl) => `${this.config.loginUrl}?next=${encodeURIComponent(redirectUrl)}`);
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Redirects the user to the logout page in the real implementation.  Is a no-op here.
+         *
+         * @param {string} redirectUrl The URL the user should be redirected to after logging in.
+         */
+        this.redirectToLogin = jest.fn((redirectUrl = this.config.baseUrl) => {
+            // Do nothing after getting the URL - this preserves the calls properly, but doesn't redirect.
+            this.getLoginRedirectUrl(redirectUrl);
+        });
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Builds a URL to the logout page with a post-logout redirect URL attached as a query parameter.
+         *
+         * ```
+         * const url = getLogoutRedirectUrl('http://localhost/mypage');
+         * console.log(url); // http://localhost/logout?next=http%3A%2F%2Flocalhost%2Fmypage
+         * ```
+         *
+         * @param {string} redirectUrl The URL the user should be redirected to after logging out.
+         */
+        this.getLogoutRedirectUrl = jest.fn((redirectUrl = this.config.baseUrl) => `${this.config.logoutUrl}?redirect_url=${encodeURIComponent(redirectUrl)}`);
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Redirects the user to the logout page in the real implementation.  Is a no-op here.
+         *
+         * @param {string} redirectUrl The URL the user should be redirected to after logging out.
+         */
+        this.redirectToLogout = jest.fn((redirectUrl = this.config.baseUrl) => {
+            // Do nothing after getting the URL - this preserves the calls properly, but doesn't redirect.
+            this.getLogoutRedirectUrl(redirectUrl);
+        });
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * If it exists, returns the user data representing the currently authenticated user. If the
+         * user is anonymous, returns null.
+         *
+         * @returns {UserData|null}
+         */
+        this.getAuthenticatedUser = jest.fn(() => this.authenticatedUser);
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Sets the authenticated user to the provided value.
+         *
+         * @param {UserData} authUser
+         */
+        this.setAuthenticatedUser = jest.fn((authUser) => {
+            this.authenticatedUser = authUser;
+        });
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Returns the current authenticated user details, as supplied in the `authenticatedUser` field
+         * of the config options.  Resolves to null if the user is unauthenticated / the config option
+         * has not been set.
+         *
+         * @returns {UserData|null} Resolves to the user's access token if they are
+         * logged in.
+         */
+        this.fetchAuthenticatedUser = jest.fn(() => this.getAuthenticatedUser());
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Ensures a user is authenticated. It will redirect to login when not authenticated.
+         *
+         * @param {string} [redirectUrl=config.baseUrl] to return user after login when not
+         * authenticated.
+         * @returns {UserData|null} Resolves to the user's access token if they are
+         * logged in.
+         */
+        this.ensureAuthenticatedUser = jest.fn((redirectUrl = this.config.baseUrl) => {
+            this.fetchAuthenticatedUser();
+            if (this.getAuthenticatedUser() === null) {
+                // The user is not authenticated, send them to the login page.
+                this.redirectToLogin(redirectUrl);
+            }
+            return this.getAuthenticatedUser();
+        });
+        /**
+         * A Jest mock function (jest.fn())
+         *
+         * Adds the user data supplied in the `hydratedAuthenticatedUser` config option into the object
+         * returned by `getAuthenticatedUser`.  This emulates the behavior of a real auth service which
+         * would make a request to fetch this data prior to merging it in.
+         *
+         * ```
+         * console.log(authenticatedUser); // Will be sparse and only contain basic information.
+         * await hydrateAuthenticatedUser()
+         * const authenticatedUser = getAuthenticatedUser();
+         * console.log(authenticatedUser); // Will contain additional user information
+         * ```
+         *
+         * @returns {Promise<null>}
+         */
+        this.hydrateAuthenticatedUser = jest.fn(() => {
+            const user = this.getAuthenticatedUser();
+            if (user !== null) {
+                this.setAuthenticatedUser(Object.assign(Object.assign({}, user), this.hydratedAuthenticatedUser));
+            }
+        });
+        this.authenticatedHttpClient = null;
+        this.httpClient = null;
+        PropTypes.checkPropTypes(optionsPropTypes, options, 'options', 'AuthService');
+        this.config = options.config;
+        this.loggingService = options.loggingService;
+        // Mock user
+        this.authenticatedUser = null;
+        this.hydratedAuthenticatedUser = {};
+        this.authenticatedHttpClient = axios.create();
+        this.httpClient = axios.create();
+    }
+    /**
+     * A Jest mock function (jest.fn())
+     *
+     * Applies middleware to the axios instances in this service.
+     *
+     * @param {Array} middleware Middleware to apply.
+     */
+    applyMiddleware(middleware = []) {
+        const clients = [
+            this.authenticatedHttpClient, this.httpClient,
+            this.cachedAuthenticatedHttpClient, this.cachedHttpClient,
+        ];
+        try {
+            (middleware).forEach((middlewareFn) => {
+                clients.forEach((client) => client && middlewareFn(client));
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to apply middleware: ${error.message}.`);
+        }
+    }
+}
+export default MockAuthService;
+//# sourceMappingURL=MockAuthService.js.map

package/dist/runtime/auth/MockAuthService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockAuthService.js","sourceRoot":"","sources":["../../../runtime/auth/MockAuthService.js"],"names":[],"mappings":"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","sourcesContent":["import axios from 'axios';\nimport PropTypes from 'prop-types';\n\nconst userPropTypes = PropTypes.shape({\n  userId: PropTypes.string.isRequired,\n  username: PropTypes.string.isRequired,\n  roles: PropTypes.arrayOf(PropTypes.string),\n  administrator: PropTypes.boolean,\n});\n\nconst optionsPropTypes = {\n  config: PropTypes.shape({\n    baseUrl: PropTypes.string.isRequired,\n    lmsBaseUrl: PropTypes.string.isRequired,\n    loginUrl: PropTypes.string.isRequired,\n    logoutUrl: PropTypes.string.isRequired,\n    refreshAccessTokenApiPath: PropTypes.string.isRequired,\n    accessTokenCookieName: PropTypes.string.isRequired,\n    csrfTokenApiPath: PropTypes.string.isRequired,\n  }).isRequired,\n  loggingService: PropTypes.shape({\n    logError: PropTypes.func.isRequired,\n    logInfo: PropTypes.func.isRequired,\n  }).isRequired,\n  // The absence of authenticatedUser means the user is anonymous.\n  authenticatedUser: userPropTypes,\n  // Must be at least a valid user, but may have other fields.\n  hydratedAuthenticatedUser: userPropTypes,\n};\n\n/**\n * The MockAuthService class mocks authenticated user-fetching logic and allows for manually\n * setting user data.  It is compatible with axios-mock-adapter to wrap its HttpClients so that\n * they can be mocked for testing.\n *\n * It wraps all methods of the service with Jest mock functions (jest.fn()).  This allows test code\n * to assert expectations on all functions of the service while preserving sensible behaviors.  For\n * instance, the login/logout methods related to redirecting maintain their real behavior.\n *\n * This service is NOT suitable for use in an application itself - only tests.  It depends on Jest,\n * which should only be a dev dependency of your project.  You don't want to pull the entire suite\n * of test dependencies into your application at runtime, probably even in your dev server.\n *\n * In a test where you would like to mock out API requests - perhaps from a redux-thunk function -\n * you could do the following to set up a MockAuthService for your test:\n *\n * ```\n * import { getSiteConfig, mergeSiteConfig, configureAuth, MockAuthService } from '@openedx/frontend-base';\n * import MockAdapter from 'axios-mock-adapter';\n *\n * const mockLoggingService = {\n *   logInfo: jest.fn(),\n *   logError: jest.fn(),\n * };\n * mergeSiteConfig({\n *   authenticatedUser: {\n *     userId: 'abc123',\n *     username: 'Mock User',\n *     roles: [],\n *     administrator: false,\n *   },\n * });\n * configureAuth(MockAuthService, { config: getSiteConfig(), loggingService: mockLoggingService });\n * const mockAdapter = new MockAdapter(getAuthenticatedHttpClient());\n * // Mock calls for your tests.  This configuration can be done in any sort of test setup.\n * mockAdapter.onGet(...);\n * ```\n *\n * Also see the `initializeMockApp` function which also automatically uses mock services for\n * Logging and Analytics.\n *\n * @implements {AuthService}\n * @memberof module:Auth\n */\nclass MockAuthService {\n  /**\n   * @param {Object} options\n   * @param {Object} options.config\n   * @param {string} options.config.baseUrl\n   * @param {string} options.config.lmsBaseUrl\n   * @param {string} options.config.loginUrl\n   * @param {string} options.config.logoutUrl\n   * @param {string} options.config.refreshAccessTokenApiPath\n   * @param {string} options.config.accessTokenCookieName\n   * @param {string} options.config.csrfTokenApiPath\n   * @param {Object} options.loggingService requires logError and logInfo methods\n   */\n  constructor(options) {\n    this.authenticatedHttpClient = null;\n    this.httpClient = null;\n\n    PropTypes.checkPropTypes(optionsPropTypes, options, 'options', 'AuthService');\n\n    this.config = options.config;\n    this.loggingService = options.loggingService;\n\n    // Mock user\n    this.authenticatedUser = null;\n    this.hydratedAuthenticatedUser = {};\n\n    this.authenticatedHttpClient = axios.create();\n    this.httpClient = axios.create();\n  }\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Applies middleware to the axios instances in this service.\n   *\n   * @param {Array} middleware Middleware to apply.\n   */\n  applyMiddleware(middleware = []) {\n    const clients = [\n      this.authenticatedHttpClient, this.httpClient,\n      this.cachedAuthenticatedHttpClient, this.cachedHttpClient,\n    ];\n    try {\n      (middleware).forEach((middlewareFn) => {\n        clients.forEach((client) => client && middlewareFn(client));\n      });\n    } catch (error) {\n      throw new Error(`Failed to apply middleware: ${error.message}.`);\n    }\n  }\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Gets the authenticated HTTP client instance, which is an axios client wrapped in\n   * MockAdapter from axios-mock-adapter.\n   *\n   * @returns {HttpClient} An HttpClient wrapped in MockAdapter.\n   */\n  getAuthenticatedHttpClient = jest.fn(() => this.authenticatedHttpClient);\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Gets the unauthenticated HTTP client instance, which is an axios client wrapped in\n   * MockAdapter from axios-mock-adapter.\n   *\n   * @returns {HttpClient} An HttpClient wrapped in MockAdapter.\n   */\n  getHttpClient = jest.fn(() => this.httpClient);\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Builds a URL to the login page with a post-login redirect URL attached as a query parameter.\n   *\n   * ```\n   * const url = getLoginRedirectUrl('http://localhost/mypage');\n   * console.log(url); // http://localhost/login?next=http%3A%2F%2Flocalhost%2Fmypage\n   * ```\n   *\n   * @param {string} redirectUrl The URL the user should be redirected to after logging in.\n   */\n  getLoginRedirectUrl = jest.fn(\n    (redirectUrl = this.config.baseUrl) => `${this.config.loginUrl}?next=${encodeURIComponent(redirectUrl)}`,\n  );\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Redirects the user to the logout page in the real implementation.  Is a no-op here.\n   *\n   * @param {string} redirectUrl The URL the user should be redirected to after logging in.\n   */\n  redirectToLogin = jest.fn((redirectUrl = this.config.baseUrl) => {\n    // Do nothing after getting the URL - this preserves the calls properly, but doesn't redirect.\n    this.getLoginRedirectUrl(redirectUrl);\n  });\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Builds a URL to the logout page with a post-logout redirect URL attached as a query parameter.\n   *\n   * ```\n   * const url = getLogoutRedirectUrl('http://localhost/mypage');\n   * console.log(url); // http://localhost/logout?next=http%3A%2F%2Flocalhost%2Fmypage\n   * ```\n   *\n   * @param {string} redirectUrl The URL the user should be redirected to after logging out.\n   */\n  getLogoutRedirectUrl = jest.fn((redirectUrl = this.config.baseUrl) => `${this.config.logoutUrl}?redirect_url=${encodeURIComponent(redirectUrl)}`);\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Redirects the user to the logout page in the real implementation.  Is a no-op here.\n   *\n   * @param {string} redirectUrl The URL the user should be redirected to after logging out.\n   */\n  redirectToLogout = jest.fn((redirectUrl = this.config.baseUrl) => {\n    // Do nothing after getting the URL - this preserves the calls properly, but doesn't redirect.\n    this.getLogoutRedirectUrl(redirectUrl);\n  });\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * If it exists, returns the user data representing the currently authenticated user. If the\n   * user is anonymous, returns null.\n   *\n   * @returns {UserData|null}\n   */\n  getAuthenticatedUser = jest.fn(() => this.authenticatedUser);\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Sets the authenticated user to the provided value.\n   *\n   * @param {UserData} authUser\n   */\n  setAuthenticatedUser = jest.fn((authUser) => {\n    this.authenticatedUser = authUser;\n  });\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Returns the current authenticated user details, as supplied in the `authenticatedUser` field\n   * of the config options.  Resolves to null if the user is unauthenticated / the config option\n   * has not been set.\n   *\n   * @returns {UserData|null} Resolves to the user's access token if they are\n   * logged in.\n   */\n  fetchAuthenticatedUser = jest.fn(() => this.getAuthenticatedUser());\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Ensures a user is authenticated. It will redirect to login when not authenticated.\n   *\n   * @param {string} [redirectUrl=config.baseUrl] to return user after login when not\n   * authenticated.\n   * @returns {UserData|null} Resolves to the user's access token if they are\n   * logged in.\n   */\n  ensureAuthenticatedUser = jest.fn((redirectUrl = this.config.baseUrl) => {\n    this.fetchAuthenticatedUser();\n\n    if (this.getAuthenticatedUser() === null) {\n      // The user is not authenticated, send them to the login page.\n      this.redirectToLogin(redirectUrl);\n    }\n\n    return this.getAuthenticatedUser();\n  });\n\n  /**\n   * A Jest mock function (jest.fn())\n   *\n   * Adds the user data supplied in the `hydratedAuthenticatedUser` config option into the object\n   * returned by `getAuthenticatedUser`.  This emulates the behavior of a real auth service which\n   * would make a request to fetch this data prior to merging it in.\n   *\n   * ```\n   * console.log(authenticatedUser); // Will be sparse and only contain basic information.\n   * await hydrateAuthenticatedUser()\n   * const authenticatedUser = getAuthenticatedUser();\n   * console.log(authenticatedUser); // Will contain additional user information\n   * ```\n   *\n   * @returns {Promise<null>}\n   */\n  hydrateAuthenticatedUser = jest.fn(() => {\n    const user = this.getAuthenticatedUser();\n    if (user !== null) {\n      this.setAuthenticatedUser({ ...user, ...this.hydratedAuthenticatedUser });\n    }\n  });\n}\n\nexport default MockAuthService;\n"]}

package/dist/runtime/auth/index.d.ts

@@ -0,0 +1,3 @@
+export { default as AxiosJwtAuthService } from './AxiosJwtAuthService';
+export { AUTHENTICATED_USER_CHANGED, AUTHENTICATED_USER_TOPIC, configureAuth, ensureAuthenticatedUser, fetchAuthenticatedUser, getAuthenticatedHttpClient, getAuthenticatedUser, getAuthService, getHttpClient, getLoginRedirectUrl, getLogoutRedirectUrl, hydrateAuthenticatedUser, redirectToLogin, redirectToLogout, setAuthenticatedUser } from './interface';
+export { default as MockAuthService } from './MockAuthService';

package/dist/runtime/auth/index.js

@@ -0,0 +1,4 @@
+export { default as AxiosJwtAuthService } from './AxiosJwtAuthService';
+export { AUTHENTICATED_USER_CHANGED, AUTHENTICATED_USER_TOPIC, configureAuth, ensureAuthenticatedUser, fetchAuthenticatedUser, getAuthenticatedHttpClient, getAuthenticatedUser, getAuthService, getHttpClient, getLoginRedirectUrl, getLogoutRedirectUrl, hydrateAuthenticatedUser, redirectToLogin, redirectToLogout, setAuthenticatedUser } from './interface';
+export { default as MockAuthService } from './MockAuthService';
+//# sourceMappingURL=index.js.map

package/dist/runtime/auth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../runtime/auth/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,oBAAoB,EACpB,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,wBAAwB,EACxB,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC","sourcesContent":["export { default as AxiosJwtAuthService } from './AxiosJwtAuthService';\nexport {\n  AUTHENTICATED_USER_CHANGED,\n  AUTHENTICATED_USER_TOPIC,\n  configureAuth,\n  ensureAuthenticatedUser,\n  fetchAuthenticatedUser,\n  getAuthenticatedHttpClient,\n  getAuthenticatedUser,\n  getAuthService,\n  getHttpClient,\n  getLoginRedirectUrl,\n  getLogoutRedirectUrl,\n  hydrateAuthenticatedUser,\n  redirectToLogin,\n  redirectToLogout,\n  setAuthenticatedUser\n} from './interface';\nexport { default as MockAuthService } from './MockAuthService';\n"]}

package/dist/runtime/auth/interceptors/createCsrfTokenProviderInterceptor.d.ts

@@ -0,0 +1,2 @@
+export default createCsrfTokenProviderInterceptor;
+declare function createCsrfTokenProviderInterceptor(options: any): (axiosRequestConfig: any) => Promise<any>;

package/dist/runtime/auth/interceptors/createCsrfTokenProviderInterceptor.js

@@ -0,0 +1,42 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const createCsrfTokenProviderInterceptor = (options) => {
+    const { csrfTokenService, csrfTokenApiPath, shouldSkip } = options;
+    // Creating the interceptor inside this closure to
+    // maintain reference to the options supplied.
+    const interceptor = (axiosRequestConfig) => __awaiter(void 0, void 0, void 0, function* () {
+        if (shouldSkip(axiosRequestConfig)) {
+            return axiosRequestConfig;
+        }
+        const { url } = axiosRequestConfig;
+        let csrfToken;
+        // Important: the job of this interceptor is to get a csrf token and update
+        // the original request configuration. Errors thrown getting the csrf token
+        // should contain the original request config. This allows other interceptors
+        // (namely our retry request interceptor below) to access the original request
+        // and handle it appropriately
+        try {
+            csrfToken = yield csrfTokenService.getCsrfToken(url, csrfTokenApiPath);
+        }
+        catch (error) {
+            const requestError = Object.create(error);
+            requestError.message = `[getCsrfToken] ${requestError.message}`;
+            // Important: return the original axios request config
+            requestError.config = axiosRequestConfig;
+            return Promise.reject(requestError);
+        }
+        const CSRF_HEADER_NAME = 'X-CSRFToken';
+        axiosRequestConfig.headers[CSRF_HEADER_NAME] = csrfToken;
+        return axiosRequestConfig;
+    });
+    return interceptor;
+};
+export default createCsrfTokenProviderInterceptor;
+//# sourceMappingURL=createCsrfTokenProviderInterceptor.js.map

package/dist/runtime/auth/interceptors/createCsrfTokenProviderInterceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCsrfTokenProviderInterceptor.js","sourceRoot":"","sources":["../../../../runtime/auth/interceptors/createCsrfTokenProviderInterceptor.js"],"names":[],"mappings":";;;;;;;;;AAAA,MAAM,kCAAkC,GAAG,CAAC,OAAO,EAAE,EAAE;IACrD,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAEnE,kDAAkD;IAClD,8CAA8C;IAC9C,MAAM,WAAW,GAAG,CAAO,kBAAkB,EAAE,EAAE;QAC/C,IAAI,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAC;YACnC,OAAO,kBAAkB,CAAC;QAC5B,CAAC;QACD,MAAM,EAAE,GAAG,EAAE,GAAG,kBAAkB,CAAC;QACnC,IAAI,SAAS,CAAC;QAEd,2EAA2E;QAC3E,2EAA2E;QAC3E,6EAA6E;QAC7E,8EAA8E;QAC9E,8BAA8B;QAC9B,IAAI,CAAC;YACH,SAAS,GAAG,MAAM,gBAAgB,CAAC,YAAY,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;QACzE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC1C,YAAY,CAAC,OAAO,GAAG,kBAAkB,YAAY,CAAC,OAAO,EAAE,CAAC;YAChE,sDAAsD;YACtD,YAAY,CAAC,MAAM,GAAG,kBAAkB,CAAC;YACzC,OAAO,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACtC,CAAC;QAED,MAAM,gBAAgB,GAAG,aAAa,CAAC;QACvC,kBAAkB,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC;QACzD,OAAO,kBAAkB,CAAC;IAC5B,CAAC,CAAA,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF,eAAe,kCAAkC,CAAC","sourcesContent":["const createCsrfTokenProviderInterceptor = (options) => {\n  const { csrfTokenService, csrfTokenApiPath, shouldSkip } = options;\n\n  // Creating the interceptor inside this closure to\n  // maintain reference to the options supplied.\n  const interceptor = async (axiosRequestConfig) => {\n    if (shouldSkip(axiosRequestConfig)) {\n      return axiosRequestConfig;\n    }\n    const { url } = axiosRequestConfig;\n    let csrfToken;\n\n    // Important: the job of this interceptor is to get a csrf token and update\n    // the original request configuration. Errors thrown getting the csrf token\n    // should contain the original request config. This allows other interceptors\n    // (namely our retry request interceptor below) to access the original request\n    // and handle it appropriately\n    try {\n      csrfToken = await csrfTokenService.getCsrfToken(url, csrfTokenApiPath);\n    } catch (error) {\n      const requestError = Object.create(error);\n      requestError.message = `[getCsrfToken] ${requestError.message}`;\n      // Important: return the original axios request config\n      requestError.config = axiosRequestConfig;\n      return Promise.reject(requestError);\n    }\n\n    const CSRF_HEADER_NAME = 'X-CSRFToken';\n    axiosRequestConfig.headers[CSRF_HEADER_NAME] = csrfToken;\n    return axiosRequestConfig;\n  };\n\n  return interceptor;\n};\n\nexport default createCsrfTokenProviderInterceptor;\n"]}

package/dist/runtime/auth/interceptors/createJwtTokenProviderInterceptor.d.ts

@@ -0,0 +1,2 @@
+export default createJwtTokenProviderInterceptor;
+declare function createJwtTokenProviderInterceptor(options: any): (axiosRequestConfig: any) => Promise<any>;

package/dist/runtime/auth/interceptors/createJwtTokenProviderInterceptor.js

@@ -0,0 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const createJwtTokenProviderInterceptor = (options) => {
+    const { jwtTokenService, shouldSkip, } = options;
+    // Creating the interceptor inside this closure to
+    // maintain reference to the options supplied.
+    const interceptor = (axiosRequestConfig) => __awaiter(void 0, void 0, void 0, function* () {
+        if (shouldSkip(axiosRequestConfig)) {
+            return axiosRequestConfig;
+        }
+        // Important: the job of this interceptor is to refresh a jwt token and update
+        // the original request configuration. Errors thrown from fetching the jwt
+        // should contain the original request config. This allows other interceptors
+        // (namely our retry request interceptor below) to access the original request
+        // and handle it appropriately
+        try {
+            yield jwtTokenService.getJwtToken();
+        }
+        catch (error) {
+            const requestError = Object.create(error);
+            requestError.message = `[getJwtToken] ${requestError.message}`;
+            // Important: return the original axios request config
+            requestError.config = axiosRequestConfig;
+            return Promise.reject(requestError);
+        }
+        // Add the proper headers to tell the server to look for the jwt cookie
+        axiosRequestConfig.headers['USE-JWT-COOKIE'] = true;
+        return axiosRequestConfig;
+    });
+    return interceptor;
+};
+export default createJwtTokenProviderInterceptor;
+//# sourceMappingURL=createJwtTokenProviderInterceptor.js.map

package/dist/runtime/auth/interceptors/createJwtTokenProviderInterceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJwtTokenProviderInterceptor.js","sourceRoot":"","sources":["../../../../runtime/auth/interceptors/createJwtTokenProviderInterceptor.js"],"names":[],"mappings":";;;;;;;;;AAAA,MAAM,iCAAiC,GAAG,CAAC,OAAO,EAAE,EAAE;IACpD,MAAM,EACJ,eAAe,EACf,UAAU,GACX,GAAG,OAAO,CAAC;IAEZ,kDAAkD;IAClD,8CAA8C;IAC9C,MAAM,WAAW,GAAG,CAAO,kBAAkB,EAAE,EAAE;QAC/C,IAAI,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAC;YACnC,OAAO,kBAAkB,CAAC;QAC5B,CAAC;QAED,8EAA8E;QAC9E,0EAA0E;QAC1E,6EAA6E;QAC7E,8EAA8E;QAC9E,8BAA8B;QAC9B,IAAI,CAAC;YACH,MAAM,eAAe,CAAC,WAAW,EAAE,CAAC;QACtC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC1C,YAAY,CAAC,OAAO,GAAG,iBAAiB,YAAY,CAAC,OAAO,EAAE,CAAC;YAC/D,sDAAsD;YACtD,YAAY,CAAC,MAAM,GAAG,kBAAkB,CAAC;YACzC,OAAO,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACtC,CAAC;QAED,uEAAuE;QACvE,kBAAkB,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC;QACpD,OAAO,kBAAkB,CAAC;IAC5B,CAAC,CAAA,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF,eAAe,iCAAiC,CAAC","sourcesContent":["const createJwtTokenProviderInterceptor = (options) => {\n  const {\n    jwtTokenService,\n    shouldSkip,\n  } = options;\n\n  // Creating the interceptor inside this closure to\n  // maintain reference to the options supplied.\n  const interceptor = async (axiosRequestConfig) => {\n    if (shouldSkip(axiosRequestConfig)) {\n      return axiosRequestConfig;\n    }\n\n    // Important: the job of this interceptor is to refresh a jwt token and update\n    // the original request configuration. Errors thrown from fetching the jwt\n    // should contain the original request config. This allows other interceptors\n    // (namely our retry request interceptor below) to access the original request\n    // and handle it appropriately\n    try {\n      await jwtTokenService.getJwtToken();\n    } catch (error) {\n      const requestError = Object.create(error);\n      requestError.message = `[getJwtToken] ${requestError.message}`;\n      // Important: return the original axios request config\n      requestError.config = axiosRequestConfig;\n      return Promise.reject(requestError);\n    }\n\n    // Add the proper headers to tell the server to look for the jwt cookie\n    axiosRequestConfig.headers['USE-JWT-COOKIE'] = true;\n    return axiosRequestConfig;\n  };\n\n  return interceptor;\n};\n\nexport default createJwtTokenProviderInterceptor;\n"]}

package/dist/runtime/auth/interceptors/createProcessAxiosRequestErrorInterceptor.d.ts

@@ -0,0 +1,2 @@
+export default createProcessAxiosRequestErrorInterceptor;
+declare function createProcessAxiosRequestErrorInterceptor(options: any): (error: any) => Promise<never>;

package/dist/runtime/auth/interceptors/createProcessAxiosRequestErrorInterceptor.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { processAxiosError } from '../utils';
+const createProcessAxiosRequestErrorInterceptor = (options) => {
+    const { loggingService } = options;
+    // Creating the interceptor inside this closure to
+    // maintain reference to the options supplied.
+    const interceptor = (error) => __awaiter(void 0, void 0, void 0, function* () {
+        const processedError = processAxiosError(error);
+        const { httpErrorStatus } = processedError.customAttributes;
+        if (httpErrorStatus === 401 || httpErrorStatus === 403) {
+            loggingService.logInfo(processedError.message, processedError.customAttributes);
+        }
+        return Promise.reject(processedError);
+    });
+    return interceptor;
+};
+export default createProcessAxiosRequestErrorInterceptor;
+//# sourceMappingURL=createProcessAxiosRequestErrorInterceptor.js.map

package/dist/runtime/auth/interceptors/createProcessAxiosRequestErrorInterceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createProcessAxiosRequestErrorInterceptor.js","sourceRoot":"","sources":["../../../../runtime/auth/interceptors/createProcessAxiosRequestErrorInterceptor.js"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,yCAAyC,GAAG,CAAC,OAAO,EAAE,EAAE;IAC5D,MAAM,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;IAEnC,kDAAkD;IAClD,8CAA8C;IAC9C,MAAM,WAAW,GAAG,CAAO,KAAK,EAAE,EAAE;QAClC,MAAM,cAAc,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAChD,MAAM,EAAE,eAAe,EAAE,GAAG,cAAc,CAAC,gBAAgB,CAAC;QAC5D,IAAI,eAAe,KAAK,GAAG,IAAI,eAAe,KAAK,GAAG,EAAE,CAAC;YACvD,cAAc,CAAC,OAAO,CAAC,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,gBAAgB,CAAC,CAAC;QAClF,CAAC;QACD,OAAO,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC,CAAA,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF,eAAe,yCAAyC,CAAC","sourcesContent":["import { processAxiosError } from '../utils';\n\nconst createProcessAxiosRequestErrorInterceptor = (options) => {\n  const { loggingService } = options;\n\n  // Creating the interceptor inside this closure to\n  // maintain reference to the options supplied.\n  const interceptor = async (error) => {\n    const processedError = processAxiosError(error);\n    const { httpErrorStatus } = processedError.customAttributes;\n    if (httpErrorStatus === 401 || httpErrorStatus === 403) {\n      loggingService.logInfo(processedError.message, processedError.customAttributes);\n    }\n    return Promise.reject(processedError);\n  };\n\n  return interceptor;\n};\n\nexport default createProcessAxiosRequestErrorInterceptor;\n"]}

package/dist/runtime/auth/interceptors/createRetryInterceptor.d.ts

@@ -0,0 +1,3 @@
+export default createRetryInterceptor;
+declare function createRetryInterceptor(options?: {}): (error: any) => Promise<any>;
+export function defaultGetBackoffMilliseconds(nthRetry: any, maximumBackoffMilliseconds?: number): number;

package/dist/runtime/auth/interceptors/createRetryInterceptor.js

@@ -0,0 +1,67 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import axios from 'axios';
+// This default algorithm is a recreation of what is documented here
+// https://cloud.google.com/storage/docs/exponential-backoff
+const defaultGetBackoffMilliseconds = (nthRetry, maximumBackoffMilliseconds = 16000) => {
+    // Retry at exponential intervals (2, 4, 8, 16...)
+    const exponentialBackoffSeconds = Math.pow(2, nthRetry);
+    // Add some randomness to avoid sending retries from separate requests all at once
+    const randomFractionOfASecond = Math.random();
+    const backoffSeconds = exponentialBackoffSeconds + randomFractionOfASecond;
+    const backoffMilliseconds = Math.round(backoffSeconds * 1000);
+    return Math.min(backoffMilliseconds, maximumBackoffMilliseconds);
+};
+const createRetryInterceptor = (options = {}) => {
+    const { httpClient = axios.create(), getBackoffMilliseconds = defaultGetBackoffMilliseconds, 
+    // By default only retry outbound request failures (not responses)
+    shouldRetry = (error) => {
+        const isRequestError = !error.response && error.config;
+        return isRequestError;
+    }, 
+    // A per-request maxRetries can be specified in request config.
+    defaultMaxRetries = 2, } = options;
+    const interceptor = (error) => __awaiter(void 0, void 0, void 0, function* () {
+        const { config } = error;
+        // If no config exists there was some other error setting up the request
+        if (!config) {
+            return Promise.reject(error);
+        }
+        if (!shouldRetry(error)) {
+            return Promise.reject(error);
+        }
+        const { maxRetries = defaultMaxRetries, } = config;
+        const retryRequest = (nthRetry) => __awaiter(void 0, void 0, void 0, function* () {
+            if (nthRetry > maxRetries) {
+                // Reject with the original error
+                return Promise.reject(error);
+            }
+            let retryResponse;
+            try {
+                const backoffDelay = getBackoffMilliseconds(nthRetry);
+                // Delay (wrapped in a promise so we can await the setTimeout)
+                yield new Promise(resolve => {
+                    setTimeout(resolve, backoffDelay);
+                });
+                // Make retry request
+                retryResponse = yield httpClient.request(config);
+            }
+            catch (e) {
+                return retryRequest(nthRetry + 1);
+            }
+            return retryResponse;
+        });
+        return retryRequest(1);
+    });
+    return interceptor;
+};
+export default createRetryInterceptor;
+export { defaultGetBackoffMilliseconds };
+//# sourceMappingURL=createRetryInterceptor.js.map

package/dist/runtime/auth/interceptors/createRetryInterceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRetryInterceptor.js","sourceRoot":"","sources":["../../../../runtime/auth/interceptors/createRetryInterceptor.js"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,oEAAoE;AACpE,4DAA4D;AAC5D,MAAM,6BAA6B,GAAG,CAAC,QAAQ,EAAE,0BAA0B,GAAG,KAAK,EAAE,EAAE;IACrF,kDAAkD;IAClD,MAAM,yBAAyB,GAAG,SAAA,CAAC,EAAI,QAAQ,CAAA,CAAC;IAChD,kFAAkF;IAClF,MAAM,uBAAuB,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;IAC9C,MAAM,cAAc,GAAG,yBAAyB,GAAG,uBAAuB,CAAC;IAC3E,MAAM,mBAAmB,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC9D,OAAO,IAAI,CAAC,GAAG,CAAC,mBAAmB,EAAE,0BAA0B,CAAC,CAAC;AACnE,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAAC,OAAO,GAAG,EAAE,EAAE,EAAE;IAC9C,MAAM,EACJ,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,EAC3B,sBAAsB,GAAG,6BAA6B;IACtD,kEAAkE;IAClE,WAAW,GAAG,CAAC,KAAK,EAAE,EAAE;QACtB,MAAM,cAAc,GAAG,CAAC,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC;QACvD,OAAO,cAAc,CAAC;IACxB,CAAC;IACD,+DAA+D;IAC/D,iBAAiB,GAAG,CAAC,GACtB,GAAG,OAAO,CAAC;IAEZ,MAAM,WAAW,GAAG,CAAO,KAAK,EAAE,EAAE;QAClC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QAEzB,wEAAwE;QACxE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,MAAM,EACJ,UAAU,GAAG,iBAAiB,GAC/B,GAAG,MAAM,CAAC;QAEX,MAAM,YAAY,GAAG,CAAO,QAAQ,EAAE,EAAE;YACtC,IAAI,QAAQ,GAAG,UAAU,EAAE,CAAC;gBAC1B,iCAAiC;gBACjC,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;YAED,IAAI,aAAa,CAAC;YAElB,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;gBACtD,8DAA8D;gBAC9D,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;oBAC1B,UAAU,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;gBACpC,CAAC,CAAC,CAAC;gBACH,qBAAqB;gBACrB,aAAa,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACnD,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,YAAY,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;YACpC,CAAC;YAED,OAAO,aAAa,CAAC;QACvB,CAAC,CAAA,CAAC;QAEF,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;IACzB,CAAC,CAAA,CAAC;IAEF,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAEF,eAAe,sBAAsB,CAAC;AACtC,OAAO,EAAE,6BAA6B,EAAE,CAAC","sourcesContent":["import axios from 'axios';\n\n// This default algorithm is a recreation of what is documented here\n// https://cloud.google.com/storage/docs/exponential-backoff\nconst defaultGetBackoffMilliseconds = (nthRetry, maximumBackoffMilliseconds = 16000) => {\n  // Retry at exponential intervals (2, 4, 8, 16...)\n  const exponentialBackoffSeconds = 2 ** nthRetry;\n  // Add some randomness to avoid sending retries from separate requests all at once\n  const randomFractionOfASecond = Math.random();\n  const backoffSeconds = exponentialBackoffSeconds + randomFractionOfASecond;\n  const backoffMilliseconds = Math.round(backoffSeconds * 1000);\n  return Math.min(backoffMilliseconds, maximumBackoffMilliseconds);\n};\n\nconst createRetryInterceptor = (options = {}) => {\n  const {\n    httpClient = axios.create(),\n    getBackoffMilliseconds = defaultGetBackoffMilliseconds,\n    // By default only retry outbound request failures (not responses)\n    shouldRetry = (error) => {\n      const isRequestError = !error.response && error.config;\n      return isRequestError;\n    },\n    // A per-request maxRetries can be specified in request config.\n    defaultMaxRetries = 2,\n  } = options;\n\n  const interceptor = async (error) => {\n    const { config } = error;\n\n    // If no config exists there was some other error setting up the request\n    if (!config) {\n      return Promise.reject(error);\n    }\n\n    if (!shouldRetry(error)) {\n      return Promise.reject(error);\n    }\n\n    const {\n      maxRetries = defaultMaxRetries,\n    } = config;\n\n    const retryRequest = async (nthRetry) => {\n      if (nthRetry > maxRetries) {\n        // Reject with the original error\n        return Promise.reject(error);\n      }\n\n      let retryResponse;\n\n      try {\n        const backoffDelay = getBackoffMilliseconds(nthRetry);\n        // Delay (wrapped in a promise so we can await the setTimeout)\n        await new Promise(resolve => {\n          setTimeout(resolve, backoffDelay);\n        });\n        // Make retry request\n        retryResponse = await httpClient.request(config);\n      } catch (e) {\n        return retryRequest(nthRetry + 1);\n      }\n\n      return retryResponse;\n    };\n\n    return retryRequest(1);\n  };\n\n  return interceptor;\n};\n\nexport default createRetryInterceptor;\nexport { defaultGetBackoffMilliseconds };\n"]}