@openedx/frontend-base 1.0.0-alpha.9 → 1.0.1-alpha.1

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

@@ -1,23 +0,0 @@
-import { defaultGetBackoffMilliseconds } from './createRetryInterceptor';
-
-describe('createRetryInterceptor: defaultGetBackoffMilliseconds', () => {
-  it('returns a number between 2000 and 3000 on the first retry', () => {
-    const backoffInMilliseconds = defaultGetBackoffMilliseconds(1);
-    expect(backoffInMilliseconds).toBeGreaterThanOrEqual(2000);
-    expect(backoffInMilliseconds).toBeLessThanOrEqual(3000);
-  });
-  it('returns a number between 4000 and 5000 on the second retry', () => {
-    const backoffInMilliseconds = defaultGetBackoffMilliseconds(2);
-    expect(backoffInMilliseconds).toBeGreaterThanOrEqual(4000);
-    expect(backoffInMilliseconds).toBeLessThanOrEqual(5000);
-  });
-  it('returns a number between 8000 and 9000 on the third retry', () => {
-    const backoffInMilliseconds = defaultGetBackoffMilliseconds(3);
-    expect(backoffInMilliseconds).toBeGreaterThanOrEqual(8000);
-    expect(backoffInMilliseconds).toBeLessThanOrEqual(9000);
-  });
-  it('returns 16000 fourth or later retry', () => {
-    const backoffInMilliseconds = defaultGetBackoffMilliseconds(4);
-    expect(backoffInMilliseconds).toEqual(16000);
-  });
-});

package/runtime/auth/interface.js

