noibu-react-native 0.2.7 → 0.2.9

package/dist/constants.d.ts

@@ -0,0 +1,48 @@
+/** @module Constants */
+export declare const CURRENT_NOIBUJS_VERSION = 2;
+export declare const MAX_STRING_LENGTH = 1024;
+export declare const MAX_TIME_FOR_UNSENT_DATA_MILLIS = 500;
+export declare const PII_EMAIL_PATTERN: RegExp;
+export declare const PII_REDACTION_REPLACEMENT_STRING = "******";
+export declare const SEVERITY: {
+    error: string;
+    warn: string;
+    info: string;
+    debug: string;
+};
+export declare const MAX_METROPLEX_SOCKET_INNACTIVE_TIME: number;
+export declare const MAX_BEACON_PAYLOAD_SIZE = 59000;
+export declare const CONTENT_TYPE = "content-type";
+/**
+ * Gets the script id from the cookie object, returns default if cannot be found
+ */
+export declare function GET_SCRIPT_ID(): string;
+/**
+ * Gets the max metro recon number
+ */
+export declare function GET_MAX_METROPLEX_RECONNECTION_NUMBER(): number;
+/**
+ * Returns the amount of time in milliseconds to delay a new connection by
+ * if we have exceeded the max consecutive connection count
+ */
+export declare function GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY(): number;
+/**
+ * gets the base url for metroplex's websocket connection
+ */
+export declare function GET_METROPLEX_BASE_SOCKET_URL(): string;
+/**
+ * gets the base url for metroplex's HTTP requests
+ */
+export declare function GET_METROPLEX_BASE_HTTP_URL(): string;
+/**
+ * Returns the URL that accepts http post requests
+ */
+export declare function GET_METROPLEX_POST_URL(): string;
+/**
+ * Returns the URL for posting metrics data to Metroplex
+ */
+export declare function GET_METROPLEX_METRICS_URL(): string;
+/**
+ * gets the current env
+ */
+export declare function GET_DEVICE_ENV(): string;

package/dist/constants.js

@@ -1,4 +1,4 @@
-import { MetroplexRoute } from './node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { MetroplexRoute } from 'noibu-metroplex-ts-bindings';
 
 /** @module Constants */
 // current collect version to be sent to front end services
