@wise/dynamic-flow-client 3.2.1 → 3.2.2-short-962e290

package/build/legacy/dynamicFlow/utils/responseParsers/response-parsers.js

@@ -0,0 +1,185 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { isObject } from '../../../common/validators';
+var parseFetchResponseByResponseType = function (response, type) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (type) {
+            case 'step':
+                return [2 /*return*/, parseStepResponse(response)];
+            case 'exit':
+                return [2 /*return*/, parseExitResponse(response)];
+            case 'action':
+                return [2 /*return*/, parseActionResponse(response)];
+            default:
+                throw new Error("Unsupported X-Df-Response-Type. Allowed values are 'step', 'action', 'exit'.");
+        }
+        return [2 /*return*/];
+    });
+}); };
+var parseStepResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody, etag;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                jsonBody = _a.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in response. Expected an object.');
+                }
+                etag = response.headers.get('etag') || undefined;
+                return [2 /*return*/, { type: 'step', step: jsonBody, etag: etag }];
+        }
+    });
+}); };
+var parseActionResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody, action;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                jsonBody = _a.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in response. Expected an object.');
+                }
+                if (!isObject(jsonBody.action)) {
+                    throw new Error('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.');
+                }
+                action = jsonBody.action;
+                if (action.exit === true && isObject(action.result)) {
+                    return [2 /*return*/, { type: 'exit', result: action.result }];
+                }
+                return [2 /*return*/, { type: 'action', action: jsonBody.action }];
+        }
+    });
+}); };
+var parseExitResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = { type: 'exit' };
+                return [4 /*yield*/, getJsonObjectOrNull(response)];
+            case 1: return [2 /*return*/, (_a.result = _b.sent(), _a)];
+        }
+    });
+}); };
+export var parseFetchResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var type, jsonBody;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                assertResponseIsValid(response);
+                if ((_a = response.headers) === null || _a === void 0 ? void 0 : _a.has('X-Df-Response-Type')) {
+                    type = response.headers.get('X-Df-Response-Type');
+                    return [2 /*return*/, parseFetchResponseByResponseType(response, type)];
+                }
+                if ((_b = response.headers) === null || _b === void 0 ? void 0 : _b.has('X-Df-Exit')) {
+                    return [2 /*return*/, parseExitResponse(response)];
+                }
+                return [4 /*yield*/, parseResponseJson(response.clone())];
+            case 1:
+                jsonBody = _c.sent();
+                if (isObject(jsonBody) && jsonBody.action) {
+                    return [2 /*return*/, parseActionResponse(response)];
+                }
+                return [2 /*return*/, parseStepResponse(response)];
+        }
+    });
+}); };
+export var parseErrorResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                assertResponseIsValid(response);
+                return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                jsonBody = _a.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in error response. Expected an object.');
+                }
+                if (!jsonBody.refreshFormUrl && !jsonBody.refreshUrl && !jsonBody.validation && !jsonBody.error) {
+                    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+                    throw jsonBody;
+                }
+                return [2 /*return*/, jsonBody];
+        }
+    });
+}); };
+export var getJsonObjectOrNull = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                assertResponseIsValid(response);
+                return [4 /*yield*/, parseResponseJson(response)];
+            case 1:
+                result = _a.sent();
+                return [2 /*return*/, isObject(result) ? result : null];
+        }
+    });
+}); };
+var parseResponseJson = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, response.json()];
+            case 1: return [2 /*return*/, (_b.sent())];
+            case 2:
+                _a = _b.sent();
+                return [2 /*return*/, null];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+var assertResponseIsValid = function (response) {
+    if (!isResponse(response)) {
+        throw new Error('Incorrect type of response from fetch. Expected object of type Response.');
+    }
+    if (response.bodyUsed) {
+        throw new Error('The body of the provided Response object has already been used. Every request must respond with a new Response object.');
+    }
+};
+var isResponse = function (response) {
+    return typeof response === 'object' &&
+        response !== null &&
+        'clone' in response &&
+        'bodyUsed' in response;
+};

package/build/legacy/dynamicFlow/utils/responseParsers/response-parsers.spec.js