@@ -1,309 +0,0 @@
-/**
- * #### Import members from **@openedx/frontend-base**
- *
- * Simplifies the process of making authenticated API requests to backend edX services by providing
- * common authN/authZ client code that enables the login/logout flow and handles ensuring the
- * presence of a valid [JWT cookie](https://github.com/openedx/edx-platform/blob/master/openedx/core/djangoapps/oauth_dispatch/docs/decisions/0009-jwt-in-session-cookie.rst).
- *
- * The `initialize` function performs much of the auth configuration for you.  If, however, you're
- * not using the `initialize` function, an authenticated API client can be created via:
- *
- * ```
- * import {
- *   configureAuth,
- *   fetchAuthenticatedUser,
- *   getAuthenticatedHttpClient,
- *   getSiteConfig,
- *   getLoggingService
- * } from '@openedx/frontend-base';
- *
- * configureAuth({
- *   loggingService: getLoggingService(),
- *   config: getSiteConfig(),
- * });
- *
- * const authenticatedUser = await fetchAuthenticatedUser(); // validates and decodes JWT token
- * const authenticatedHttpClient = getAuthenticatedHttpClient();
- * const response = await getAuthenticatedHttpClient().get(`https://example.com/api/user/data/${authenticatedUser.username}`); // fetching from an authenticated API using user data
- * ```
- *
- * As shown in this example, auth depends on the configuration document and logging.
- *
- * NOTE: The documentation for AxiosJwtAuthService is nearly the same as that for the top-level
- * auth interface, except that it contains some Axios-specific details.
- *
- * @module Auth
- */
-import PropTypes from 'prop-types';
-import { publish } from '../subscriptions';
-
-/**
- * @constant
- * @private
- */
-export const AUTHENTICATED_USER_TOPIC = 'AUTHENTICATED_USER';
-
-/**
- * Published when the authenticated user data changes.  This can happen when the authentication
- * service determines that the user is authenticated or anonymous, as well as when we fetch
- * additional user account data if the `hydrateAuthenticatedUser` flag has been set in the
- * `initialize` function.
- *
- * @event
- * @see {@link module:Initialization~initialize}
- */
-export const AUTHENTICATED_USER_CHANGED = `${AUTHENTICATED_USER_TOPIC}.CHANGED`;
-
-const optionsShape = {
-  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,
-};
-
-const serviceShape = {
-  getAuthenticatedHttpClient: PropTypes.func.isRequired,
-  getHttpClient: PropTypes.func.isRequired,
-  getLoginRedirectUrl: PropTypes.func.isRequired,
-  redirectToLogin: PropTypes.func.isRequired,
-  getLogoutRedirectUrl: PropTypes.func.isRequired,
-  redirectToLogout: PropTypes.func.isRequired,
-  getAuthenticatedUser: PropTypes.func.isRequired,
-  setAuthenticatedUser: PropTypes.func.isRequired,
-  fetchAuthenticatedUser: PropTypes.func.isRequired,
-  ensureAuthenticatedUser: PropTypes.func.isRequired,
-  hydrateAuthenticatedUser: PropTypes.func.isRequired,
-};
-
-let service;
-
-/**
- *
- * @param {class} AuthService
- * @param {*} options
- * @returns {AuthService}
- */
-export function configureAuth(AuthService, options) {
-  PropTypes.checkPropTypes(optionsShape, options, 'property', 'Auth');
-  service = new AuthService(options);
-  PropTypes.checkPropTypes(serviceShape, service, 'property', 'AuthService');
-  return service;
-}
-
-/**
- *
- *
- * @returns {AuthService}
- */
-export function getAuthService() {
-  if (!service) {
-    throw Error('You must first configure the auth service.');
-  }
-
-  return service;
-}
-
-/**
- *
- */
-export function resetAuthService() {
-  service = null;
-}
-
-/**
- * Gets the authenticated HTTP client for the service.
- *
- * @param {Object} [options] Optional options for how to configure the authenticated HTTP client
- * @param {boolean} [options.useCache] Whether to use front end caching for all requests made with the returned client
- *
- * @returns {HttpClient}
- */
-export function getAuthenticatedHttpClient(options = {}) {
-  return service.getAuthenticatedHttpClient(options);
-}
-
-/**
- * Gets the unauthenticated HTTP client for the service.
- *
- * @param {Object} [options] Optional options for how to configure the authenticated HTTP client
- * @param {boolean} [options.useCache] Whether to use front end caching for all requests made with the returned client
- *
- * @returns {HttpClient}
- */
-export function getHttpClient(options = {}) {
-  return service.getHttpClient(options);
-}
-
-/**
- * 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.
- */
-export function getLoginRedirectUrl(redirectUrl) {
-  return service.getLoginRedirectUrl(redirectUrl);
-}
-
-/**
- * Redirects the user to the login page.
- *
- * @param {string} redirectUrl The URL the user should be redirected to after logging in.
- */
-export function redirectToLogin(redirectUrl) {
-  return service.redirectToLogin(redirectUrl);
-}
-
-/**
- * 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?redirect_url=http%3A%2F%2Flocalhost%2Fmypage
- * ```
- *
- * @param {string} redirectUrl The URL the user should be redirected to after logging out.
- */
-export function getLogoutRedirectUrl(redirectUrl) {
-  return service.getLogoutRedirectUrl(redirectUrl);
-}
-
-/**
- * Redirects the user to the logout page.
- *
- * @param {string} redirectUrl The URL the user should be redirected to after logging out.
- */
-export function redirectToLogout(redirectUrl) {
-  return service.redirectToLogout(redirectUrl);
-}
-
-/**
- * If it exists, returns the user data representing the currently authenticated user. If the
- * user is anonymous, returns null.
- *
- * @returns {UserData|null}
- */
-export function getAuthenticatedUser() {
-  return service.getAuthenticatedUser();
-}
-
-/**
- * Sets the authenticated user to the provided value.
- *
- * @param {UserData} authUser
- * @emits AUTHENTICATED_USER_CHANGED
- */
-export function setAuthenticatedUser(authUser) {
-  service.setAuthenticatedUser(authUser);
-  publish(AUTHENTICATED_USER_CHANGED);
-}
-
-/**
- * Reads the authenticated user's access token. Resolves to null if the user is
- * unauthenticated.
- *
- * @returns {Promise<UserData>|Promise<null>} Resolves to the user's access token if they are
- * logged in.
- */
-export async function fetchAuthenticatedUser(options = {}) {
-  return service.fetchAuthenticatedUser(options);
-}
-
-/**
- * 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 {Promise<UserData>}
- */
-export async function ensureAuthenticatedUser(redirectUrl) {
-  return service.ensureAuthenticatedUser(redirectUrl);
-}
-
-/**
- * Fetches additional user account information for the authenticated user and merges it into the
- * existing authenticatedUser object, available via getAuthenticatedUser().
- *
- * ```
- *  console.log(authenticatedUser); // Will be sparse and only contain basic information.
- *  await hydrateAuthenticatedUser()
- *  const authenticatedUser = getAuthenticatedUser();
- *  console.log(authenticatedUser); // Will contain additional user information
- * ```
- *
- * @emits AUTHENTICATED_USER_CHANGED
- */
-export async function hydrateAuthenticatedUser() {
-  await service.hydrateAuthenticatedUser();
-  publish(AUTHENTICATED_USER_CHANGED);
-}
-
-/**
- * @name AuthService
- * @interface
- * @memberof module:Auth
- * @property {function} getAuthenticatedHttpClient
- * @property {function} getHttpClient
- * @property {function} getLoginRedirectUrl
- * @property {function} redirectToLogin
- * @property {function} getLogoutRedirectUrl
- * @property {function} redirectToLogout
- * @property {function} getAuthenticatedUser
- * @property {function} setAuthenticatedUser
- * @property {function} fetchAuthenticatedUser
- * @property {function} ensureAuthenticatedUser
- * @property {function} hydrateAuthenticatedUser
- */
-
-/**
- * A configured axios client. See axios docs for more
- * info https://github.com/axios/axios. All the functions
- * below accept isPublic and isCsrfExempt in the request
- * config options. Setting these to true will prevent this
- * client from attempting to refresh the jwt access token
- * or a csrf token respectively.
- *
- * ```
- *  // A public endpoint (no jwt token refresh)
- *  apiClient.get('/path/to/endpoint', { isPublic: true });
- * ```
- *
- * ```
- *  // A csrf exempt endpoint
- *  apiClient.post('/path/to/endpoint', { data }, { isCsrfExempt: true });
- * ```
- *
- * @name HttpClient
- * @interface
- * @memberof module:Auth
- * @property {function} get
- * @property {function} head
- * @property {function} options
- * @property {function} delete (csrf protected)
- * @property {function} post (csrf protected)
- * @property {function} put (csrf protected)
- * @property {function} patch (csrf protected)
- */
-
-/**
- * @name UserData
- * @interface
- * @memberof module:Auth
- * @property {string} userId
- * @property {string} username
- * @property {Array} roles
- * @property {boolean} administrator
- */