@@ -11,13 +11,6 @@ const MAX_STRING_LENGTH = 1024;
 const MAX_TIME_FOR_UNSENT_DATA_MILLIS = 500;
 const PII_EMAIL_PATTERN = /\b[a-z0-9!#$%&'*+/=?^_‘{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_‘{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\b/g;
 const PII_REDACTION_REPLACEMENT_STRING = '******';
-// severity levels for the collect error log
-const SEVERITY = {
-    error: 'error',
-    warn: 'warn',
-    info: 'info',
-    debug: 'debug',
-};
 // maximum seconds that we can spend without sending anything
 // to our backend. This needs to be less than Silverbolt's session innactivity
 // time so that PVs don't become part of a separate web session.
@@ -31,7 +24,7 @@ const CONTENT_TYPE = 'content-type';
  * Gets the script id from the cookie object, returns default if cannot be found
  */
 function GET_SCRIPT_ID() {
-    return "1.0.104-rn-sdk-0.2.7" ;
+    return "1.0.104-rn-sdk-0.2.9" ;
 }
 /**
  * Gets the max metro recon number
@@ -82,4 +75,4 @@ function GET_DEVICE_ENV() {
     return "react-native-expo" ;
 }
 
-export { CONTENT_TYPE, CURRENT_NOIBUJS_VERSION, GET_DEVICE_ENV, GET_MAX_METROPLEX_RECONNECTION_NUMBER, GET_METROPLEX_BASE_HTTP_URL, GET_METROPLEX_BASE_SOCKET_URL, GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY, GET_METROPLEX_METRICS_URL, GET_METROPLEX_POST_URL, GET_SCRIPT_ID, MAX_BEACON_PAYLOAD_SIZE, MAX_METROPLEX_SOCKET_INNACTIVE_TIME, MAX_STRING_LENGTH, MAX_TIME_FOR_UNSENT_DATA_MILLIS, PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING, SEVERITY };
+export { CONTENT_TYPE, CURRENT_NOIBUJS_VERSION, GET_DEVICE_ENV, GET_MAX_METROPLEX_RECONNECTION_NUMBER, GET_METROPLEX_BASE_HTTP_URL, GET_METROPLEX_BASE_SOCKET_URL, GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY, GET_METROPLEX_METRICS_URL, GET_METROPLEX_POST_URL, GET_SCRIPT_ID, MAX_BEACON_PAYLOAD_SIZE, MAX_METROPLEX_SOCKET_INNACTIVE_TIME, MAX_STRING_LENGTH, MAX_TIME_FOR_UNSENT_DATA_MILLIS, PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING };

package/dist/entry/index.d.ts

@@ -0,0 +1,13 @@
+import 'react-native-url-polyfill/auto';
+import 'whatwg-fetch';
+import globalInit from './init';
+import { ErrorBoundary as _ErrorBoundary } from '../react/ErrorBoundary';
+/** @param config */
+export declare const setupNoibu: typeof globalInit;
+export declare const NoibuJS: {
+    requestHelpCode: () => Promise<string | null>;
+    addCustomAttribute: (name: string, value: string) => Promise<string>;
+    addError: (customError: unknown) => string;
+    addJsSdkError: (customError: unknown, errorSource: unknown) => string;
+};
+export declare const ErrorBoundary: typeof _ErrorBoundary;

package/dist/entry/init.d.ts

@@ -0,0 +1,8 @@
+export declare const REQUIRED_DATA_PROCESSING_URLS: string[];
+/**
+ * isInvalidURLConfig will verify that Collect is being initializes with
+ * the correct env vars.
+ */
+export declare function isInvalidURLConfig(urls: Record<(typeof REQUIRED_DATA_PROCESSING_URLS)[number], string>): boolean;
+/** initilializes the script to start executing all of NJS features */
+export default function globalInit(customerConfig: CustomerConfig): Promise<void>;

package/dist/entry/init.js

@@ -1,9 +1,9 @@
 import { __awaiter } from 'tslib';
 import uuid from 'react-native-uuid';
-import { MetroplexRoute } from '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { MetroplexRoute, Severity } from 'noibu-metroplex-ts-bindings';
 import { KeyboardInputMonitor } from '../monitors/KeyboardInputMonitor.js';
 import { PageMonitor } from '../monitors/PageMonitor.js';
-import { SEVERITY, GET_METROPLEX_BASE_SOCKET_URL, GET_METROPLEX_BASE_HTTP_URL } from '../constants.js';
+import { GET_METROPLEX_BASE_SOCKET_URL, GET_METROPLEX_BASE_HTTP_URL } from '../constants.js';
 import ClientConfig from '../api/ClientConfig.js';
 import { isNoibuJSAlreadyLoaded } from '../utils/function.js';
 import { PageVisitManager } from '../pageVisit/PageVisitManager.js';
@@ -85,7 +85,7 @@ function globalInit(customerConfig) {
             pageMonitor.monitor();
             SessionRecorder.getInstance().recordUserSession();
             if (metroplexSocket.connectionPromise) {
-                metroplexSocket.connectionPromise.catch((error) => ClientConfig.getInstance().postInternalError({ msg: `Error during metroplexSocket initial connection`, error }, false, SEVERITY.error));
+                metroplexSocket.connectionPromise.catch((error) => ClientConfig.getInstance().postInternalError({ msg: `Error during metroplexSocket initial connection`, error }, false, Severity.ERROR));
             }
             else {
                 throw new Error('metroplex socket not ready');
@@ -93,7 +93,7 @@ function globalInit(customerConfig) {
             noibuLog('global init finished');
         }
         catch (error) {
-            ClientConfig.getInstance().postInternalError({ msg: `Error during globalInit`, error }, true, SEVERITY.error);
+            ClientConfig.getInstance().postInternalError({ msg: `Error during globalInit`, error }, true, Severity.ERROR);
             noibuLog('exiting');
         }
     });

package/dist/monitors/AppNavigationMonitor.d.ts

@@ -0,0 +1,10 @@
+import { Monitor, Singleton } from './BaseMonitor';
+/** Attaches corresponding listener to the passed navigation integration */
+export declare class AppNavigationMonitor extends Singleton implements Monitor {
+    /** Main method for starting the monitoring */
+    monitor(): void;
+    /** handler for updating navigation breadcrumbs and notifying metro of location change */
+    private static onNavigation;
+    /** Called when the event needs to be emitted */
+    private static reportLocationChange;
+}

package/dist/monitors/AppNavigationMonitor.js

@@ -1,10 +1,8 @@
-import { SEVERITY } from '../constants.js';
 import { ReactNativeNavigationIntegration } from './integrations/ReactNativeNavigationIntegration.js';
 import ClientConfig from '../api/ClientConfig.js';
 import { EventDebouncer } from '../pageVisit/EventDebouncer.js';
 import { Singleton } from './BaseMonitor.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { Severity, EventType } from 'noibu-metroplex-ts-bindings';
 
 /** Attaches corresponding listener to the passed navigation integration */
 class AppNavigationMonitor extends Singleton {
@@ -22,7 +20,7 @@ class AppNavigationMonitor extends Singleton {
             ClientConfig.getInstance().postInternalError({
                 msg: `Error while trying to attach to navigation events`,
                 error: e,
-            }, false, SEVERITY.error);
+            }, false, Severity.ERROR);
         }
     }
     /** handler for updating navigation breadcrumbs and notifying metro of location change */

