noibu-react-native 0.2.3 → 0.2.5

package/dist/monitors/gqlErrorValidator.js

@@ -1,306 +0,0 @@
-import { CONTENT_TYPE, SEVERITY } from '../constants.js';
-import { isInstanceOf, getMaxSubstringAllowed } from '../utils/function.js';
-import ClientConfig from '../api/clientConfig.js';
-
-const MESSAGE_ATT_NAME = 'message';
-const EXTENSIONS_ATT_NAME = 'extensions';
-const LOCATIONS_ATT_NAME = 'locations';
-const PATH_ATT_NAME = 'path';
-const LINE_ATT_NAME = 'line';
-const COLUMN_ATT_NAME = 'column';
-const MESSAGE_MAX_LENGTH = 1000;
-
-/* eslint-disable no-restricted-syntax */
-/* eslint-disable no-param-reassign */
-
-/**
- * Try detecting GraphQL errors from http response
- */
-class GqlErrorValidator {
-  /**
-   * Retrieves GQL error object based on fetch request/response
-   * @param {String} url
-   * @param {{}} [options]
-   * @param {Request} [request]
-   * @param {Response} [response] - cloned() from original response
-   */
-  static async fromFetch(url, options, request, response) {
-    try {
-      const isResponseValid = isInstanceOf(response, Response) && response.ok;
-      if (!isResponseValid) {
-        return null;
-      }
-      const contentType = this._getContentTypeFromFetchArguments(
-        options,
-        request,
-      );
-      if (this._shouldHandleRequest(url, contentType)) {
-        const data = await response.json();
-        return this._validate(data, []);
-      }
-    } catch (e) {
-      // can't read the response if request is aborted
-      // so just ignore it
-      if (!this._isRequestAborted(options, request)) {
-        this._postError(e);
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Retrieves GQL error object based on XHR object
-   * @param {String} url
-   * @param {XMLHttpRequest} xhr
-   */
-  static async fromXhr(url, xhr) {
-    try {
-      const isResponseValid =
-        isInstanceOf(xhr, XMLHttpRequest) &&
-        xhr.status >= 200 &&
-        xhr.status <= 299;
-      if (!isResponseValid) {
-        return null;
-      }
-      let contentType = null;
-      if (xhr.noibuRequestHeaders) {
-        contentType = xhr.noibuRequestHeaders.get(CONTENT_TYPE);
-      }
-      if (this._shouldHandleRequest(url, contentType)) {
-        let data = null;
-        if (xhr.responseType === 'blob') {
-          if (xhr.response.text) {
-            const content = await xhr.response.text();
-            data = this._parseJsonSafely(content);
-          }
-        } else if (xhr.responseType === 'json') {
-          data = xhr.response;
-        } else {
-          const content = xhr.responseText;
-          data = this._parseJsonSafely(content);
-        }
-        if (data) {
-          return this._validate(data, []);
-        }
-      }
-    } catch (e) {
-      this._postError(e);
-    }
-
-    return null;
-  }
-
-  /**
-   * Try safely parse a string and return null if fails
-   * @param {String} content
-   */
-  static _parseJsonSafely(content) {
-    try {
-      return JSON.parse(content);
-    } catch (e) {
-      return null;
-    }
-  }
-
-  /**
-   * Try to get content type for fetch arguments
-   * @param {{}} options
-   * @param {Request} [request]
-   */
-  static _getContentTypeFromFetchArguments(options, request) {
-    let headers = null;
-    if (isInstanceOf(request, Request)) {
-      headers = request.headers;
-    } else if (options && options.headers) {
-      headers = new Headers(options.headers);
-    }
-    let contentType = null;
-    if (headers) {
-      contentType = headers.get(CONTENT_TYPE);
-    }
-    return contentType;
-  }
-
-  /**
-   * Checks if request is aborted
-   * If it has been aborder we are not able to consume the response
-   * @param {{}} options
-   * @param {Request} request
-   */
-  static _isRequestAborted(options, request) {
-    if (isInstanceOf(request, Request)) {
-      return request.signal && request.signal.aborted;
-    }
-    if (options && isInstanceOf(options.signal, AbortSignal)) {
-      return options.signal.aborted;
-    }
-    return false;
-  }
-
-  /**
-   * Determines if request should be processed
-   * @param {String|URL} url
-   * @param {String} contentType
-   */
-  static _shouldHandleRequest(url, contentType) {
-    if (contentType) {
-      contentType = contentType.toLowerCase();
-    }
-    let isGqlUrl = false;
-    if (url) {
-      if (isInstanceOf(url, URL)) {
-        url = url.toString();
-      }
-      isGqlUrl = url.toLowerCase().includes('graphql');
-    }
-    return (
-      (contentType === 'application/json' && isGqlUrl) ||
-      contentType === 'application/graphql'
-    );
-  }
-
-  /**
-   * Sanitizes payload object
-   * @param {any} data
-   * @param {Array<String>} validationIssues
-   */
-  static _validate(data, validationIssues) {
-    let errors = null;
-
-    if (data && Array.isArray(data.errors)) {
-      errors = data.errors;
-
-      for (const error of errors) {
-        const properties = Object.keys(error);
-        for (const property of properties) {
-          switch (property) {
-            case MESSAGE_ATT_NAME:
-              this._validateMessage(error);
-              break;
-            case LOCATIONS_ATT_NAME:
-              this._validateLocations(error, validationIssues);
-              break;
-            case PATH_ATT_NAME:
-              this._validatePath(error, validationIssues);
-              break;
-            case EXTENSIONS_ATT_NAME:
-              this._validateExtensions(error);
-              break;
-            default:
-              delete error[property];
-              validationIssues.push(`unexpected error.${property}`);
-              break;
-          }
-        }
-      }
-
-      if (validationIssues.length > 0) {
-        this._postValidationIssues(validationIssues);
-      }
-    }
-
-    return errors;
-  }
-
-  /**
-   * Sanitizes message object
-   * @param {any} error
-   */
-  static _validateMessage(error) {
-    error[MESSAGE_ATT_NAME] = getMaxSubstringAllowed(
-      error[MESSAGE_ATT_NAME],
-      MESSAGE_MAX_LENGTH,
-    );
-  }
-
-  /**
-   * Sanitizes extensions object
-   * @param {any} error
-   * @param {Array<String>} validationIssues
-   */
-  static _validateExtensions(error) {
-    const json = JSON.stringify(error[EXTENSIONS_ATT_NAME]);
-    error[EXTENSIONS_ATT_NAME] = getMaxSubstringAllowed(
-      json,
-      MESSAGE_MAX_LENGTH,
-    );
-  }
-
-  /**
-   * Sanitizes locations object
-   * @param {any} error
-   * @param {Array<String>} validationIssues
-   */
-  static _validateLocations(error, validationIssues) {
-    const locations = error[LOCATIONS_ATT_NAME];
-    if (Array.isArray(locations)) {
-      for (const location of locations) {
-        const properties = Object.keys(location);
-        for (const property of properties) {
-          switch (property) {
-            case LINE_ATT_NAME:
-            case COLUMN_ATT_NAME:
-              if (!Number.isSafeInteger(location[property])) {
-                const value = location[property];
-                location[property] = 0;
-                validationIssues.push(
-                  `unexpected ${property} value '${value}'`,
-                );
-              }
-              break;
-            default:
-              delete location[property];
-              validationIssues.push(`unexpected error.location.${property}`);
-              break;
-          }
-        }
-      }
-    } else {
-      delete error[LOCATIONS_ATT_NAME];
-      validationIssues.push(`unexpected error.locations`);
-    }
-  }
-
-  /**
-   * Sanitizes path object
-   * @param {any} error
-   * @param {Array<String>} validationIssues
-   */
-  static _validatePath(error, validationIssues) {
-    const path = error[PATH_ATT_NAME];
-    if (Array.isArray(path)) {
-      error[PATH_ATT_NAME] = error[PATH_ATT_NAME].map(x => x.toString());
-    } else {
-      delete error[PATH_ATT_NAME];
-      validationIssues.push(`unexpected error.path`);
-    }
-  }
-
-  /**
-   * Posts error
-   * @param {String} message
-   */
-  static _postError(message) {
-    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-      `GQL parse error: ${message}`,
-      false,
-      SEVERITY.error,
-    );
-  }
-
-  /**
-   * Posts issue found during object sanitization
-   * @param {Array<String>} validationIssues
-   */
-  static _postValidationIssues(validationIssues) {
-    const message = validationIssues.join(',');
-    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-      `GQL error validation warning: ${message}`,
-      false,
-      SEVERITY.error,
-    );
-  }
-}
-
-export { GqlErrorValidator as default };

package/dist/monitors/inputMonitor.js

@@ -1,138 +0,0 @@
-import { PageVisit } from '../pageVisit/pageVisit.js';
-import { APP_NAVIGATION_EVENT_TYPE, PAGE_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS, ERROR_EVENT_TYPE, HTTP_EVENT_TYPE, KEYBOARD_EVENT_TYPE, USERSTEP_EVENT_TYPE } from '../constants.js';
-import { timestampWrapper } from '../utils/date.js';
-import { addSafeEventListener } from '../utils/eventlistener.js';
-import { noibuLog } from '../utils/log.js';
-
-/** @module InputMonitor */
-
-/**
- * Singleton class to manage the client configuration
- * this class will be responsible for debouncing all events
- * that are registered
- */
-class InputMonitor {
-  /**
-   * Creates an instance of InputMonitor
-   */
-  constructor() {
-    // events are stored in queues that are debounced seperatly
-    // each object in this map is
-    // type: {
-    //   timeout: timeout,
-    //   events: [...],
-    //   debouncePeriod: period at which we debounce events,
-    //   eventName: name of the event, could be different than type
-    //      (clicks and keyboards are usersteps)
-    // }
-    this.eventsToDebounce = {};
-
-    // setting up debouncers for all events
-    // we send clicks directly to the socket so they aren't registered here
-    // we dont wait to send location changes, they happen at most once per second.
-    this.registerInputType(APP_NAVIGATION_EVENT_TYPE, 0);
-    this.registerInputType(PAGE_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-    this.registerInputType(ERROR_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-    this.registerInputType(HTTP_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-    this.registerInputType(
-      KEYBOARD_EVENT_TYPE,
-      MAX_TIME_FOR_UNSENT_DATA_MILLIS,
-      USERSTEP_EVENT_TYPE,
-    );
-
-    this._setupUnloadHandler();
-  }
-
-  /**
-   * gets the instance of InputMonitor
-   * @returns {InputMonitor}
-   */
-  static getInstance() {
-    if (!this.instance) {
-      this.instance = new InputMonitor();
-    }
-
-    return this.instance;
-  }
-
-  /** will debounce all events that are of this type by the debounce period
-   * @param  {} type
-   * @param  {} debouncePeriod
-   * @param  {} eventName=type
-   */
-  registerInputType(type, debouncePeriod, eventName = type) {
-    if (type in this.eventsToDebounce) {
-      return;
-    }
-
-    // registering this event type as a debouncable
-    this.eventsToDebounce[type] = {
-      timeout: null,
-      events: [],
-      debouncePeriod,
-      eventName,
-    };
-  }
-
-  /**
-   * Creates an event object with the event and the time it was added then pushes
-   * that event object to the queue of events waiting to be debounced.
-   * @param  {} event
-   * @param  {} type
-   */
-  addEvent(event, type) {
-    noibuLog('addEvent', {
-      event,
-      type,
-    });
-    if (!(type in this.eventsToDebounce)) {
-      throw new Error(`Type: ${type} is not in eventsToDebounce`);
-    }
-
-    this.eventsToDebounce[type].events.push({
-      event,
-      occurredAt: new Date(timestampWrapper(Date.now())).toISOString(),
-    });
-
-    this._debouncePvEvents(type);
-  }
-
-  /**
-   * Adds the events from the object to the page visit and sets up a timer
-   * to send the events if no more are received without the timeout
-   * @param  {} type
-   */
-  _debouncePvEvents(type) {
-    /**
-     * Debounce function to be executed once the debounce period is completed
-     */
-    const later = () => {
-      this.eventsToDebounce[type].timeout = null;
-      PageVisit.getInstance().addPageVisitEvents(
-        this.eventsToDebounce[type].events,
-        this.eventsToDebounce[type].eventName,
-      );
-      this.eventsToDebounce[type].events = [];
-    };
-
-    clearTimeout(this.eventsToDebounce[type].timeout);
-    this.eventsToDebounce[type].timeout = setTimeout(
-      later,
-      this.eventsToDebounce[type].debouncePeriod,
-    );
-  }
-
-  /** Sets up the page hide handler to try to push remaining events in the queues */
-  _setupUnloadHandler() {
-    addSafeEventListener(window, 'pagehide', () => {
-      Object.values(this.eventsToDebounce).forEach(eventObject => {
-        PageVisit.getInstance().addPageVisitEvents(
-          eventObject.events,
-          eventObject.eventName,
-        );
-      });
-    });
-  }
-}
-
-export { InputMonitor };

package/dist/monitors/keyboardInputMonitor.js

@@ -1,66 +0,0 @@
-import { TextInput } from 'react-native';
-import { updatePayload } from '../pageVisit/userStep.js';
-import { InputMonitor } from './inputMonitor.js';
-import { SOURCE_ATT_NAME, TEXT_ATT_NAME, TAGNAME_ATT_NAME, TYPE_ATT_NAME, KEYBOARD_EVENT_TYPE } from '../constants.js';
-
-/** @module KeyboardInputMonitor */
-
-/**
- * KeyboardInputMonitor is a listener class that attaches a
- * keyboard input listener of the document object.
- */
-class KeyboardInputMonitor {
-  /**
-   * Begins the monitoring process
-   * we currently only monitor two input locations: textarea and input
-   */
-  monitor() {
-    const handler = this._handle.bind(this);
-
-    if (!TextInput.originalRender) {
-      TextInput.originalRender = TextInput.render;
-      TextInput.render = function (props, ...args) {
-        const onChange = event => {
-          const currentText = event.nativeEvent.text;
-          handler(event.target.viewConfig.uiViewClassName, props);
-          if (props.onChange) props.onChange(event);
-          if (props.onChangeText) props.onChangeText(currentText);
-        };
-        const newProps = {
-          ...props,
-          onChange,
-        };
-        return TextInput.originalRender(newProps, ...args);
-      };
-    }
-  }
-
-  /**
-   * Validates an event
-   * @param uiViewClassName
-   * @param props
-   */
-  _handle(uiViewClassName, props) {
-    if (!/(text|input)/i.test(uiViewClassName)) {
-      return;
-    }
-
-    const name = props.placeholder || props.testID;
-
-    if (!name) {
-      return;
-    }
-
-    InputMonitor.getInstance().addEvent(
-      updatePayload({
-        [SOURCE_ATT_NAME]: '',
-        [TEXT_ATT_NAME]: name,
-        [TAGNAME_ATT_NAME]: uiViewClassName.toLowerCase(),
-        [TYPE_ATT_NAME]: KEYBOARD_EVENT_TYPE,
-      }),
-      KEYBOARD_EVENT_TYPE,
-    );
-  }
-}
-
-export { KeyboardInputMonitor };

package/dist/monitors/pageMonitor.js

@@ -1,122 +0,0 @@
-import { PAGE_EVENTS_WINDOW, PAGE_EVENTS_DOCUMENT, PAGE_EVENT_TYPE } from '../constants.js';
-import { InputMonitor } from './inputMonitor.js';
-import { addSafeEventListener } from '../utils/eventlistener.js';
-
-/** @module PageMonitor */
-
-/** Monitors the page events which we capture and later process */
-class PageMonitor {
-  /**
-   * gets the singleton instance
-   * @returns {PageMonitor}
-   */
-  static getInstance() {
-    if (!this.instance) {
-      this.instance = new PageMonitor();
-    }
-
-    return this.instance;
-  }
-
-  /** Starts monitoring page events on the document */
-  monitor() {
-    PAGE_EVENTS_WINDOW.forEach(pageEvent => {
-      addSafeEventListener(
-        window,
-        pageEvent,
-        this._onPageEventHandle.bind(this),
-        true,
-      );
-    });
-    if (global.document) {
-      PAGE_EVENTS_DOCUMENT.forEach(pageEvent => {
-        addSafeEventListener(
-          document,
-          pageEvent,
-          this._onPageEventHandle.bind(this),
-          true,
-        );
-      });
-    }
-  }
-
-  /**
-   * Handles a single page event
-   * @param  {} event
-   */
-  _onPageEventHandle(event) {
-    if (!event || !event.type) {
-      return;
-    }
-
-    const payload = {
-      type: event.type,
-    };
-
-    // Add data if applicable for the event type
-    switch (event.type) {
-      case 'visibilitychange':
-        payload.data = `state: ${this.getDocumentState()}`;
-        break;
-      case 'readystatechange':
-        payload.data = `state: ${document.readyState}`;
-        break;
-      case 'pagehide':
-      case 'pageshow':
-      case 'load':
-        if (event.persisted) {
-          payload.data = `persisted: ${event.persisted}`;
-        }
-        break;
-      case 'storage':
-        if (event.key) {
-          payload.data = `key: ${event.key}`;
-        }
-        break;
-      case 'message':
-      case 'messageerror':
-        if (event.data && event.origin) {
-          payload.data = `origin: ${event.origin} size: ${this.getSizeInBytes(
-            event.data,
-          )}`;
-        }
-        break;
-      case 'hashchange':
-        if (event.newURL) {
-          payload.data = `newURL: ${event.newURL}`;
-        }
-        break;
-      // do nothing
-    }
-
-    // storing the page event in the page visit queue
-    InputMonitor.getInstance().addEvent(payload, PAGE_EVENT_TYPE);
-  }
-
-  /** Returns document state */
-  getDocumentState() {
-    if (document.visibilityState === 'hidden') {
-      return 'hidden';
-    }
-    if (document.hasFocus()) {
-      return 'active';
-    }
-    return 'passive';
-  }
-
-  /**
-   * Returns object size in bytes
-   * @param  {} obj
-   */
-  getSizeInBytes(obj) {
-    let str = obj;
-    if (typeof obj !== 'string') {
-      // Else, make obj into a string
-      str = JSON.stringify(obj);
-    }
-    // 2B per character in the string
-    return str.length * 2;
-  }
-}
-
-export { PageMonitor };