noibu-react-native 0.2.3 → 0.2.4

package/dist/monitors/RequestMonitor.js

@@ -0,0 +1,390 @@
+import { __awaiter } from 'tslib';
+import 'react-native/Libraries/Network/fetch';
+import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
+import { isHttpCodeFailure, PageVisitEventHTTP } from '../pageVisit/pageVisitEventHTTP.js';
+import { safeEntries, propWriteableOrMadeWriteable, replace } from '../utils/object.js';
+import { BODY_USED_ERROR, HTTP_RESP_LENGTH_ATT_NAME, SEVERITY, PV_SEQ_ATT_NAME, RESPONSE_ERROR_TYPE, GQL_ERROR_TYPE, XML_HTTP_REQUEST_ERROR_TYPE, FETCH_EXCEPTION_ERROR_TYPE, HTTP_METHOD_ATT_NAME, HTTP_RESP_CODE_ATT_NAME, URL_ATT_NAME, HTTP_RESP_TIME_ATT_NAME } from '../constants.js';
+import ClientConfig from '../api/clientConfig.js';
+import { noibuLog } from '../utils/log.js';
+import { tryGetStackTrace, safeTrim } from '../utils/function.js';
+import { promiseAll } from '../utils/polyfills.js';
+import { addSafeEventListener } from '../utils/eventlistener.js';
+import { HTTPDataBundler } from './http-tools/HTTPDataBundler.js';
+import GqlErrorValidator from './http-tools/GqlErrorValidator.js';
+import { Singleton } from '../types/Monitor.js';
+
+/**
+ * Monitors all requests
+ */
+class RequestMonitor extends Singleton {
+    /** main method */
+    monitor() {
+        noibuLog('monitorRequests started');
+        RequestMonitor.setupGlobalFetchWrapper(global);
+        RequestMonitor.setupGlobalXMLHttpWrapper();
+        noibuLog('monitorRequests ended');
+    }
+    /**
+     * 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.
+     */
+    static consumeResponseAndGetBodyText(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(response instanceof Response)) {
+                return '';
+            }
+            if (response.bodyUsed) {
+                return BODY_USED_ERROR;
+            }
+            return response.text();
+        });
+    }
+    /**
+     * Generates new PVEventHTTP
+     */
+    static getPvEventHttp(status, responseHeaders, method, url, responseTime) {
+        const httpEvent = {
+            [HTTP_METHOD_ATT_NAME]: method,
+            [HTTP_RESP_CODE_ATT_NAME]: status,
+            [URL_ATT_NAME]: url,
+            [HTTP_RESP_TIME_ATT_NAME]: responseTime,
+        };
+        const bundler = HTTPDataBundler.getInstance();
+        // add response payload length, if any
+        const contentLength = bundler.contentLength(responseHeaders);
+        if (contentLength > 0 && bundler.shouldContinueForURL(url)) {
+            httpEvent[HTTP_RESP_LENGTH_ATT_NAME] = contentLength;
+        }
+        return httpEvent;
+    }
+    /**
+     * Gets headers from request or request options. Handles different scenarios where simple conversion is not possible
+     */
+    static getRequestHeaders(request, options) {
+        const headers = safeEntries((request === null || request === void 0 ? void 0 : request.headers) || (options === null || options === void 0 ? void 0 : options.headers));
+        return HTTPDataBundler.headersMapFromIterable(headers);
+    }
+    /**
+     * Gets response headers.
+     * It is always a Headers object.
+     */
+    static getResponseHeaders(response) {
+        const headers = safeEntries(response === null || response === void 0 ? void 0 : response.headers);
+        return HTTPDataBundler.headersMapFromIterable(headers);
+    }
+    /**
+     * Gets request body from body strings or Request options
+     */
+    static getRequestBody(requestText, options) {
+        if (typeof requestText === 'string') {
+            return requestText;
+        }
+        // it's fine if it's falsy or an empty string, we catch that in HTTPDataBundler.getInstance().bundleHTTPData
+        return options === null || options === void 0 ? void 0 : options.body;
+    }
+    /**
+     * Returns the parameters to pass the PageVisitEventHTTP constructor. Specific to the fetch wrapper.
+     */
+    static getHttpDataFromFetch(request, response, method, url, options, isError, requestText, responseText) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
+                return null;
+            }
+            return HTTPDataBundler.getInstance().bundleHTTPData(url, RequestMonitor.getRequestHeaders(request, options), RequestMonitor.getRequestBody(requestText, options), RequestMonitor.getResponseHeaders(response), responseText, method, isError);
+        });
+    }
+    /** Clones Response / Request or returns original object if cloning is not possible */
+    static cloneResponse(ogResponse) {
+        if (!ogResponse.bodyUsed) {
+            return ogResponse.clone();
+        }
+        return ogResponse; // body consumed already, no http response body for us
+    }
+    /**
+     * Handles fetch response safely. Reports PageVisitEventHTTP and error to Pagevisit if needed.
+     */
+    static safeHandleFetchResponse(startTime, url, method, options, request) {
+        return (ogResponse) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                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().postNoibuErrorAndOptionallyDisableClient(`Error in custom fetch() callback: no response received`, 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
+                const httpEventDataResponse = RequestMonitor.cloneResponse(clonedResponse);
+                const respTime = Date.now() - startTime;
+                const status = clonedResponse.status;
+                const headers = clonedResponse.headers;
+                const gqlError = yield GqlErrorValidator.fromFetch(url, options, request, graphqlResponse);
+                const isHttpError = isHttpCodeFailure(status);
+                const [maybeRequestText, responseText] = yield promiseAll([
+                    Promise.resolve((_a = request === null || request === void 0 ? void 0 : request.text) === null || _a === void 0 ? void 0 : _a.call(request)),
+                    RequestMonitor.consumeResponseAndGetBodyText(httpEventDataResponse),
+                ]);
+                const httpEvent = RequestMonitor.getPvEventHttp(status, headers, method, url, respTime);
+                const httpData = yield RequestMonitor.getHttpDataFromFetch(request, httpEventDataResponse, method, url, options, isHttpError || !!gqlError, maybeRequestText, responseText);
+                const pageVisitEventHTTP = new PageVisitEventHTTP(httpEvent, httpData, !!gqlError);
+                pageVisitEventHTTP.saveHTTPEvent();
+                const seq = (_b = pageVisitEventHTTP.httpData) === null || _b === void 0 ? void 0 : _b[PV_SEQ_ATT_NAME];
+                if (isHttpError) {
+                    // this does not consume response body so no need to clone it
+                    saveErrorToPagevisit(RESPONSE_ERROR_TYPE, clonedResponse, seq);
+                }
+                if (gqlError) {
+                    gqlError.forEach(error => saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq));
+                }
+            }
+            catch (e) {
+                if ((e === null || e === void 0 ? void 0 : e.name) === 'AbortError') {
+                    // skip it, as it's somewhat expected
+                    return;
+                }
+                const stack = tryGetStackTrace(e);
+                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in custom fetch() callback: ${e}${stack}`, false, SEVERITY.error);
+            }
+        });
+    }
+    /**
+     * Safe function to get method and url from fetch args
+     */
+    static getMethodUrlFromFetchArgs(resource, options) {
+        const defaultResource = { method: 'GET', url: '' };
+        try {
+            // There is no valid reason for fetch() to be called without a resource, but we
+            // see it on a bunch of websites. It seems to work the same as empty string
+            if (!resource) {
+                return defaultResource;
+            }
+            if (resource instanceof Request && resource.method) {
+                return { method: resource.method, url: resource.url || '' };
+            }
+            return {
+                method: (options === null || options === void 0 ? void 0 : options.method) || 'GET',
+                url: typeof resource.toString === 'function' ? resource.toString() : '',
+            };
+        }
+        catch (e) {
+            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in fetch() wrapper: ${e}`, false, SEVERITY.error);
+        }
+        return defaultResource;
+    }
+    /**
+     * Setting up the wrapper around fetch functions to try and
+     * catch http errors
+     */
+    static setupGlobalFetchWrapper(proto) {
+        if (!propWriteableOrMadeWriteable(proto, 'fetch')) {
+            return;
+        }
+        replace(proto, 'fetch', function (originalFunction) {
+            // please don't change the name of this function. we need this stack frame to be nbuWrapper
+            return function nbuWrapper(resource, options) {
+                let request;
+                const { url, method } = RequestMonitor.getMethodUrlFromFetchArgs(resource, options);
+                if (resource instanceof Request) {
+                    /**
+                     * We clone the request object, as its body can only be read once per instance.
+                     * It's important that we do this before the original function is called, as it
+                     * cannot be cloned afterward.
+                     */
+                    request = resource.clone();
+                }
+                const startTime = Date.now();
+                const promiseFromOriginalFetch = originalFunction.call(this, resource, options);
+                promiseFromOriginalFetch
+                    .then(RequestMonitor.safeHandleFetchResponse(startTime, url, method, options, request))
+                    .catch(err => {
+                    RequestMonitor.handleFetchFailure(err, url);
+                });
+                return promiseFromOriginalFetch;
+            };
+        });
+    }
+    /**
+     * Does a check if data collection is enabled and combines it into HttpDataBundle
+     */
+    static getHttpDataFromXhr(xhrObj_1, method_1, url_1, isError_1) {
+        return __awaiter(this, arguments, void 0, function* (xhrObj, method, url, isError, requestPayload = null, responseText) {
+            if (!HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
+                return null;
+            }
+            const responseHeaders = HTTPDataBundler.headersMapFromString(xhrObj.getAllResponseHeaders());
+            return HTTPDataBundler.getInstance().bundleHTTPData(url, xhrObj.noibuRequestHeaders, requestPayload, responseHeaders, responseText, method, isError);
+        });
+    }
+    /**
+     * on loadend we catch the event and
+     * make sure it was correct
+     */
+    static loadendHandler(xhr, startTime, url, method, requestPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const respTime = Date.now() - startTime;
+            const gqlError = yield GqlErrorValidator.fromXhr(url, xhr);
+            const httpError = isHttpCodeFailure(xhr.status);
+            const responseText = yield HTTPDataBundler.getResponseStringFromXHR(xhr);
+            const httpEvent = RequestMonitor.getPvEventHttp(xhr.status, HTTPDataBundler.headersMapFromString(xhr.getAllResponseHeaders()), method, url, respTime);
+            const httpData = yield RequestMonitor.getHttpDataFromXhr(xhr, method, url, httpError || !!gqlError, requestPayload, responseText);
+            const pageVisitEventHTTP = new PageVisitEventHTTP(httpEvent, httpData, !!gqlError);
+            // Save HTTP Info
+            pageVisitEventHTTP.saveHTTPEvent();
+            const seq = (_a = pageVisitEventHTTP.httpData) === null || _a === void 0 ? void 0 : _a[PV_SEQ_ATT_NAME];
+            if (httpError) {
+                saveErrorToPagevisit(XML_HTTP_REQUEST_ERROR_TYPE, xhr, seq);
+            }
+            if (gqlError) {
+                gqlError.forEach(error => saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq));
+            }
+        });
+    }
+    /**
+     * Handles fetch failure
+     */
+    static handleFetchFailure(maybeErr, url) {
+        if (!maybeErr || typeof maybeErr !== 'object') {
+            return;
+        }
+        const err = maybeErr;
+        // we do not need this error if we cannot extract both the message and stack
+        if (!(err === null || err === void 0 ? void 0 : err.message) || !(err === null || err === void 0 ? void 0 : err.stack)) {
+            return;
+        }
+        const errorFromFetch = new Error();
+        errorFromFetch.stack = err.stack;
+        // making sure we have an url
+        const checkedURL = safeTrim(url);
+        const urlMessage = checkedURL ? ` on url ${checkedURL}` : '';
+        errorFromFetch.message = `${err.message}${urlMessage}`;
+        const errorPayload = {
+            error: errorFromFetch,
+        };
+        saveErrorToPagevisit(FETCH_EXCEPTION_ERROR_TYPE, errorPayload);
+    }
+    /** gets method from xhr */
+    static getMethodFromXHR(xhr, payload) {
+        if (xhr.noibuHttpMethod) {
+            return xhr.noibuHttpMethod;
+        }
+        // This is very hacky, but we do not really have an option as
+        // we do not have access to either the url nor the method when
+        // overriding the send method
+        return payload ? 'POST' : 'GET';
+    }
+    /**
+     * 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
+     */
+    static wrapXMLHTTPSend(proto) {
+        replace(proto, 'send', function (originalFunction) {
+            return function nbuWrapper(payload) {
+                try {
+                    const method = RequestMonitor.getMethodFromXHR(this, payload);
+                    const startTime = Date.now();
+                    addSafeEventListener(this, 'loadend', () => RequestMonitor.loadendHandler(this, startTime, this.noibuHttpUrl || this.responseURL, method, payload));
+                }
+                catch (e) {
+                    const stack = tryGetStackTrace(e);
+                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.send() wrapper: ${e}${stack}`, false, SEVERITY.error);
+                }
+                return originalFunction.call(this, payload);
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    static wrapXMLHTTPOpen(proto, shouldHandleLoadend) {
+        replace(proto, 'open', function (originalFunction) {
+            return function nbuWrapper(method, url, async = true, user = null, password = null) {
+                try {
+                    /**
+                     * We wrap assignment of the .noibu[...] variables in a try/catch, as we're assigning
+                     * properties to a built-in object type, and have no guarantee of success.
+                     */
+                    try {
+                        this.noibuHttpMethod = method;
+                        this.noibuHttpUrl = url;
+                    }
+                    catch (error) {
+                        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to set custom properties on XHR object: ${error}`, false, SEVERITY.warn);
+                    }
+                    if (shouldHandleLoadend) {
+                        const startTime = Date.now();
+                        addSafeEventListener(this, 'loadend', () => RequestMonitor.loadendHandler(this, startTime, url, method, null));
+                    }
+                }
+                catch (e) {
+                    const stack = tryGetStackTrace(e);
+                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.open() wrapper: ${e}${stack}`, false, SEVERITY.error);
+                }
+                return originalFunction.call(this, method, url, async, user, password);
+            };
+        });
+    }
+    /**
+     * 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
+     */
+    static wrapXMLHTTPSetRequestHeader(proto) {
+        replace(proto, 'setRequestHeader', function (originalFunction) {
+            return function nbuWrapper(header, value) {
+                // We wrap all of our logic in a try block to guarantee that we will complete the original
+                // implementation if we throw an error in our logic.
+                try {
+                    if (!(this.noibuRequestHeaders instanceof Map)) {
+                        this.noibuRequestHeaders = new Map();
+                    }
+                    // Ensure it's a string. This also converts null to "null"
+                    const stringValue = typeof value === 'string' ? value : String(value);
+                    if (typeof header === 'string') {
+                        this.noibuRequestHeaders.set(header.toLowerCase(), stringValue);
+                    }
+                }
+                catch (error) {
+                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.setRequestHeader() wrapper: ${error}`, false, SEVERITY.error);
+                }
+                return originalFunction.call(this, header, value);
+            };
+        });
+    }
+    /**
+     * Setting up the wrapper around send functions to try and
+     * catch http errors
+     */
+    static setupGlobalXMLHttpWrapper() {
+        if (typeof XMLHttpRequest === 'undefined') {
+            return;
+        }
+        const XMLHttp = XMLHttpRequest;
+        // The event target needs to have a prototype and have the open function
+        const proto = XMLHttp && XMLHttp.prototype;
+        const canWriteOpen = propWriteableOrMadeWriteable(proto, 'open');
+        const canWriteSend = propWriteableOrMadeWriteable(proto, 'send');
+        const canWriteSetHeader = propWriteableOrMadeWriteable(proto, 'setRequestHeader');
+        if (canWriteOpen) {
+            // If we can't wrap the XHR.send() function, we need the wrapped .open() function to
+            // set the listener on 'loadend' events.
+            RequestMonitor.wrapXMLHTTPOpen(proto, !canWriteSend);
+        }
+        if (canWriteSend) {
+            RequestMonitor.wrapXMLHTTPSend(proto);
+        }
+        if (canWriteSetHeader) {
+            RequestMonitor.wrapXMLHTTPSetRequestHeader(proto);
+        }
+    }
+}
+
+export { RequestMonitor as default };

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