package/dist/monitors/AppNavigationMonitor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/monitors/BaseMonitor.d.ts

@@ -0,0 +1,13 @@
+export interface Monitor {
+    monitor(): void;
+}
+/** Singleton pattern with our flavor */
+export declare abstract class Singleton {
+    private static instances;
+    /** returns singleton instance */
+    static getInstance<T extends Singleton, A extends any[]>(this: new (...args: A) => T, ...args: ConstructorParameters<new (...args: A) => T>): T;
+    /** Destructor */
+    protected destroy(): void;
+    /** used for testing only */
+    private static resetInstances;
+}

package/dist/monitors/BaseMonitor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/monitors/ClickMonitor.d.ts

@@ -0,0 +1,28 @@
+/** @module ClickMonitor */
+import { Monitor, Singleton } from './BaseMonitor';
+/** Monitors the clicks which we capture and later process */
+export declare class ClickMonitor extends Singleton implements Monitor {
+    private static textCapturedWhiteListRegex;
+    private static htmlIDAllowListRegex;
+    /** Starts monitoring clicks on every Press-able component */
+    monitor(): void;
+    /** Handles a single click event */
+    private static onClickHandle;
+    /** Gets the textual content from an element, if any
+     */
+    private static getTextualContentFromEl;
+    /** Parse and trim text */
+    private static trimText;
+    /** gets id */
+    private static getHid;
+    /** gets tag name */
+    private static getTagName;
+    /** Recursively parses element's inner content and masks blocked css classes */
+    private static parseInnerContent;
+    /** Gets selectors to prevent those elements from being recorded */
+    private static getBlockedElements;
+    /** normalize value and append to the resulting text if not empty */
+    private static parseAndAppendText;
+    /** Destructs instance */
+    destroy(this: Singleton): void;
+}

package/dist/monitors/ClickMonitor.js

@@ -6,9 +6,7 @@ import { maskTextInput } from '../utils/function.js';
 import ClientConfig from '../api/ClientConfig.js';
 import { Singleton } from './BaseMonitor.js';
 import { isNoibuWrapped, replace, unwrapNoibuWrapped } from '../utils/object.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { UserStepType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/UserStepType.js';