@@ -0,0 +1,463 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { parseFetchResponse, parseErrorResponse, getJsonObjectOrNull } from './response-parsers';
+describe('parseFetchResponse', function () {
+    describe('when the response object is not an instance of Response', function () {
+        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = { invalid: 'response' };
+                        return [4 /*yield*/, expect(parseFetchResponse(response)).rejects.toThrow('Incorrect type of response from fetch. Expected object of type Response.')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when the Response body has already been parsed', function () {
+        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new Response("{}");
+                        return [4 /*yield*/, response.json()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, expect(parseFetchResponse(response)).rejects.toThrow('The body of the provided Response object has already been used. Every request must respond with a new Response object.')];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when response contains the X-DF-Response-Type header', function () {
+        describe('step (with etag)', function () {
+            var headers = { 'X-Df-Response-Type': 'step', etag: '4be5c814' };
+            it('returns a "step" object with the step taken from the response body and etag', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var parsedBody;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"id\": \"step-id\" }", { headers: headers }))];
+                        case 1:
+                            parsedBody = _a.sent();
+                            expect(parsedBody).toStrictEqual({
+                                type: 'step',
+                                step: { id: 'step-id' },
+                                etag: '4be5c814'
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        describe('step (but no etag)', function () {
+            var headers = { 'X-Df-Response-Type': 'step' };
+            it('returns a "step" object with the step taken from the response body and an etag property as undefined', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var parsedBody;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"id\": \"step-id\" }", { headers: headers }))];
+                        case 1:
+                            parsedBody = _a.sent();
+                            expect(parsedBody).toStrictEqual({
+                                type: 'step',
+                                step: { id: 'step-id' },
+                                etag: undefined
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        describe('action', function () {
+            describe('when the body contains a valid action', function () {
+                var headers = { 'X-Df-Response-Type': 'action' };
+                it('returns an "action" object with the response body action', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var parsedBody;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"action\": { \"$id\": \"action-id\" } }", { headers: headers }))];
+                            case 1:
+                                parsedBody = _a.sent();
+                                expect(parsedBody).toStrictEqual({
+                                    type: 'action',
+                                    action: { $id: 'action-id' }
+                                });
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+            describe('when the body contains an invalid action', function () {
+                var headers = { 'X-Df-Response-Type': 'action' };
+                it('throws an error', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, expect(parseFetchResponse(new Response("{ \"action\": \"this is not an action\" }", { headers: headers }))).rejects.toThrow('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.')];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+            describe('when the body contains an exit action', function () {
+                var headers = { 'X-Df-Response-Type': 'action' };
+                it('returns an "exit" object with the response body action.result as result', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var parsedBody;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, parseFetchResponse(new Response("{ \"action\": { \"exit\": true, \"result\": {\"my-result\": 1234 } } }", {
+                                    headers: headers
+                                }))];
+                            case 1:
+                                parsedBody = _a.sent();
+                                expect(parsedBody).toStrictEqual({
+                                    type: 'exit',
+                                    result: { 'my-result': 1234 }
+                                });
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+        describe('exit', function () {
+            var headers = { 'X-Df-Response-Type': 'exit' };
+            it('returns "exit" with the response body as result', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var parsedBody;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, parseFetchResponse(new Response('{"id": 12345, "name": "Bob Loblaw", "url": "bobloblaw.law.blog" }', {
+                                headers: headers
+                            }))];
+                        case 1:
+                            parsedBody = _a.sent();
+                            expect(parsedBody).toStrictEqual({
+                                type: 'exit',
+                                result: { id: 12345, name: 'Bob Loblaw', url: 'bobloblaw.law.blog' }
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    describe('when response contains the X-DF-Exit header', function () {
+        var headers = { 'X-Df-Exit': 'true' };
+        describe('and response body can be json-parsed as an object', function () {
+            it('should return exit result', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var response, parsedBody;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            response = new Response("{ \"exitResult\": \"exit result\" }", { headers: headers });
+                            return [4 /*yield*/, parseFetchResponse(response)];
+                        case 1:
+                            parsedBody = _a.sent();
+                            expect(parsedBody).toStrictEqual({
+                                type: 'exit',
+                                result: { exitResult: 'exit result' }
+                            });
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        describe('but response body cannot be json-parsed as an object', function () {
+            describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
+                it("returns exit result with null", function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var parsedBody;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, parseFetchResponse(new Response(body, { headers: headers }))];
+                            case 1:
+                                parsedBody = _a.sent();
+                                expect(parsedBody).toStrictEqual({ type: 'exit', result: null });
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+    });
+    describe('when response does not contain the X-DF-Exit header', function () {
+        var headers = { etag: 'etag' };
+        describe('and response body can be json-parsed as an object', function () {
+            describe('and it contains an action property', function () {
+                describe('and the action property is an object', function () {
+                    it('assumes the action property is of type Action, and returns type action and the action', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var parsedBody;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, parseFetchResponse(new Response('{ "action": { "url": "/path", "method": "POST" } }'))];
+                                case 1:
+                                    parsedBody = _a.sent();
+                                    expect(parsedBody).toStrictEqual({
+                                        type: 'action',
+                                        action: { url: '/path', method: 'POST' }
+                                    });
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    it('assumes the action property is of type Action, even if its NOT', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var parsedBody;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, parseFetchResponse(new Response('{ "action": { "random": "property" } }'))];
+                                case 1:
+                                    parsedBody = _a.sent();
+                                    expect(parsedBody).toStrictEqual({ type: 'action', action: { random: 'property' } });
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                });
+                describe('and the action property is NOT an object', function () {
+                    it('throws an error', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, expect(parseFetchResponse(new Response('{ "action": 123 }'))).rejects.toThrow('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.')];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                });
+            });
+            describe('when the body is NOT an object with an action property', function () {
+                it('assumes the response is a step and returns step and etag', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var response, parsedBody;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                response = new Response("{ \"stepResult\": \"step result\" }", { headers: headers });
+                                return [4 /*yield*/, parseFetchResponse(response)];
+                            case 1:
+                                parsedBody = _a.sent();
+                                expect(parsedBody).toStrictEqual({
+                                    type: 'step',
+                                    step: { stepResult: 'step result' },
+                                    etag: 'etag'
+                                });
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+        describe('but response body cannot be json-parsed as an object', function () {
+            describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
+                it("throws an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, expect(parseFetchResponse(new Response(body))).rejects.toThrow('Incorrect response body in response. Expected an object.')];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+    });
+});
+describe('parseErrorResponse', function () {
+    describe('when the response object is not an instance of Response', function () {
+        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = { invalid: 'response' };
+                        return [4 /*yield*/, expect(parseErrorResponse(response)).rejects.toThrow('Incorrect type of response from fetch. Expected object of type Response.')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when the Response body has already been parsed', function () {
+        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new Response("{}");
+                        return [4 /*yield*/, response.json()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, expect(parseErrorResponse(response)).rejects.toThrow('The body of the provided Response object has already been used. Every request must respond with a new Response object.')];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when response body can be json-parsed as an object', function () {
+        it('returns the response body', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response, parsedBody;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new Response(JSON.stringify({
+                            error: 'This is a global error',
+                            validation: { field: 'This is a field error' }
+                        }), { status: 422 });
+                        return [4 /*yield*/, parseErrorResponse(response)];
+                    case 1:
+                        parsedBody = _a.sent();
+                        expect(parsedBody).toStrictEqual({
+                            error: 'This is a global error',
+                            validation: { field: 'This is a field error' }
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when response body CANNOT be json-parsed as an object', function () {
+        describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
+            it("throws an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, expect(parseErrorResponse(new Response(body))).rejects.toThrow('Incorrect response body in error response. Expected an object.')];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+});
+describe('getJsonObjectOrNull', function () {
+    describe('when the response object is not an instance of Response', function () {
+        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = { invalid: 'response' };
+                        return [4 /*yield*/, expect(getJsonObjectOrNull(response)).rejects.toThrow('Incorrect type of response from fetch. Expected object of type Response.')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when the Response body has already been parsed', function () {
+        it('throws a clear error message', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new Response("{}");
+                        return [4 /*yield*/, response.json()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, expect(getJsonObjectOrNull(response)).rejects.toThrow('The body of the provided Response object has already been used. Every request must respond with a new Response object.')];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when response body can be json-parsed as an object', function () {
+        it('returns the parsed response body', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response = new Response("{ \"exitResult\": \"exit result\" }");
+                        return [4 /*yield*/, expect(getJsonObjectOrNull(response)).resolves.toStrictEqual({
+                                exitResult: 'exit result'
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('when response body CANNOT be json-parsed as an object', function () {
+        describe.each(getNonObjectBodyCases())('when the body is %s', function (_, body) {
+            it("returns null", function () { return __awaiter(void 0, void 0, void 0, function () {
+                var parsedBody;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, getJsonObjectOrNull(new Response(body))];
+                        case 1:
+                            parsedBody = _a.sent();
+                            expect(parsedBody).toBeNull();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+});
+function getNonObjectBodyCases() {
+    return [
+        ['parseable as number', '1234'],
+        ['parseable as a string', '"json string"'],
+        ['parseable as an empty string', '""'],
+        ['parseable as an array', '[]'],
+        ['parseable as true', 'true'],
+        ['parseable as false', 'false'],
+        ['parseable as null', 'null'],
+        ['an empty string', ''],
+        ['non-json parseable string', 'non-json string'],
+        ['a number', 1234],
+        ['NaN', NaN],
+        ['undefined', undefined],
+        ['a Blob instance', new Blob()],
+        ['a FormData instance', new FormData()],
+        ['a URLSearchParams instance', new URLSearchParams('foo=bar')],
+    ];
+}