noibu-react-native 0.2.2 → 0.2.4

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/httpDataBundler.d.ts

@@ -1,161 +0,0 @@
-/** Bundles HTTP payloads and headers */
-export class HTTPDataBundler {
-    /** gets http data payload allowed URLs */
-    static getHttpPayloadAllowedURLs(): string[];
-    /**
-     * gets the singleton instance
-     * @returns {HTTPDataBundler}
-     */
-    static getInstance(): HTTPDataBundler;
-    /**
-     * Builds the HTTP payload allowed regexes for full and relative URLs
-     * @param allowedURLs A list of allowed URLs
-     * @param {'absolute' | 'relative'} strategy Use only absolute URLs if true, use only relative URL if false
-     * @returns a regex of allowed URLs
-     */
-    static buildAllowedRegex(allowedURLs: any, strategy: "absolute" | "relative"): RegExp | null;
-    /**
-     * Takes an iterator and returns a map of strings representing headers.
-     * @param {object} headersIterable any iterable object
-     * @returns a map of strings (as expected by metroplex) representing HTTP
-     * request or response headers
-     */
-    static headersMapFromIterable(headersIterable: object): Map<any, any>;
-    /**
-     * Takes a string of headers with 'name: value' and returns
-     * a map of strings representing headers.
-     * @param {string} headersString is all the headers in one string
-     * @returns a map of strings (as expected by metroplex) representing HTTP
-     * request or response headers
-     */
-    static headersMapFromString(headersString: string): Map<any, any>;
-    /**
-     * For an XHR object, checks the responseType property and handles the response or
-     * responseText property accordingly to return a string representation of the response.
-     * @param {object} xhr an XMLHTTPRequest object
-     * @returns a string representation of the response, or null if this fails.
-     */
-    static responseStringFromXHRResponseType(xhr: object): any;
-    /**
-     * Determins if the URL is absolute or relative
-     * @param {string} url
-     * @returns boolean indicating whether the URL passed is either absolute or relative
-     */
-    static isAbsoluteURL(url: string): boolean;
-    contentTypeReadableRegex: RegExp;
-    initialURLPartsReversed: any[];
-    httpDataCollectionEnabled: boolean;
-    httpDataAllowedAbsoluteRegex: RegExp | null;
-    httpDataAllowedRelativeRegex: RegExp | null;
-    fuzzyFieldsToRedact: string[];
-    exactFieldsToRedact: string[];
-    /**
-     * Takes a URL and returns true if it is determined to be on the same domain as the URL
-     * the script is running on. Ignores protocol and path, and allows the URL to be a subdomain.
-     * @param {string} requestURL the URL of a request to compare to the script website's URL
-     */
-    isURLSameDomain(requestURL: string): boolean;
-    /**
-     * Builds an HTTP Data bundle
-     * @param  url
-     * @param  requestHeaders is a map of request headers
-     * @param  rawRequestPayload
-     * @param  responseHeaders is a map of response headers
-     * @param  responsePayload
-     * @param  method
-     * @param shouldCollectPayload
-     */
-    bundleHTTPData(url: any, requestHeaders: any, rawRequestPayload: any, responseHeaders: any, responsePayload: any, method: any, shouldCollectPayload: any): {
-        rqh: any;
-        rqp: string | null;
-        rsh: any;
-        rsp: string | null;
-    } | null;
-    /**
-     * Validates a request based on the URL and method. When enabled, will handle
-     * de-duping the requests
-     * @param {string} url
-     * @param {string} method
-     * @returns boolean indicating whether the validation passed
-     */
-    isValidRequest(url: string, method: string): boolean;
-    /**
-     * Checks two things: that the URL is either on the same domain (or an address relative to the
-     * current domain), and also checks that the config http_data_collection flag is enabled.
-     * @param {string} url
-     * @returns boolean indicating whether the URL passed is either relative (in which case it is
-     * inherently on the current domain) or matches the current domain.
-     */
-    shouldContinueForURL(url: string): boolean;
-    /**
-     * Checks whether HTTP payloads can be collected on this URL
-     * @param {string} url
-     * @returns boolean indicating whether HTTP payloads can be collected on this URL
-     */
-    shouldCollectPayloadForURL(url: string): boolean;
-    /**
-     * Double checks content length if we couldn't read the headers, and redacts PII
-     * @param  {string} payload
-     * @param  {string} url
-     * @returns the restricted payload
-     */
-    restrictPayload(payload: string, url: string): string | null;
-    /**
-     * Returns true if the content length is acceptable to collect
-     * If the headers are not found, check actual content for length
-     * @param  {Headers} headers
-     * @returns boolean true if acceptable to collect
-     */
-    contentLengthAcceptable(headers: Headers): boolean;
-    /**
-     * Returns true if the content type according to the headers is valid for collection.
-     * Also returns assumed true if content type is not stated in headers.
-     * @param {Map} headersMap
-     * @returns boolean true if acceptable to collect
-     */
-    contentTypeAcceptable(headersMap: Map<any, any>): boolean;
-    /**
-     * Returns a descriptive string if we have to drop payload based on the length
-     * or type listed in the headers passed. Returns an empty string otherwise.
-     * @param {Headers} headers a Headers object
-     * @returns A string, which is empty if the payload doesn't need to be dropped, or is a
-     * descriptive string explaining the circumstances of the drop otherwise.
-     */
-    dropPayloadIfNecessaryFromHeaders(headers: Headers): string;
-    /**
-     * Returns content length from the headers, if available
-     * If the headers are not found or not a number, return -1
-     * @param  {} headersObject
-     * @returns content length
-     */
-    contentLength(headersObject: any): number;
-    /**
-     * Accepts a value that could be any type used as a request payload, and returns a string
-     * representation. First attemtps to find a .toString() method, then tries to handle it
-     * like an XML or HTML element, then finally falls back to JSON.stringify(). If none of
-     * these are successful, returns null.
-     * @param {*} value request paylad body, of any type
-     * @returns string representation of the value passed, or null if this fails.
-     */
-    stringFromRequestBody(value: any): any;
-    /**
-     * Removes possible PII from headers.
-     * @param {Map} dirtyHeaders a Map of HTTP response or request headers
-     * @returns a map of headers with PII redacted
-     */
-    removePIIHeaders(dirtyHeaders: Map<any, any>): Map<any, any> | null;
-    /**
-     * Takes a body payload string and redacts any PII we're able to detect
-     *
-     * @param {string} dirtyBody the string from which we want to redact PII
-     * @returns the string with any PII we're able to detect redacted.
-     */
-    removePIIBody(dirtyBody: string): string | null;
-    /**
-     * Try to parse content as a JSON object and
-     * iterate it recursively removing PII.
-     * Returns original content if nothing was changes or error is thrown.
-     * @param {String} content
-     */
-    tryParseObjectAndRemovePII(content: string): string;
-}