-import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { UserStepType, EventType } from 'noibu-metroplex-ts-bindings';
 
 /** @module ClickMonitor */
 /**

package/dist/monitors/ClickMonitor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/monitors/ErrorMonitor.d.ts

@@ -0,0 +1,39 @@
+import { Monitor, Singleton } from './BaseMonitor';
+/** Monitors the errors happening on the window */
+export declare class ErrorMonitor extends Singleton implements Monitor {
+    static preventInfiniteLoopFlag: boolean;
+    /** base method */
+    monitor(): void;
+    /** proxy error utils */
+    private static configureErrorUtilsHandler;
+    /** Handles a single error event */
+    private static onErrorHandler;
+    /** proxy hermes engine */
+    private static configureHermesHooks;
+    /** handler for promise rejection failures */
+    private static onPromiseRejectionHandler;
+    /**
+     * wraps and replaces the addEventListener property
+     * of event targets to try and catch errors
+     * eventTargetString: event target name
+     */
+    private static configureEventListeners;
+    /** iterates arguments to try to extract errors from them
+     */
+    private static processErrorLogArguments;
+    /**
+     * Constructs error objects based on console args.
+     * Relies on isStackTrace() to determine if arg is a stack trace, otherwise the arg must be a message.
+     *
+     * If there are multiple stack traces or the number of error messages is not equal to one,
+     * it maps the stack traces to objects with their respective first lines as messages.
+     * Otherwise, if there is exactly one stack trace and one error message,
+     * it constructs an array with a single object containing the first stack trace and the first error message.
+     */
+    private static constructErrors;
+    /**
+     * transform a log into an error since React hides component errors
+     * https://reactjs.org/docs/error-boundaries.html
+     */
+    private static processErrorLog;
+}

package/dist/monitors/ErrorMonitor.js

@@ -2,9 +2,8 @@ import { asString, isStackTrace } from '../utils/function.js';
 import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
 import { replace } from '../utils/object.js';
 import { Singleton } from './BaseMonitor.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { PageVisitErrorSource } from 'noibu-metroplex-ts-bindings';
 import ClientConfig from '../api/ClientConfig.js';
-import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
 
 /* eslint-disable @typescript-eslint/ban-types,prefer-arrow-callback */
 /** @module ErrorMonitor */

package/dist/monitors/KeyboardInputMonitor.d.ts

@@ -0,0 +1,18 @@
+import { Monitor, Singleton } from './BaseMonitor';
+/**
+ * KeyboardInputMonitor is a listener class that attaches a
+ * keyboard input listener of the document object.
+ */
+export declare class KeyboardInputMonitor extends Singleton implements Monitor {
+    private static originalRender;
+    /**
+     * Begins the monitoring process
+     * we currently only monitor two input locations: textarea and input
+     */
+    monitor(): void;
+    /** Validates an event */
+    static handle(uiViewClassName: string, props: {
+        placeholder?: string;
+        testID?: string;
+    }): void;
+}

package/dist/monitors/KeyboardInputMonitor.js

@@ -1,9 +1,7 @@
 import { EventDebouncer } from '../pageVisit/EventDebouncer.js';
 import { TextInput } from 'react-native';
 import { Singleton } from './BaseMonitor.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
