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

package/runtime/analytics/interface.js

@@ -1,145 +0,0 @@
-/**
- * #### Import members from **@openedx/frontend-base** Analytics
- *
- * Contains a shared interface for tracking events.  Has a default implementation of
- * SegmentAnalyticsService, which supports Segment and the Tracking Log API (hosted in LMS).
- *
- * The `initialize` function performs much of the analytics configuration for you.  If, however,
- * you're not using the `initialize` function, analytics can be configured via:
- *
- * ```
- * import {
- *   getSiteConfig,
- *   getAuthenticatedHttpClient,
- *   getLoggingService,
- *   configureAnalytics,
- *   SegmentAnalyticsService
- * } from '@openedx/frontend-base';
- *
- * configureAnalytics(SegmentAnalyticsService, {
- *   config: getSiteConfig(),
- *   loggingService: getLoggingService(),
- *   httpClient: getAuthenticatedHttpClient(),
- * });
- * ```
- *
- * As shown in this example, analytics depends on the configuration document, logging, and having
- * an authenticated HTTP client.
- *
- * @module Analytics
- */
-import PropTypes from 'prop-types';
-
-const optionsShape = {
-  config: PropTypes.object.isRequired,
-  httpClient: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
-  loggingService: PropTypes.shape({
-    logError: PropTypes.func.isRequired,
-    logInfo: PropTypes.func.isRequired,
-  }).isRequired,
-};
-
-const serviceShape = {
-  sendTrackingLogEvent: PropTypes.func.isRequired,
-  identifyAuthenticatedUser: PropTypes.func.isRequired,
-  identifyAnonymousUser: PropTypes.func.isRequired,
-  sendTrackEvent: PropTypes.func.isRequired,
-  sendPageEvent: PropTypes.func.isRequired,
-};
-
-let service;
-
-/**
- *
- * @param {class} AnalyticsService
- * @param {*} options
- * @returns {AnalyticsService}
- */
-export function configureAnalytics(AnalyticsService, options) {
-  PropTypes.checkPropTypes(optionsShape, options, 'property', 'Analytics');
-  service = new AnalyticsService(options);
-  PropTypes.checkPropTypes(serviceShape, service, 'property', 'AnalyticsService');
-  return service;
-}
-
-/**
- *
- * @param {*} eventName
- * @param {*} properties
- * @returns {Promise}
- */
-export function sendTrackingLogEvent(eventName, properties) {
-  return service.sendTrackingLogEvent(eventName, properties);
-}
-
-/**
- *
- *
- * @param {*} userId
- * @param {*} traits
- */
-export function identifyAuthenticatedUser(userId, traits) {
-  service.identifyAuthenticatedUser(userId, traits);
-}
-
-/**
- *
- *
- * @param {*} traits
- * @returns {Promise}
- */
-export function identifyAnonymousUser(traits) {
-  return service.identifyAnonymousUser(traits);
-}
-
-/**
- *
- *
- * @param {*} eventName
- * @param {*} properties
- */
-export function sendTrackEvent(eventName, properties) {
-  service.sendTrackEvent(eventName, properties);
-}
-
-/**
- *
- *
- * @param {*} category
- * @param {*} name
- * @param {*} properties
- */
-export function sendPageEvent(category, name, properties) {
-  service.sendPageEvent(category, name, properties);
-}
-
-/**
- *
- *
- * @returns {AnalyticsService}
- */
-export function getAnalyticsService() {
-  if (!service) {
-    throw Error('You must first configure the analytics service.');
-  }
-
-  return service;
-}
-
-/**
- *
- */
-export function resetAnalyticsService() {
-  service = null;
-}
-
-/**
- * @name AnalyticsService
- * @interface
- * @memberof module:Analytics
- * @property {function} identifyAnonymousUser
- * @property {function} identifyAuthenticatedUser
- * @property {function} sendPageEvent
- * @property {function} sendTrackEvent
- * @property {function} sendTrackingLogEvent
- */

package/runtime/analytics/interface.test.js

