@kwiz/common 1.0.78 → 1.0.80

package/src/utils/rest.ts

@@ -1,502 +1,502 @@
-import { jsonParse } from "../helpers/json";
-import { assign, getGlobal, hasOwnProperty, jsonClone } from "../helpers/objects";
-import { isNullOrEmptyString, isNullOrUndefined, isNumber, isObject, isPrimitiveValue, isString } from "../helpers/typecheckers";
-import { IDictionary } from "../types/common.types";
-import { AllRestCacheOptionsKeys, IJsonSyncResult, IRequestBody, IRequestObjects, IRestCacheOptions, IRestError, IRestOptions, IRestRequestOptions, jsonTypes } from "../types/rest.types";
-import { ConsoleLogger } from "./consolelogger";
-import { getCacheItem, setCacheItem } from "./localstoragecache";
-import { getFormDigest } from "./sharepoint.rest/web";
-
-var logger = ConsoleLogger.get("kwizcom.rest.module");
-const supressDebugMessages = true;
-
-/** cache for 1 day */
-export const noLocalCache: IRestOptions = { allowCache: false };
-/** cache for 1 days */
-export const longLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 1 } };
-/** cache for 2 days */
-export const extraLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 2 } };
-/** cache for 7 days */
-export const weeekLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 7 } };
-/** cache for 30 days */
-export const monthLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 30 } };
-/** cache for 5 minutes */
-export const shortLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { minutes: 5 } };
-/** cache for 15 minutes */
-export const mediumLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { minutes: 15 } };
-
-interface IPendingRequest<T> {
-    objects: IRequestObjects;
-    /**the main promise */
-    promise: Promise<T>;
-    /**additional listeners
-     * must add a separate promise, so that I can make a full(not shallow) copy of the result.
-     * this way if the first caller changes the object, the second caller gets it unchanged.
-     */
-    listeners: {
-        resolve: (result: T) => void;
-        reject: (reason: any) => void;
-    }[];
-}
-
-//if allowCache is true, results will be stored/returned from here
-function _getCachedResults() {
-    var _cachedResults = getGlobal<{ [key: string]: IJsonSyncResult<any>; }>("utils_restmodule_cachedResults");
-    return _cachedResults;
-}
-
-//cannot use from top window, example: DVP, if you open view item popup and close it too fast, there might be a pending request that never resolves since the handler code was unloaded from the window.
-function _getPendingRequests() {
-    var _pendingRequests = getGlobal<IDictionary<IPendingRequest<any>>>("utils_restmodule_pendingRequests", undefined, true);
-    return _pendingRequests;
-}
-
-
-function getDefaultOptions(): IRestOptions {
-    return {
-        includeDigestInPost: true,
-        headers: {
-        }
-    };
-}
-
-function fillHeaders(xhr: XMLHttpRequest, headers: { [key: string]: string; }) {
-    for (let header in headers)
-        if (hasOwnProperty(headers, header)) {
-            let val = headers[header];
-            if (!isNullOrEmptyString(val))
-                xhr.setRequestHeader(header, val);
-        }
-}
-
-function getXhr(url: string, body?: IRequestBody, options?: IRestOptions, async = true): IRequestObjects {
-    var optionsWithDefaults = assign<IRestOptions>({}, getDefaultOptions(), options);
-    let myCacheOptions: IRestCacheOptions & { cacheKey?: string; } = {};
-    Object.keys(AllRestCacheOptionsKeys).forEach(key => {
-        if (hasOwnProperty(optionsWithDefaults, key)) {
-            myCacheOptions[key] = optionsWithDefaults[key];
-            delete optionsWithDefaults[key];
-        }
-    });
-    let myOptions: IRestRequestOptions = { ...optionsWithDefaults };
-
-    var xhr: XMLHttpRequest = new XMLHttpRequest();
-
-    let jsonType = myOptions.jsonMetadata || jsonTypes.verbose;
-
-    if (myOptions.cors) {
-        xhr.withCredentials = true;
-    }
-
-    if (isNullOrUndefined(myOptions.headers)) myOptions.headers = {};//issue 660 in case the sender sent headers as null
-    if (isNullOrUndefined(myOptions.headers["Accept"])) {
-        myOptions.headers["Accept"] = jsonType;
-    }
-
-    let method = myOptions.method;
-    if (isNullOrEmptyString(method)) {
-        method = isNullOrUndefined(body) ? "GET" : "POST";
-    }
-
-    myOptions.method = method;
-    xhr.open(method, url, async !== false);
-    if (method === "GET") {
-        if (myOptions.includeDigestInGet === true) {//by default don't add it, unless explicitly asked in options
-            xhr.setRequestHeader("X-RequestDigest", getFormDigest(myOptions.spWebUrl));
-        }
-    }
-    else if (method === "POST") {
-        if (isNullOrUndefined(myOptions.headers["content-type"])) {
-            myOptions.headers["content-type"] = jsonType;
-        }
-
-        if (myOptions.includeDigestInPost !== false) {//if explicitly set to false - don't include it
-            xhr.setRequestHeader("X-RequestDigest", getFormDigest(myOptions.spWebUrl));
-        }
-    }
-
-    if (!isNullOrEmptyString(myOptions.xHttpMethod)) {
-        myOptions.headers["X-HTTP-Method"] = myOptions.xHttpMethod;
-
-        if (myOptions.xHttpMethod === "MERGE" || myOptions.xHttpMethod === "DELETE" || myOptions.xHttpMethod === "PUT") {
-            myOptions.headers["If-Match"] = "*";// update regadless of other user changes
-        }
-    }
-
-    fillHeaders(xhr, myOptions.headers);
-
-    if (!isNullOrEmptyString(myOptions.responseType) && myOptions.responseType !== "text") {
-        if (myCacheOptions.allowCache === true &&
-            (myOptions.responseType === "blob" || myOptions.responseType === "arraybuffer" || myOptions.responseType === "document")) {
-            logger.warn("When allowCache is true, Blob, ArrayBuffer and Document response types will only be stored in runtime memory and not committed to local storage.");
-        }
-        xhr.responseType = myOptions.responseType;
-    }
-
-    //we do not support cache if there is a request body
-    //postCacheKey - allow cache on post request for stuff like get item by CamlQuery
-    if (isNullOrUndefined(body) || !isNullOrEmptyString(myOptions.postCacheKey)) {
-        myCacheOptions.cacheKey = (url + '|' + JSON.stringify(myOptions)).trim().toLowerCase();
-    }
-
-    return {
-        xhr: xhr,
-        options: myOptions,
-        cacheOptions: myCacheOptions
-    };
-}
-
-function getCachedResult<T>(objects: IRequestObjects): IJsonSyncResult<T> {
-    var cacheKey = objects.cacheOptions.cacheKey;
-    if (objects.cacheOptions.allowCache === true && objects.cacheOptions.forceCacheUpdate !== true) {
-        if (isNullOrEmptyString(cacheKey)) {
-            //logger.warn('cache is not supported for this type of request.');
-            return null;
-        }
-
-        let _cachedResults = _getCachedResults();
-        if (isNullOrUndefined(_cachedResults[cacheKey])) {
-            //try to load from local storage
-            let result = getCacheItem<IJsonSyncResult<T>>('jsr_' + cacheKey);
-
-            if (!isNullOrUndefined(result) && (result.success === true || result.status === 404)) {
-                if (!result.cachedTime) {
-                    let now = new Date();
-                    now.setDate(-1);
-                    result.cachedTime = now.getTime();
-                }
-
-                _cachedResults[cacheKey] = result;
-            }
-        }
-
-        if (!isNullOrUndefined(_cachedResults[cacheKey])) {
-            let result = _cachedResults[cacheKey];
-
-            var maxAge = isNumber(objects.cacheOptions.maxAge) && objects.cacheOptions.maxAge > 0 ? objects.cacheOptions.maxAge : null;
-
-            if (maxAge && result.cachedTime) {
-                let now = new Date().getTime();
-                var cachedTime = result.cachedTime;
-                var validUntil = cachedTime + (maxAge * 1000);
-
-                if (now > validUntil) {
-                    logger.debug("getCachedResult - entry has out lived max age");
-                    return null;
-                }
-            }
-
-            return {
-                ..._cachedResults[cacheKey],
-                result: _canSafelyStringify(_cachedResults[cacheKey].result) ?
-                    jsonClone(_cachedResults[cacheKey].result) :
-                    _cachedResults[cacheKey].result
-            };
-        }
-    }
-    return null;
-}
-
-function setCachedResult<T>(cacheOptions: IRestCacheOptions & { cacheKey?: string; }, response: IJsonSyncResult<T>) {
-    if (isNullOrEmptyString(cacheOptions.cacheKey)) {
-        return;
-    }
-    response.cachedTime = new Date().getTime();
-    let isResultSerializable = _canSafelyStringify(response.result);
-
-    let _cachedResults = _getCachedResults();
-    _cachedResults[cacheOptions.cacheKey] = {
-        ...response,
-        result: isResultSerializable ? jsonClone(response.result) : response.result
-    };
-
-    if (!isResultSerializable) {
-        logger.warn("When allowCache is true, Blob, ArrayBuffer and Document response types will only be stored in runtime memory and not committed to local storage.");
-    }
-
-    if (isResultSerializable && !isNullOrUndefined(cacheOptions.localStorageExpiration) && response && response.success === true) {
-        setCacheItem('jsr_' + cacheOptions.cacheKey, response, cacheOptions.localStorageExpiration as any);
-    }
-}
-
-function getPendingRequest<T = any>(objects: IRequestObjects): IPendingRequest<T> {
-    var cacheKey = objects.cacheOptions.cacheKey;
-    // if (isNullOrEmptyString(cacheKey)) {
-    //     logger.warn('cache is not supported for this type of request.');
-    // }
-
-    let _pendingRequests = _getPendingRequests();
-
-    if (!isNullOrEmptyString(cacheKey) && !isNullOrUndefined(_pendingRequests[cacheKey])) {
-        //returned from cache
-        return _pendingRequests[cacheKey];
-    }
-    return null;
-}
-
-function getParsedResponse<T>(objects: IRequestObjects) {
-    let parsedResponse: T = null;
-    if (!isNullOrEmptyString(objects.options.responseType) && objects.options.responseType !== "text") {
-        parsedResponse = objects.xhr.response;
-    } else {
-        if (objects.options.responseType !== "text") {
-            //Only try to parse if caller didn't expect text explicitly
-            parsedResponse = jsonParse(objects.xhr.responseText);
-        }
-        if (isNullOrUndefined(parsedResponse)) {
-            parsedResponse = objects.xhr.responseText as any;
-        }
-    }
-
-    return parsedResponse;
-}
-
-function setPendingRequest<T = any>(cacheKey: string, objects: IRequestObjects, promise: Promise<T>): IPendingRequest<T> {
-    if (isNullOrEmptyString(cacheKey)) {
-        return null;
-    }
-
-    let _pendingRequests = _getPendingRequests();
-    _pendingRequests[cacheKey] = { objects: objects, promise: promise, listeners: [] };
-    return _pendingRequests[cacheKey];
-}
-
-function removePendingRequest(cacheKey: string) {
-    if (isNullOrEmptyString(cacheKey)) {
-        return;
-    }
-
-    try {
-        let _pendingRequests = _getPendingRequests();
-        _pendingRequests[cacheKey] = null;
-        delete _pendingRequests[cacheKey];
-    } catch (ex) {
-    }
-}
-
-function _getRestErrorMessage(xhr: XMLHttpRequest) {
-    try {
-        //issue 245, external datasource might return error.code as a number with a plain text message.
-        if (!isNullOrUndefined(xhr) && !isNullOrEmptyString(xhr.responseText)) {
-            let error = jsonParse<{ code: string | number; message: string; }>(xhr.responseText);
-            if (!isNullOrUndefined(error) && !isNullOrEmptyString(error.code)) {
-                if (isString(error.code) && error.code.indexOf("SPQueryThrottledException") !== -1) {
-                    return !isNullOrEmptyString(error.message) ? `${error.message} (SPQueryThrottledException)` : `an error occured (SPQueryThrottledException)`;
-                }
-                if (!isNullOrEmptyString(error.message)) return error.message;
-            }
-        }
-    } catch (e) { }
-    return `an error occured`;
-}
-
-function _canSafelyStringify(result: any) {
-    //this would return false positives on some response strings    
-    if (isPrimitiveValue(result)) {
-        return true;
-    } else if (isObject(result)) {
-        if (
-            ("ArrayBuffer" in globalThis && (result instanceof ArrayBuffer))
-            || ("Blob" in globalThis && (result instanceof Blob))
-            || ("Document" in globalThis && (result instanceof Document))
-        ) {
-            return false;
-        }
-        return true;
-    } else {
-        return false;//shouldn't get here... since result should either be primitive value or an object
-    }
-}
-
-export function GetJsonSync<T>(url: string, body?: IRequestBody, options?: IRestOptions): IJsonSyncResult<T> {
-    let xhr: XMLHttpRequest = null;
-    let syncResult: IJsonSyncResult<T> = null;
-    let objects = getXhr(url, body, options, false);
-    try {
-        var cachedResult = getCachedResult<T>(objects);
-        if (!isNullOrUndefined(cachedResult)) {
-            return cachedResult;
-        }
-
-        xhr = objects.xhr;
-
-        if (objects.options.method === "GET") {
-            objects.xhr.send();
-        }
-        else {
-            objects.xhr.send(body);
-        }
-
-        if (objects.options.returnXhrObject === true) {
-            return {
-                status: xhr.status,
-                success: xhr.status >= 200 && xhr.status < 400,
-                result: xhr as any as T
-            } as any;
-        }
-
-        // status < 300 leaves out 304 responses which are successful responses so we should use < 400
-        if (objects.xhr.status >= 200 && objects.xhr.status < 400) {
-            let result: T = getParsedResponse<T>(objects);
-
-            syncResult = {
-                status: xhr.status,
-                success: true,
-                result: result
-            };
-
-            setCachedResult(objects.cacheOptions, syncResult);
-        } else {
-            throw new Error("Error code: " + objects.xhr.status);
-        }
-    } catch (e) {
-        //make sure errors get here and not returned without catch...
-        let responseText = xhr.responseText;
-        let errorData: any;
-        if (!isNullOrEmptyString(responseText)) {
-            errorData = jsonParse(responseText);
-            if (isNullOrUndefined(errorData)) {
-                errorData = responseText;
-            }
-        }
-
-        let errorMessage = _getRestErrorMessage(xhr);
-
-        syncResult = {
-            status: xhr && xhr.status || -1,
-            success: false,
-            errorData: errorData,
-            errorMessage: errorMessage
-        };
-        setCachedResult(objects.cacheOptions, syncResult);
-    }
-    return syncResult;
-}
-
-export function GetJson<T>(url: string, body?: IRequestBody, options?: IRestOptions): Promise<T> {
-    try {
-        let objects = getXhr(url, body, options);
-
-        var cachedResult = getCachedResult<T>(objects);
-        if (!isNullOrUndefined(cachedResult)) {
-            if (!supressDebugMessages) {
-                logger.debug(`GetJson - request fulfilled by cached results: ${url}`);
-            }
-            if (cachedResult.success) {
-                return Promise.resolve(cachedResult.result);
-            }
-            else {
-                return Promise.reject({
-                    message: isNullOrEmptyString(cachedResult.errorMessage) ? "an error occured in cached results" : cachedResult.errorMessage,
-                    errorData: cachedResult.errorData
-                } as IRestError);
-            }
-        }
-
-        var pendingRequest = getPendingRequest(objects);
-        var xhrPromise: Promise<T> = null;
-
-        if (isNullOrUndefined(pendingRequest)) {
-            if (!supressDebugMessages) {
-                logger.debug(`GetJson - request fulfilled by new request: ${url}`);
-            }
-            xhrPromise = new Promise((resolve, reject) => {
-                let promiseResolved = false;
-
-                objects.xhr.addEventListener("readystatechange", () => {
-                    if (objects.xhr.readyState === XMLHttpRequest.DONE) {
-                        try {
-                            if (!supressDebugMessages) {
-                                logger.debug(`readystate changed: ${url}`);
-                            }
-                            if (objects.options.returnXhrObject === true) {
-                                promiseResolved = true;
-                                resolve(objects.xhr as any as T);
-                            }
-
-                            let parsedResponse: T = getParsedResponse<T>(objects);
-
-                            // status < 300 leaves out 304 responses which are successful responses so we should use < 400
-                            if (objects.xhr.status >= 200 && objects.xhr.status < 400) {
-                                setCachedResult(objects.cacheOptions, { status: objects.xhr.status, success: true, result: parsedResponse });
-                                promiseResolved = true;
-                                resolve(parsedResponse);
-                                if (pendingRequest) {
-                                    pendingRequest.listeners.forEach(l => {
-                                        let listenerParsedResponse: T = getParsedResponse<T>(objects);
-                                        l.resolve(listenerParsedResponse);
-                                    });
-                                }
-                            } else {
-                                let errorMessage = _getRestErrorMessage(objects.xhr);
-                                setCachedResult(objects.cacheOptions, { status: objects.xhr.status, success: false, errorData: parsedResponse, errorMessage: errorMessage });
-                                promiseResolved = true;
-                                reject({ message: errorMessage, errorData: parsedResponse, xhr: objects.xhr } as IRestError);
-                                if (pendingRequest) {
-                                    pendingRequest.listeners.forEach(l => l.reject({ message: errorMessage, errorData: parsedResponse, xhr: objects.xhr } as IRestError));
-                                }
-                            }
-                        } catch (e) {
-                            if (!supressDebugMessages) {
-                                logger.error(`readystate error: ${e}: ${url}`);
-                            }
-                        }
-                        if (!promiseResolved) {
-                            if (!supressDebugMessages) {
-                                logger.debug(`promise NOT resolved. resoving myself...: ${url}`);
-                            }
-
-                            promiseResolved = true;
-                            reject({ message: "an unknown error occured", xhr: objects.xhr } as IRestError);
-                        }
-                        else if (!supressDebugMessages) {
-                            logger.debug(`promise resolved. removing pending request object: ${url}`);
-                        }
-
-                        removePendingRequest(objects.cacheOptions.cacheKey);
-                    }
-                });
-            });
-
-            if (objects.xhr.readyState === XMLHttpRequest.OPENED) {
-                //only set this if our request is on the way
-                pendingRequest = setPendingRequest(objects.cacheOptions.cacheKey, objects, xhrPromise);
-
-                if (!supressDebugMessages) {
-                    logger.debug(`${url}: sending request, setPendingRequest`);
-                }
-
-                if (objects.options.method === "GET") {
-                    objects.xhr.send();
-                } else {
-                    objects.xhr.send(body);
-                }
-            }
-            else logger.error('xhr not opened');
-        } else if (pendingRequest) {
-            if (!supressDebugMessages) {
-                logger.debug(`GetJson - request fulfilled by pending requests: ${url}`);
-            }
-            //must add a separate promise, so that I can make a full(not shallow) copy of the result.
-            //this way if the first caller changes the object, the second caller gets it unchanged.
-            xhrPromise = new Promise<T>((resolve, reject) => {
-                pendingRequest.listeners.push({
-                    resolve: (result: T) => resolve(result),
-                    reject: (reason) => reject(reason)
-                });
-            });
-        }
-
-        return xhrPromise;
-    } catch (e) {
-        return Promise.reject({ message: "an error occured" });
-    }
-}
-
-/** if you detected a change that invalidates all requests stored in memory - this will clear all in-memory cached results */
-export function GetJsonClearCache() {
-    let _cachedResults = _getCachedResults();
-    Object.keys(_cachedResults).forEach(key => {
-        delete _cachedResults[key];
-    });
+import { jsonParse } from "../helpers/json";
+import { assign, getGlobal, hasOwnProperty, jsonClone } from "../helpers/objects";
+import { isNullOrEmptyString, isNullOrUndefined, isNumber, isObject, isPrimitiveValue, isString } from "../helpers/typecheckers";
+import { IDictionary } from "../types/common.types";
+import { AllRestCacheOptionsKeys, IJsonSyncResult, IRequestBody, IRequestObjects, IRestCacheOptions, IRestError, IRestOptions, IRestRequestOptions, jsonTypes } from "../types/rest.types";
+import { ConsoleLogger } from "./consolelogger";
+import { getCacheItem, setCacheItem } from "./localstoragecache";
+import { getFormDigest } from "./sharepoint.rest/web";
+
+var logger = ConsoleLogger.get("kwizcom.rest.module");
+const supressDebugMessages = true;
+
+/** cache for 1 day */
+export const noLocalCache: IRestOptions = { allowCache: false };
+/** cache for 1 days */
+export const longLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 1 } };
+/** cache for 2 days */
+export const extraLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 2 } };
+/** cache for 7 days */
+export const weeekLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 7 } };
+/** cache for 30 days */
+export const monthLongLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { days: 30 } };
+/** cache for 5 minutes */
+export const shortLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { minutes: 5 } };
+/** cache for 15 minutes */
+export const mediumLocalCache: IRestOptions = { allowCache: true, localStorageExpiration: { minutes: 15 } };
+
+interface IPendingRequest<T> {
+    objects: IRequestObjects;
+    /**the main promise */
+    promise: Promise<T>;
+    /**additional listeners
+     * must add a separate promise, so that I can make a full(not shallow) copy of the result.
+     * this way if the first caller changes the object, the second caller gets it unchanged.
+     */
+    listeners: {
+        resolve: (result: T) => void;
+        reject: (reason: any) => void;
+    }[];
+}
+
+//if allowCache is true, results will be stored/returned from here
+function _getCachedResults() {
+    var _cachedResults = getGlobal<{ [key: string]: IJsonSyncResult<any>; }>("utils_restmodule_cachedResults");
+    return _cachedResults;
+}
+
+//cannot use from top window, example: DVP, if you open view item popup and close it too fast, there might be a pending request that never resolves since the handler code was unloaded from the window.
+function _getPendingRequests() {
+    var _pendingRequests = getGlobal<IDictionary<IPendingRequest<any>>>("utils_restmodule_pendingRequests", undefined, true);
+    return _pendingRequests;
+}
+
+
+function getDefaultOptions(): IRestOptions {
+    return {
+        includeDigestInPost: true,
+        headers: {
+        }
+    };
+}
+
+function fillHeaders(xhr: XMLHttpRequest, headers: { [key: string]: string; }) {
+    for (let header in headers)
+        if (hasOwnProperty(headers, header)) {
+            let val = headers[header];
+            if (!isNullOrEmptyString(val))
+                xhr.setRequestHeader(header, val);
+        }
+}
+
+function getXhr(url: string, body?: IRequestBody, options?: IRestOptions, async = true): IRequestObjects {
+    var optionsWithDefaults = assign<IRestOptions>({}, getDefaultOptions(), options);
+    let myCacheOptions: IRestCacheOptions & { cacheKey?: string; } = {};
+    Object.keys(AllRestCacheOptionsKeys).forEach(key => {
+        if (hasOwnProperty(optionsWithDefaults, key)) {
+            myCacheOptions[key] = optionsWithDefaults[key];
+            delete optionsWithDefaults[key];
+        }
+    });
+    let myOptions: IRestRequestOptions = { ...optionsWithDefaults };
+
+    var xhr: XMLHttpRequest = new XMLHttpRequest();
+
+    let jsonType = myOptions.jsonMetadata || jsonTypes.verbose;
+
+    if (myOptions.cors) {
+        xhr.withCredentials = true;
+    }
+
+    if (isNullOrUndefined(myOptions.headers)) myOptions.headers = {};//issue 660 in case the sender sent headers as null
+    if (isNullOrUndefined(myOptions.headers["Accept"])) {
+        myOptions.headers["Accept"] = jsonType;
+    }
+
+    let method = myOptions.method;
+    if (isNullOrEmptyString(method)) {
+        method = isNullOrUndefined(body) ? "GET" : "POST";
+    }
+
+    myOptions.method = method;
+    xhr.open(method, url, async !== false);
+    if (method === "GET") {
+        if (myOptions.includeDigestInGet === true) {//by default don't add it, unless explicitly asked in options
+            xhr.setRequestHeader("X-RequestDigest", getFormDigest(myOptions.spWebUrl));
+        }
+    }
+    else if (method === "POST") {
+        if (isNullOrUndefined(myOptions.headers["content-type"])) {
+            myOptions.headers["content-type"] = jsonType;
+        }
+
+        if (myOptions.includeDigestInPost !== false) {//if explicitly set to false - don't include it
+            xhr.setRequestHeader("X-RequestDigest", getFormDigest(myOptions.spWebUrl));
+        }
+    }
+
+    if (!isNullOrEmptyString(myOptions.xHttpMethod)) {
+        myOptions.headers["X-HTTP-Method"] = myOptions.xHttpMethod;
+
+        if (myOptions.xHttpMethod === "MERGE" || myOptions.xHttpMethod === "DELETE" || myOptions.xHttpMethod === "PUT") {
+            myOptions.headers["If-Match"] = "*";// update regadless of other user changes
+        }
+    }
+
+    fillHeaders(xhr, myOptions.headers);
+
+    if (!isNullOrEmptyString(myOptions.responseType) && myOptions.responseType !== "text") {
+        if (myCacheOptions.allowCache === true &&
+            (myOptions.responseType === "blob" || myOptions.responseType === "arraybuffer" || myOptions.responseType === "document")) {
+            logger.warn("When allowCache is true, Blob, ArrayBuffer and Document response types will only be stored in runtime memory and not committed to local storage.");
+        }
+        xhr.responseType = myOptions.responseType;
+    }
+
+    //we do not support cache if there is a request body
+    //postCacheKey - allow cache on post request for stuff like get item by CamlQuery
+    if (isNullOrUndefined(body) || !isNullOrEmptyString(myOptions.postCacheKey)) {
+        myCacheOptions.cacheKey = (url + '|' + JSON.stringify(myOptions)).trim().toLowerCase();
+    }
+
+    return {
+        xhr: xhr,
+        options: myOptions,
+        cacheOptions: myCacheOptions
+    };
+}
+
+function getCachedResult<T>(objects: IRequestObjects): IJsonSyncResult<T> {
+    var cacheKey = objects.cacheOptions.cacheKey;
+    if (objects.cacheOptions.allowCache === true && objects.cacheOptions.forceCacheUpdate !== true) {
+        if (isNullOrEmptyString(cacheKey)) {
+            //logger.warn('cache is not supported for this type of request.');
+            return null;
+        }
+
+        let _cachedResults = _getCachedResults();
+        if (isNullOrUndefined(_cachedResults[cacheKey])) {
+            //try to load from local storage
+            let result = getCacheItem<IJsonSyncResult<T>>('jsr_' + cacheKey);
+
+            if (!isNullOrUndefined(result) && (result.success === true || result.status === 404)) {
+                if (!result.cachedTime) {
+                    let now = new Date();
+                    now.setDate(-1);
+                    result.cachedTime = now.getTime();
+                }
+
+                _cachedResults[cacheKey] = result;
+            }
+        }
+
+        if (!isNullOrUndefined(_cachedResults[cacheKey])) {
+            let result = _cachedResults[cacheKey];
+
+            var maxAge = isNumber(objects.cacheOptions.maxAge) && objects.cacheOptions.maxAge > 0 ? objects.cacheOptions.maxAge : null;
+
+            if (maxAge && result.cachedTime) {
+                let now = new Date().getTime();
+                var cachedTime = result.cachedTime;
+                var validUntil = cachedTime + (maxAge * 1000);
+
+                if (now > validUntil) {
+                    logger.debug("getCachedResult - entry has out lived max age");
+                    return null;
+                }
+            }
+
+            return {
+                ..._cachedResults[cacheKey],
+                result: _canSafelyStringify(_cachedResults[cacheKey].result) ?
+                    jsonClone(_cachedResults[cacheKey].result) :
+                    _cachedResults[cacheKey].result
+            };
+        }
+    }
+    return null;
+}
+
+function setCachedResult<T>(cacheOptions: IRestCacheOptions & { cacheKey?: string; }, response: IJsonSyncResult<T>) {
+    if (isNullOrEmptyString(cacheOptions.cacheKey)) {
+        return;
+    }
+    response.cachedTime = new Date().getTime();
+    let isResultSerializable = _canSafelyStringify(response.result);
+
+    let _cachedResults = _getCachedResults();
+    _cachedResults[cacheOptions.cacheKey] = {
+        ...response,
+        result: isResultSerializable ? jsonClone(response.result) : response.result
+    };
+
+    if (!isResultSerializable) {
+        logger.warn("When allowCache is true, Blob, ArrayBuffer and Document response types will only be stored in runtime memory and not committed to local storage.");
+    }
+
+    if (isResultSerializable && !isNullOrUndefined(cacheOptions.localStorageExpiration) && response && response.success === true) {
+        setCacheItem('jsr_' + cacheOptions.cacheKey, response, cacheOptions.localStorageExpiration as any);
+    }
+}
+
+function getPendingRequest<T = any>(objects: IRequestObjects): IPendingRequest<T> {
+    var cacheKey = objects.cacheOptions.cacheKey;
+    // if (isNullOrEmptyString(cacheKey)) {
+    //     logger.warn('cache is not supported for this type of request.');
+    // }
+
+    let _pendingRequests = _getPendingRequests();
+
+    if (!isNullOrEmptyString(cacheKey) && !isNullOrUndefined(_pendingRequests[cacheKey])) {
+        //returned from cache
+        return _pendingRequests[cacheKey];
+    }
+    return null;
+}
+
+function getParsedResponse<T>(objects: IRequestObjects) {
+    let parsedResponse: T = null;
+    if (!isNullOrEmptyString(objects.options.responseType) && objects.options.responseType !== "text") {
+        parsedResponse = objects.xhr.response;
+    } else {
+        if (objects.options.responseType !== "text") {
+            //Only try to parse if caller didn't expect text explicitly
+            parsedResponse = jsonParse(objects.xhr.responseText);
+        }
+        if (isNullOrUndefined(parsedResponse)) {
+            parsedResponse = objects.xhr.responseText as any;
+        }
+    }
+
+    return parsedResponse;
+}
+
+function setPendingRequest<T = any>(cacheKey: string, objects: IRequestObjects, promise: Promise<T>): IPendingRequest<T> {
+    if (isNullOrEmptyString(cacheKey)) {
+        return null;
+    }
+
+    let _pendingRequests = _getPendingRequests();
+    _pendingRequests[cacheKey] = { objects: objects, promise: promise, listeners: [] };
+    return _pendingRequests[cacheKey];
+}
+
+function removePendingRequest(cacheKey: string) {
+    if (isNullOrEmptyString(cacheKey)) {
+        return;
+    }
+
+    try {
+        let _pendingRequests = _getPendingRequests();
+        _pendingRequests[cacheKey] = null;
+        delete _pendingRequests[cacheKey];
+    } catch (ex) {
+    }
+}
+
+function _getRestErrorMessage(xhr: XMLHttpRequest) {
+    try {
+        //issue 245, external datasource might return error.code as a number with a plain text message.
+        if (!isNullOrUndefined(xhr) && !isNullOrEmptyString(xhr.responseText)) {
+            let error = jsonParse<{ code: string | number; message: string; }>(xhr.responseText);
+            if (!isNullOrUndefined(error) && !isNullOrEmptyString(error.code)) {
+                if (isString(error.code) && error.code.indexOf("SPQueryThrottledException") !== -1) {
+                    return !isNullOrEmptyString(error.message) ? `${error.message} (SPQueryThrottledException)` : `an error occured (SPQueryThrottledException)`;
+                }
+                if (!isNullOrEmptyString(error.message)) return error.message;
+            }
+        }
+    } catch (e) { }
+    return `an error occured`;
+}
+
+function _canSafelyStringify(result: any) {
+    //this would return false positives on some response strings    
+    if (isPrimitiveValue(result)) {
+        return true;
+    } else if (isObject(result)) {
+        if (
+            ("ArrayBuffer" in globalThis && (result instanceof ArrayBuffer))
+            || ("Blob" in globalThis && (result instanceof Blob))
+            || ("Document" in globalThis && (result instanceof Document))
+        ) {
+            return false;
+        }
+        return true;
+    } else {
+        return false;//shouldn't get here... since result should either be primitive value or an object
+    }
+}
+
+export function GetJsonSync<T>(url: string, body?: IRequestBody, options?: IRestOptions): IJsonSyncResult<T> {
+    let xhr: XMLHttpRequest = null;
+    let syncResult: IJsonSyncResult<T> = null;
+    let objects = getXhr(url, body, options, false);
+    try {
+        var cachedResult = getCachedResult<T>(objects);
+        if (!isNullOrUndefined(cachedResult)) {
+            return cachedResult;
+        }
+
+        xhr = objects.xhr;
+
+        if (objects.options.method === "GET") {
+            objects.xhr.send();
+        }
+        else {
+            objects.xhr.send(body);
+        }
+
+        if (objects.options.returnXhrObject === true) {
+            return {
+                status: xhr.status,
+                success: xhr.status >= 200 && xhr.status < 400,
+                result: xhr as any as T
+            } as any;
+        }
+
+        // status < 300 leaves out 304 responses which are successful responses so we should use < 400
+        if (objects.xhr.status >= 200 && objects.xhr.status < 400) {
+            let result: T = getParsedResponse<T>(objects);
+
+            syncResult = {
+                status: xhr.status,
+                success: true,
+                result: result
+            };
+
+            setCachedResult(objects.cacheOptions, syncResult);
+        } else {
+            throw new Error("Error code: " + objects.xhr.status);
+        }
+    } catch (e) {
+        //make sure errors get here and not returned without catch...
+        let responseText = xhr.responseText;
+        let errorData: any;
+        if (!isNullOrEmptyString(responseText)) {
+            errorData = jsonParse(responseText);
+            if (isNullOrUndefined(errorData)) {
+                errorData = responseText;
+            }
+        }
+
+        let errorMessage = _getRestErrorMessage(xhr);
+
+        syncResult = {
+            status: xhr && xhr.status || -1,
+            success: false,
+            errorData: errorData,
+            errorMessage: errorMessage
+        };
+        setCachedResult(objects.cacheOptions, syncResult);
+    }
+    return syncResult;
+}
+
+export function GetJson<T>(url: string, body?: IRequestBody, options?: IRestOptions): Promise<T> {
+    try {
+        let objects = getXhr(url, body, options);
+
+        var cachedResult = getCachedResult<T>(objects);
+        if (!isNullOrUndefined(cachedResult)) {
+            if (!supressDebugMessages) {
+                logger.debug(`GetJson - request fulfilled by cached results: ${url}`);
+            }
+            if (cachedResult.success) {
+                return Promise.resolve(cachedResult.result);
+            }
+            else {
+                return Promise.reject({
+                    message: isNullOrEmptyString(cachedResult.errorMessage) ? "an error occured in cached results" : cachedResult.errorMessage,
+                    errorData: cachedResult.errorData
+                } as IRestError);
+            }
+        }
+
+        var pendingRequest = getPendingRequest(objects);
+        var xhrPromise: Promise<T> = null;
+
+        if (isNullOrUndefined(pendingRequest)) {
+            if (!supressDebugMessages) {
+                logger.debug(`GetJson - request fulfilled by new request: ${url}`);
+            }
+            xhrPromise = new Promise((resolve, reject) => {
+                let promiseResolved = false;
+
+                objects.xhr.addEventListener("readystatechange", () => {
+                    if (objects.xhr.readyState === XMLHttpRequest.DONE) {
+                        try {
+                            if (!supressDebugMessages) {
+                                logger.debug(`readystate changed: ${url}`);
+                            }
+                            if (objects.options.returnXhrObject === true) {
+                                promiseResolved = true;
+                                resolve(objects.xhr as any as T);
+                            }
+
+                            let parsedResponse: T = getParsedResponse<T>(objects);
+
+                            // status < 300 leaves out 304 responses which are successful responses so we should use < 400
+                            if (objects.xhr.status >= 200 && objects.xhr.status < 400) {
+                                setCachedResult(objects.cacheOptions, { status: objects.xhr.status, success: true, result: parsedResponse });
+                                promiseResolved = true;
+                                resolve(parsedResponse);
+                                if (pendingRequest) {
+                                    pendingRequest.listeners.forEach(l => {
+                                        let listenerParsedResponse: T = getParsedResponse<T>(objects);
+                                        l.resolve(listenerParsedResponse);
+                                    });
+                                }
+                            } else {
+                                let errorMessage = _getRestErrorMessage(objects.xhr);
+                                setCachedResult(objects.cacheOptions, { status: objects.xhr.status, success: false, errorData: parsedResponse, errorMessage: errorMessage });
+                                promiseResolved = true;
+                                reject({ message: errorMessage, errorData: parsedResponse, xhr: objects.xhr } as IRestError);
+                                if (pendingRequest) {
+                                    pendingRequest.listeners.forEach(l => l.reject({ message: errorMessage, errorData: parsedResponse, xhr: objects.xhr } as IRestError));
+                                }
+                            }
+                        } catch (e) {
+                            if (!supressDebugMessages) {
+                                logger.error(`readystate error: ${e}: ${url}`);
+                            }
+                        }
+                        if (!promiseResolved) {
+                            if (!supressDebugMessages) {
+                                logger.debug(`promise NOT resolved. resoving myself...: ${url}`);
+                            }
+
+                            promiseResolved = true;
+                            reject({ message: "an unknown error occured", xhr: objects.xhr } as IRestError);
+                        }
+                        else if (!supressDebugMessages) {
+                            logger.debug(`promise resolved. removing pending request object: ${url}`);
+                        }
+
+                        removePendingRequest(objects.cacheOptions.cacheKey);
+                    }
+                });
+            });
+
+            if (objects.xhr.readyState === XMLHttpRequest.OPENED) {
+                //only set this if our request is on the way
+                pendingRequest = setPendingRequest(objects.cacheOptions.cacheKey, objects, xhrPromise);
+
+                if (!supressDebugMessages) {
+                    logger.debug(`${url}: sending request, setPendingRequest`);
+                }
+
+                if (objects.options.method === "GET") {
+                    objects.xhr.send();
+                } else {
+                    objects.xhr.send(body);
+                }
+            }
+            else logger.error('xhr not opened');
+        } else if (pendingRequest) {
+            if (!supressDebugMessages) {
+                logger.debug(`GetJson - request fulfilled by pending requests: ${url}`);
+            }
+            //must add a separate promise, so that I can make a full(not shallow) copy of the result.
+            //this way if the first caller changes the object, the second caller gets it unchanged.
+            xhrPromise = new Promise<T>((resolve, reject) => {
+                pendingRequest.listeners.push({
+                    resolve: (result: T) => resolve(result),
+                    reject: (reason) => reject(reason)
+                });
+            });
+        }
+
+        return xhrPromise;
+    } catch (e) {
+        return Promise.reject({ message: "an error occured" });
+    }
+}
+
+/** if you detected a change that invalidates all requests stored in memory - this will clear all in-memory cached results */
+export function GetJsonClearCache() {
+    let _cachedResults = _getCachedResults();
+    Object.keys(_cachedResults).forEach(key => {
+        delete _cachedResults[key];
+    });
 }