-import { UserStepType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/UserStepType.js';
+import { EventType, UserStepType } from 'noibu-metroplex-ts-bindings';
 
 /** @module KeyboardInputMonitor */
 /**

package/dist/monitors/PageMonitor.d.ts

@@ -0,0 +1,20 @@
+import { Monitor, Singleton } from './BaseMonitor';
+type Event = any;
+/** Monitors the page events which we capture and later process */
+export declare class PageMonitor extends Singleton implements Monitor {
+    /** Starts monitoring page events on the document */
+    monitor(): void;
+    /**
+     * Handles a single page event
+     * todo: don't think these events exist in RN world
+     */
+    _onPageEventHandle(event: Event): void;
+    /** Returns document state */
+    getDocumentState(): "passive" | "hidden" | "active";
+    /**
+     * Returns object size in bytes
+     * @param  {} obj
+     */
+    getSizeInBytes(obj: any): number;
+}
+export {};

package/dist/monitors/PageMonitor.js

@@ -1,8 +1,7 @@
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import { EventDebouncer } from '../pageVisit/EventDebouncer.js';
 import { Singleton } from './BaseMonitor.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { EventType } from 'noibu-metroplex-ts-bindings';
 
 /** @module PageMonitor */
 const PAGE_EVENTS_DOCUMENT = ['visibilitychange', 'resume', 'freeze', 'readystatechange', 'cut', 'copy', 'paste'];

package/dist/monitors/RequestMonitor.d.ts

@@ -0,0 +1,74 @@
+import { Monitor, Singleton } from './BaseMonitor';
+/** Monitors all requests */
+export default class RequestMonitor extends Singleton implements Monitor {
+    /** main method */
+    monitor(): void;
+    /**
+     * Gets a response text Promise out of Response & headers. Returns reason if bundler decides to drop text.
+     * Due to async nature of text() and async function sent to Promise.all,
+     * our code race competes with client's code consuming the response.
+     * So at this point engine somehow gets access to the original ReadableStream and marks it as locked,
+     * thus client code may throw an error.
+     */
+    private static consumeResponseAndGetBodyText;
+    /** Generates new PVEventHTTP */
+    private static getPvEventHttp;
+    /** Gets headers from request or request options. Handles different scenarios where simple conversion is not possible */
+    private static getRequestHeaders;
+    /**
+     * Gets response headers.
+     * It is always a Headers object.
+     */
+    private static getResponseHeaders;
+    /** Gets request body from body strings or Request options */
+    private static getRequestBody;
+    /** Returns the parameters to pass the HttpEventManager constructor. Specific to the fetch wrapper. */
+    private static getHttpDataFromFetch;
+    /** Clones Response / Request or returns original object if cloning is not possible */
+    private static cloneResponse;
+    /** Handles fetch response safely. Reports HttpEventManager and error to Pagevisit if needed. */
+    private static safeHandleFetchResponse;
+    /** Safe function to get method and url from fetch args */
+    private static getMethodUrlFromFetchArgs;
+    /**
+     * Setting up the wrapper around fetch functions to try and
+     * catch http errors
+     */
+    private static setupGlobalFetchWrapper;
+    /** Does a check if data collection is enabled and combines it into HttpDataBundle */
+    private static getHttpDataFromXhr;
+    /**
+     * on loadend we catch the event and
+     * make sure it was correct
+     */
+    private static loadendHandler;
+    /** Handles fetch failure */
+    private static handleFetchFailure;
+    /** gets method from xhr */
+    private static getMethodFromXHR;
+    /**
+     * Wraps the send prototype of the xmlhttp object
+     * We set nbuWrapper to the handler function so if this returns an error
+     * the trace message will start with nbuWrapper which would allow us to
+     * detect that this is a wrapped function and not a NoibuJS error
+     */
+    private static wrapXMLHTTPSend;
+    /**
+     * Wraps the open prototype of the xmlhttp object
+     * We set nbuWrapper to the handler function so if this returns an error
+     * the trace message will start with nbuWrapper which would allow us to
+     * detect that this is a wrapped function and not a NoibuJS error
+     */
+    private static wrapXMLHTTPOpen;
+    /**
+     * Replaces the native XMLHTTPRequest.setHeader() function. We use this to build an array of
+     * request headers as these are not stored by the XMLHTTPRequest object.
+     * @param {object} proto window.XMLHTTPRequest's prototype
+     */
+    private static wrapXMLHTTPSetRequestHeader;
+    /**
+     * Setting up the wrapper around send functions to try and
+     * catch http errors
+     */
+    private static setupGlobalXMLHttpWrapper;
+}

package/dist/monitors/RequestMonitor.js

@@ -2,7 +2,6 @@ import { __awaiter } from 'tslib';
 import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
 import { isHttpCodeFailure, saveHTTPEvent } from '../pageVisit/HttpEventManager.js';
 import { safeEntries, propWriteableOrMadeWriteable, replace } from '../utils/object.js';
-import { SEVERITY } from '../constants.js';
 import ClientConfig from '../api/ClientConfig.js';
 import { noibuLog } from '../utils/log.js';
 import { tryGetStackTrace, safeTrim } from '../utils/function.js';
@@ -11,8 +10,7 @@ import { addSafeEventListener } from '../utils/eventlistener.js';
 import { HTTPDataBundler } from './http-tools/HTTPDataBundler.js';
 import GqlErrorValidator from './http-tools/GqlErrorValidator.js';
 import { Singleton } from './BaseMonitor.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
+import { Severity, PageVisitErrorSource } from 'noibu-metroplex-ts-bindings';
 
 /** request monitor */
 const BODY_USED_ERROR = 'Response data unavailable due to an improperly wrapped fetch call';
@@ -104,7 +102,7 @@ class RequestMonitor extends Singleton {
                 if (!ogResponse) {
                     // no idea how, but this happens sometimes, esp if other libs override fetch
                     // logging to track the issue if it becomes widespread
-                    return ClientConfig.getInstance().postInternalError({ msg: 'No response object in fetch callback', url, method, options, request }, false, SEVERITY.error);
+                    return ClientConfig.getInstance().postInternalError({ msg: 'No response object in fetch callback', url, method, options, request }, false, Severity.ERROR);
                 }
                 const clonedResponse = RequestMonitor.cloneResponse(ogResponse); // have to do it as early as possible
                 const graphqlResponse = RequestMonitor.cloneResponse(clonedResponse); // and two times more for each consumption
@@ -139,7 +137,7 @@ class RequestMonitor extends Singleton {
                     return;
                 }
                 const stack = tryGetStackTrace(e);
-                ClientConfig.getInstance().postInternalError({ msg: `Error in custom fetch() callback`, error: e, stack }, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({ msg: `Error in custom fetch() callback`, error: e, stack }, false, Severity.ERROR);
             }
         });
     }