@@ -0,0 +1,259 @@
+import { __awaiter } from 'tslib';
+import { isInstanceOf, getMaxSubstringAllowed } from '../../utils/function.js';
+import { CONTENT_TYPE, SEVERITY } from '../../constants.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
+     */
+    static fromFetch(url, options, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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
+     */
+    static fromXhr(url, xhr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const isResponseValid = isInstanceOf(xhr, XMLHttpRequest) &&
+                    xhr.status >= 200 &&
+                    xhr.status <= 299;
+                if (!isResponseValid) {
+                    return null;
+                }
+                let contentType;
+                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 = yield 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
+     */
+    static _parseJsonSafely(content) {
+        try {
+            return JSON.parse(content);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    /**
+     * Try to get content type for fetch arguments
+     */
+    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 aborted we are not able to consume the response
+     */
+    static _isRequestAborted(options, request) {
+        if (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
+     */
+    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
+     */
+    static _validate(data, validationIssues) {
+        if (!(typeof data === 'object' &&
+            data &&
+            Array.isArray(data.errors))) {
+            return null;
+        }
+        const errors = data.errors;
+        errors.forEach(error => {
+            if (typeof error !== 'object' || !error) {
+                return;
+            }
+            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
+     */
+    static _validateMessage(error) {
+        error[MESSAGE_ATT_NAME] = getMaxSubstringAllowed(error[MESSAGE_ATT_NAME], MESSAGE_MAX_LENGTH);
+    }
+    /**
+     * Sanitizes extensions object
+     * @param {any} error
+     */
+    static _validateExtensions(error) {
+        const json = JSON.stringify(error[EXTENSIONS_ATT_NAME]);
+        error[EXTENSIONS_ATT_NAME] = getMaxSubstringAllowed(json, MESSAGE_MAX_LENGTH);
+    }
+    /**
+     * Sanitizes locations object
+     */
+    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
+     */
+    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
+     */
+    static _postError(message) {
+        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`GQL parse error: ${message}`, false, SEVERITY.error);
+    }
+    /**
+     * Posts issue found during object sanitization
+     */
+    static _postValidationIssues(validationIssues) {
+        const message = validationIssues.join(',');
+        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`GQL error validation warning: ${message}`, false, SEVERITY.error);
+    }
+}
+
+export { GqlErrorValidator as default };