@@ -1,242 +0,0 @@
-import {
-  configureAnalytics,
-  identifyAnonymousUser,
-  identifyAuthenticatedUser,
-  sendPageEvent,
-  sendTrackEvent,
-  sendTrackingLogEvent,
-  SegmentAnalyticsService,
-} from './index';
-
-const eventType = 'test.event';
-const eventData = {
-  testShallow: 'test-shallow',
-  testObject: {
-    testDeep: 'test-deep',
-  },
-};
-const testUserId = 99;
-const mockLoggingService = {
-  logError: jest.fn(),
-  logInfo: jest.fn(),
-};
-// The actual ApiClient is a function, so while this feels weird, it accurately models the real
-// thing.
-const mockAuthApiClient = () => {
-};
-mockAuthApiClient.post = jest.fn().mockResolvedValue(undefined);
-
-// SegmentAnalyticsService inserts a script before the first script element
-// in the document. Add one here.
-document.body.innerHTML = '<script id="stub" />';
-
-describe('Analytics', () => {
-  let service;
-  let userIdFunction;
-
-  beforeEach(() => {
-    window.analytics = [];
-  });
-
-  function afterConfigure() {
-    mockLoggingService.logError.mockReset();
-    mockAuthApiClient.post.mockReset();
-    mockAuthApiClient.post.mockResolvedValue(undefined);
-    window.analytics.identify = jest.fn();
-    window.analytics.page = jest.fn();
-    window.analytics.track = jest.fn();
-    window.analytics.reset = jest.fn();
-    userIdFunction = jest.fn();
-    window.analytics.user = jest.fn(() => ({
-      id: userIdFunction,
-    }));
-    window.analytics.ready = jest.fn((callback) => {
-      if (callback) {
-        callback();
-      }
-    });
-  }
-
-  describe('with valid segmentKey', () => {
-    beforeEach(() => {
-      service = configureAnalytics(SegmentAnalyticsService, {
-        loggingService: mockLoggingService,
-        httpClient: mockAuthApiClient,
-        config: {
-          lmsBaseUrl: 'https://example.com',
-          segmentKey: 'test-key',
-        },
-      });
-
-      afterConfigure();
-
-      expect(global.analytics.invoked).toBe(true);
-      expect(service.segmentInitialized).toBe(true);
-    });
-
-    describe('analytics sendTrackingLogEvent', () => {
-      it('posts expected data when successful', () => {
-        expect.assertions(6);
-        return sendTrackingLogEvent(eventType, eventData)
-          .then(() => {
-            expect(mockAuthApiClient.post.mock.calls.length).toEqual(1);
-            expect(mockAuthApiClient.post.mock.calls[0][0]).toEqual('https://example.com/event');
-            const expectedData = 'event_type=test.event&event=%7B%22test_shallow%22%3A%22test-shallow%22%2C%22test_object%22%3A%7B%22test_deep%22%3A%22test-deep%22%7D%7D&page=http%3A%2F%2Flocalhost%2F';
-            expect(mockAuthApiClient.post.mock.calls[0][1]).toEqual(expectedData);
-            const config = mockAuthApiClient.post.mock.calls[0][2];
-            expect(config.headers['Content-Type']).toEqual('application/x-www-form-urlencoded');
-          });
-      });
-
-      it('calls loggingService.logError on error', () => {
-        mockAuthApiClient.post.mockRejectedValue('test-error');
-        expect.assertions(4);
-        return sendTrackingLogEvent(eventType, eventData)
-          .then(() => {
-            expect(mockLoggingService.logError.mock.calls.length).toBe(1);
-            expect(mockLoggingService.logError).toBeCalledWith('test-error');
-          });
-      });
-    });
-
-    describe('analytics identifyAuthenticatedUser', () => {
-      it('calls Segment identify on success', () => {
-        const testTraits = { anything: 'Yay!' };
-        identifyAuthenticatedUser(testUserId, testTraits);
-
-        expect(window.analytics.identify.mock.calls.length).toBe(1);
-        expect(window.analytics.identify).toBeCalledWith(testUserId, testTraits);
-      });
-
-      it('throws error if userId is not supplied', () => {
-        expect(() => identifyAuthenticatedUser(null))
-          .toThrowError(new Error('UserId is required for identifyAuthenticatedUser.'));
-      });
-    });
-
-    describe('analytics identifyAnonymousUser', () => {
-      it('does not call segment reset for no previous segment user', () => {
-        window.analytics.user = () => ({ id: () => null });
-        const testTraits = { anything: 'Yay!' };
-        identifyAnonymousUser(testTraits);
-
-        expect(window.analytics.reset.mock.calls.length).toBe(0);
-      });
-
-      it('calls segment reset for a previous segment user', () => {
-        window.analytics.user = () => ({ id: () => 7 });
-        const testTraits = { anything: 'Yay!' };
-        identifyAnonymousUser(testTraits);
-
-        expect(window.analytics.reset.mock.calls.length).toBe(1);
-      });
-    });
-
-    function testSendPageAfterIdentify(identifyFunction) {
-      identifyFunction();
-
-      const testCategory = 'test-category';
-      const testName = 'test-name';
-      const testProperties = { anything: 'Yay!' };
-      sendPageEvent(testCategory, testName, testProperties);
-
-      expect(window.analytics.page.mock.calls.length).toBe(1);
-      expect(window.analytics.page).toBeCalledWith(testCategory, testName, testProperties);
-    }
-
-    describe('analytics send Page event', () => {
-      it('calls Segment page on success after identifyAuthenticatedUser', () => {
-        const userId = 1;
-        testSendPageAfterIdentify(() => identifyAuthenticatedUser(userId));
-      });
-
-      it('calls Segment page on success after identifyAnonymousUser', () => {
-        testSendPageAfterIdentify(identifyAnonymousUser);
-      });
-
-      it('fails if page called with no identify', () => {
-        sendPageEvent();
-
-        expect(mockLoggingService.logError.mock.calls.length).toBe(1);
-        expect(mockLoggingService.logError).toBeCalledWith('Identify must be called before other tracking events.');
-      });
-    });
-
-    function testSendTrackEventAfterIdentify(identifyFunction) {
-      identifyFunction();
-
-      const testName = 'test-name';
-      const testProperties = { anything: 'Yay!' };
-      sendTrackEvent(testName, testProperties);
-
-      expect(window.analytics.track.mock.calls.length).toBe(1);
-      expect(window.analytics.track).toBeCalledWith(testName, testProperties);
-    }
-
-    describe('analytics send Track event', () => {
-      it('calls Segment track on success after identifyAuthenticatedUser', () => {
-        const userId = 1;
-        testSendTrackEventAfterIdentify(() => identifyAuthenticatedUser(userId));
-      });
-
-      it('calls Segment track on success after identifyAnonymousUser', () => {
-        testSendTrackEventAfterIdentify(identifyAnonymousUser);
-      });
-
-      it('fails if track called with no identify', () => {
-        sendTrackEvent();
-
-        expect(mockLoggingService.logError.mock.calls.length).toBe(1);
-        expect(mockLoggingService.logError).toBeCalledWith('Identify must be called before other tracking events.');
-      });
-    });
-  });
-
-  describe('with invalid segmentKey', () => {
-    beforeEach(() => {
-      service = configureAnalytics(SegmentAnalyticsService, {
-        loggingService: mockLoggingService,
-        httpClient: mockAuthApiClient,
-        config: {
-          lmsBaseUrl: 'https://example.com',
-          segmentKey: '',
-        },
-      });
-
-      afterConfigure();
-    });
-
-    it('should not initialize Segment analytics', () => {
-      expect(global.analytics.invoked).toBeFalsy();
-      expect(service.segmentInitialized).toBe(false);
-    });
-
-    it('should not call segment track in sendTrackEvent', () => {
-      sendTrackEvent();
-      expect(window.analytics.track).not.toHaveBeenCalled();
-    });
-
-    it('should not call segment page in sendPageEvent', () => {
-      sendPageEvent();
-      expect(window.analytics.page).not.toHaveBeenCalled();
-    });
-
-    it('should not call ready, user, reset, or identify in identifyAnonymousUser', () => {
-      identifyAnonymousUser();
-
-      expect(window.analytics.ready).not.toHaveBeenCalled();
-      expect(window.analytics.user).not.toHaveBeenCalled();
-      expect(userIdFunction).not.toHaveBeenCalled();
-      expect(window.analytics.reset).not.toHaveBeenCalled();
-      expect(window.analytics.identify).not.toHaveBeenCalled();
-      expect(service.hasIdentifyBeenCalled).toBe(false);
-    });
-
-    it('should not call identify in identifyAuthenticatedUser', () => {
-      identifyAuthenticatedUser(testUserId);
-
-      expect(window.analytics.identify).not.toHaveBeenCalled();
-      expect(service.hasIdentifyBeenCalled).toBe(false);
-    });
-  });
-});