@@ -161,7 +159,7 @@ class RequestMonitor extends Singleton {
             };
         }
         catch (e) {
-            ClientConfig.getInstance().postInternalError({ msg: `Error in fetch() wrapper`, error: e }, false, SEVERITY.error);
+            ClientConfig.getInstance().postInternalError({ msg: `Error in fetch() wrapper`, error: e }, false, Severity.ERROR);
         }
         return defaultResource;
     }
@@ -281,7 +279,7 @@ class RequestMonitor extends Singleton {
                 }
                 catch (e) {
                     const stack = tryGetStackTrace(e);
-                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.send() wrapper`, error: e, stack }, false, SEVERITY.error);
+                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.send() wrapper`, error: e, stack }, false, Severity.ERROR);
                 }
                 return originalFunction.call(this, payload);
             };
@@ -306,7 +304,7 @@ class RequestMonitor extends Singleton {
                         this.noibuHttpUrl = url;
                     }
                     catch (error) {
-                        ClientConfig.getInstance().postInternalError({ msg: `Unable to set custom properties on XHR object`, error }, false, SEVERITY.warn);
+                        ClientConfig.getInstance().postInternalError({ msg: `Unable to set custom properties on XHR object`, error }, false, Severity.WARN);
                     }
                     if (shouldHandleLoadend) {
                         const startTime = Date.now();
@@ -315,7 +313,7 @@ class RequestMonitor extends Singleton {
                 }
                 catch (e) {
                     const stack = tryGetStackTrace(e);
-                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.open() wrapper`, error: e, stack }, false, SEVERITY.error);
+                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.open() wrapper`, error: e, stack }, false, Severity.ERROR);
                 }
                 return originalFunction.call(this, method, url, async, user, password);
             };