package/runtime/auth/utils.js

@@ -1,105 +0,0 @@
-// Lifted from here: https://regexr.com/3ok5o
-const urlRegex = /([a-z]{1,2}tps?):\/\/((?:(?!(?:\/|#|\?|&)).)+)(?:(\/(?:(?:(?:(?!(?:#|\?|&)).)+\/))?))?(?:((?:(?!(?:\.|$|\?|#)).)+))?(?:(\.(?:(?!(?:\?|$|#)).)+))?(?:(\?(?:(?!(?:$|#)).)+))?(?:(#.+))?/;
-const getUrlParts = (url) => {
-  const found = url.match(urlRegex);
-  try {
-    const [
-      fullUrl,
-      protocol,
-      domain,
-      path,
-      endFilename,
-      endFileExtension,
-      query,
-      hash,
-    ] = found;
-
-    return {
-      fullUrl,
-      protocol,
-      domain,
-      path,
-      endFilename,
-      endFileExtension,
-      query,
-      hash,
-    };
-  } catch (e) {
-    throw new Error(`Could not find url parts from ${url}.`);
-  }
-};
-
-const logFrontendAuthError = (loggingService, error) => {
-  const prefixedMessageError = Object.create(error);
-  prefixedMessageError.message = `[frontend-auth] ${error.message}`;
-  loggingService.logError(prefixedMessageError, prefixedMessageError.customAttributes);
-};
-
-const processAxiosError = (axiosErrorObject) => {
-  const error = Object.create(axiosErrorObject);
-  const { request, response, config } = error;
-
-  if (!config) {
-    error.customAttributes = {
-      ...error.customAttributes,
-      httpErrorType: 'unknown-api-request-error',
-    };
-    return error;
-  }
-
-  const {
-    url: httpErrorRequestUrl,
-    method: httpErrorRequestMethod,
-  } = config;
-  /* istanbul ignore else: difficult to enter the request-only error case in a unit test */
-  if (response) {
-    const { status, data } = response;
-    const stringifiedData = JSON.stringify(data) || '(empty response)';
-    const responseIsHTML = stringifiedData.includes('<!DOCTYPE html>');
-    // Don't include data if it is just an HTML document, like a 500 error page.
-    /* istanbul ignore next */
-    const httpErrorResponseData = responseIsHTML ? '<Response is HTML>' : stringifiedData;
-    error.customAttributes = {
-      ...error.customAttributes,
-      httpErrorType: 'api-response-error',
-      httpErrorStatus: status,
-      httpErrorResponseData,
-      httpErrorRequestUrl,
-      httpErrorRequestMethod,
-    };
-    error.message = `Axios Error (Response): ${status} - See custom attributes for details.`;
-  } else if (request) {
-    error.customAttributes = {
-      ...error.customAttributes,
-      httpErrorType: 'api-request-error',
-      httpErrorMessage: error.message,
-      httpErrorRequestUrl,
-      httpErrorRequestMethod,
-    };
-    // This case occurs most likely because of intermittent internet connection issues
-    // but it also, though less often, catches CORS or server configuration problems.
-    error.message = 'Axios Error (Request): (Possible local connectivity issue.) See custom attributes for details.';
-  } else {
-    error.customAttributes = {
-      ...error.customAttributes,
-      httpErrorType: 'api-request-config-error',
-      httpErrorMessage: error.message,
-      httpErrorRequestUrl,
-      httpErrorRequestMethod,
-    };
-    error.message = 'Axios Error (Config): See custom attributes for details.';
-  }
-
-  return error;
-};
-
-const processAxiosErrorAndThrow = (axiosErrorObject) => {
-  throw processAxiosError(axiosErrorObject);
-};
-
-export {
-  getUrlParts,
-  logFrontendAuthError,
-  processAxiosError,
-  processAxiosErrorAndThrow
-};

package/runtime/babel.config.js

@@ -1,3 +0,0 @@
-const config = require('../tools/babel/babel.config');
-
-module.exports = config;

package/runtime/config/getExternalLinkUrl.test.js

@@ -1,76 +0,0 @@
-import { getExternalLinkUrl, setSiteConfig } from '.';
-
-describe('getExternalLinkUrl', () => {
-  afterEach(() => {
-    // Reset config after each test to avoid cross-test pollution
-    setSiteConfig({});
-  });
-
-  it('should return the url passed in when externalLinkUrlOverrides is not set', () => {
-    setSiteConfig({});
-    const url = 'https://foo.example.com';
-    expect(getExternalLinkUrl(url)).toBe(url);
-  });
-
-  it('should return the url passed in when externalLinkUrlOverrides does not have the url mapping', () => {
-    setSiteConfig({
-      externalLinkUrlOverrides: {
-        'https://bar.example.com': 'https://mapped.example.com',
-      },
-    });
-    const url = 'https://foo.example.com';
-    expect(getExternalLinkUrl(url)).toBe(url);
-  });
-
-  it('should return the mapped url when externalLinkUrlOverrides has the url mapping', () => {
-    const url = 'https://foo.example.com';
-    const mappedUrl = 'https://mapped.example.com';
-    setSiteConfig({ externalLinkUrlOverrides: { [url]: mappedUrl } });
-    expect(getExternalLinkUrl(url)).toBe(mappedUrl);
-  });
-
-  it('should handle empty externalLinkUrlOverrides object', () => {
-    setSiteConfig({ externalLinkUrlOverrides: {} });
-    const url = 'https://foo.example.com';
-    expect(getExternalLinkUrl(url)).toBe(url);
-  });
-
-  it('should guard against empty string argument', () => {
-    const fallbackResult = '#';
-    setSiteConfig({ externalLinkUrlOverrides: { foo: 'bar' } });
-    expect(getExternalLinkUrl(undefined)).toBe(fallbackResult);
-  });
-
-  it('should guard against non-string argument', () => {
-    const fallbackResult = '#';
-    setSiteConfig({ externalLinkUrlOverrides: { foo: 'bar' } });
-    expect(getExternalLinkUrl(null)).toBe(fallbackResult);
-    expect(getExternalLinkUrl(42)).toBe(fallbackResult);
-  });
-
-  it('should not throw if externalLinkUrlOverrides is not an object', () => {
-    setSiteConfig({ externalLinkUrlOverrides: null });
-    const url = 'https://foo.example.com';
-    expect(getExternalLinkUrl(url)).toBe(url);
-    setSiteConfig({ externalLinkUrlOverrides: 42 });
-    expect(getExternalLinkUrl(url)).toBe(url);
-  });
-
-  it('should work with multiple mappings', () => {
-    setSiteConfig({
-      externalLinkUrlOverrides: {
-        'https://a.example.com': 'https://mapped-a.example.com',
-        'https://b.example.com': 'https://mapped-b.example.com',
-      },
-    });
-    expect(getExternalLinkUrl('https://a.example.com')).toBe(
-      'https://mapped-a.example.com',
-    );
-    expect(getExternalLinkUrl('https://b.example.com')).toBe(
-      'https://mapped-b.example.com',
-    );
-    expect(getExternalLinkUrl('https://c.example.com')).toBe(
-      'https://c.example.com',
-    );
-  });
-});