package/runtime/auth/AxiosCsrfTokenService.js

@@ -1,60 +0,0 @@
-import axios from 'axios';
-import { getUrlParts, processAxiosErrorAndThrow } from './utils';
-
-export default class AxiosCsrfTokenService {
-  constructor(csrfTokenApiPath) {
-    this.csrfTokenApiPath = csrfTokenApiPath;
-    this.httpClient = axios.create();
-    // Set withCredentials to true. Enables cross-site Access-Control requests
-    // to be made using cookies, authorization headers or TLS client
-    // certificates. More on MDN:
-    // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials
-    this.httpClient.defaults.withCredentials = true;
-    this.httpClient.defaults.headers['USE-JWT-COOKIE'] = true;
-
-    this.csrfTokenCache = {};
-    this.csrfTokenRequestPromises = {};
-  }
-
-  async getCsrfToken(url) {
-    let urlParts;
-    try {
-      urlParts = getUrlParts(url);
-    } catch (e) {
-      // If the url is not parsable it's likely because a relative
-      // path was supplied as the url. This is acceptable and in
-      // this case we should use the current origin of the page.
-      urlParts = getUrlParts(global.location.origin);
-    }
-
-    const { protocol, domain } = urlParts;
-    const csrfToken = this.csrfTokenCache[domain];
-
-    if (csrfToken) {
-      return csrfToken;
-    }
-
-    if (!this.csrfTokenRequestPromises[domain]) {
-      this.csrfTokenRequestPromises[domain] = this.httpClient
-        .get(`${protocol}://${domain}${this.csrfTokenApiPath}`)
-        .then((response) => {
-          this.csrfTokenCache[domain] = response.data.csrfToken;
-          return this.csrfTokenCache[domain];
-        })
-        .catch(processAxiosErrorAndThrow)
-        .finally(() => {
-          delete this.csrfTokenRequestPromises[domain];
-        });
-    }
-
-    return this.csrfTokenRequestPromises[domain];
-  }
-
-  clearCsrfTokenCache() {
-    this.csrfTokenCache = {};
-  }
-
-  getHttpClient() {
-    return this.httpClient;
-  }
-}