@@ -342,7 +340,7 @@ class RequestMonitor extends Singleton {
                     }
                 }
                 catch (error) {
-                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.setRequestHeader() wrapper`, error }, false, SEVERITY.error);
+                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.setRequestHeader() wrapper`, error }, false, Severity.ERROR);
                 }
                 return originalFunction.call(this, header, value);
             };

package/dist/monitors/http-tools/GqlErrorValidator.d.ts

@@ -0,0 +1,35 @@
+import { GQLError } from 'noibu-metroplex-ts-bindings';
+/** Try detecting GraphQL errors from http response */
+export default class GqlErrorValidator {
+    /** Retrieves GQL error object based on fetch request/response */
+    static fromFetch(url: string, options: RequestInit | undefined, request: Request | undefined, response: Response): Promise<GQLError[] | null>;
+    /** Retrieves GQL error object based on XHR object */
+    static fromXhr(url: string, xhr: unknown): Promise<GQLError[] | null>;
+    /** Try safely parse a string and return null if fails */
+    static _parseJsonSafely(content: string): any;
+    /** Try to get content type for fetch arguments */
+    static _getContentTypeFromFetchArguments(options?: RequestInit, request?: Request): string | null;
+    /**
+     * Checks if request is aborted
+     * If it has been aborted we are not able to consume the response
+     */
+    static _isRequestAborted(options?: RequestInit, request?: RequestInit): boolean | null | undefined;
+    /** Determines if request should be processed */
+    static _shouldHandleRequest(url: string, contentType?: string | null): boolean;
+    /** Sanitizes payload object */
+    static _validate(data: unknown, validationIssues: string[]): GQLError[] | null;
+    /** Sanitizes message object */
+    static _validateMessage(error: GQLError): void;
+    /**
+     * Sanitizes extensions object
+     */
+    static _validateExtensions(error: GQLError): void;
+    /** Sanitizes locations object */
+    static _validateLocations(error: GQLError, validationIssues: string[]): void;
+    /** Sanitizes path object */
+    static _validatePath(error: object, validationIssues: string[]): void;
+    /** Posts error */
+    static _postError(message: unknown): void;
+    /** Posts issue found during object sanitization */
+    static _postValidationIssues(validationIssues: string[]): void;
+}

package/dist/monitors/http-tools/GqlErrorValidator.js

@@ -1,7 +1,8 @@
 import { __awaiter } from 'tslib';
 import { isInstanceOf, getMaxSubstringAllowed } from '../../utils/function.js';
-import { CONTENT_TYPE, SEVERITY } from '../../constants.js';
+import { CONTENT_TYPE } from '../../constants.js';
 import ClientConfig from '../../api/ClientConfig.js';
+import { Severity } from 'noibu-metroplex-ts-bindings';
 
 const GQL_EXTENSIONS_ATT_NAME = 'extensions';
 const GQL_LOCATIONS_ATT_NAME = 'locations';
@@ -217,12 +218,12 @@ class GqlErrorValidator {
     }
     /** Posts error */
     static _postError(message) {
-        ClientConfig.getInstance().postInternalError({ msg: `GQL parse error: ${message}` }, false, SEVERITY.error);
+        ClientConfig.getInstance().postInternalError({ msg: `GQL parse error: ${message}` }, false, Severity.ERROR);
     }
     /** Posts issue found during object sanitization */
     static _postValidationIssues(validationIssues) {
         const message = validationIssues.join(',');
-        ClientConfig.getInstance().postInternalError({ msg: `GQL error validation warning: ${message}` }, false, SEVERITY.error);
+        ClientConfig.getInstance().postInternalError({ msg: `GQL error validation warning: ${message}` }, false, Severity.ERROR);
     }
 }