@merchi/sdk 1.42.18 → 1.42.19

package/dist/request.js

@@ -13,6 +13,53 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -42,10 +89,11 @@ var ApiError = /** @class */ (function (_super) {
         var message = resolveApiErrorMessage(err);
         /* istanbul ignore next */
         _this = _super.call(this, message) || this;
-        _this.statusCode = err.statusCode;
-        _this.errorCode = getErrorFromCode(err.errorCode);
+        var fields = err && typeof err === 'object' ? err : {};
+        _this.statusCode = fields.statusCode;
+        _this.errorCode = getErrorFromCode(fields.errorCode);
         _this.errorMessage = message;
-        _this.details = err.details;
+        _this.details = fields.details;
         _this.name = 'ApiError';
         _this.original = err;
         return _this;
@@ -78,34 +126,63 @@ function ensureVersionInUri(baseUrl) {
     };
 }
 export function backendFetch(baseUrl, resource, options) {
-    var e_1, _a;
-    var _b = ensureVersionInUri(baseUrl), cleanBaseUrl = _b.baseUrl, apiVersion = _b.version;
-    // Remove leading slash from resource if it exists to prevent double slashes
-    var cleanResource = resource.startsWith('/') ? resource.slice(1) : resource;
-    var url = new URL(cleanBaseUrl + apiVersion + '/' + cleanResource);
-    if (options && options.query) {
-        try {
-            for (var _c = __values(options.query), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var entry = _d.value;
-                url.searchParams.append(entry[0], entry[1]);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var _c, cleanBaseUrl, apiVersion, cleanResource, url, query, query_1, query_1_1, entry, method, error_1, networkError;
+        var e_1, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _c = ensureVersionInUri(baseUrl), cleanBaseUrl = _c.baseUrl, apiVersion = _c.version;
+                    cleanResource = resource.startsWith('/') ? resource.slice(1) : resource;
+                    url = new URL(cleanBaseUrl + apiVersion + '/' + cleanResource);
+                    query = options === null || options === void 0 ? void 0 : options.query;
+                    if (query) {
+                        try {
+                            for (query_1 = __values(query), query_1_1 = query_1.next(); !query_1_1.done; query_1_1 = query_1.next()) {
+                                entry = query_1_1.value;
+                                url.searchParams.append(entry[0], entry[1]);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (query_1_1 && !query_1_1.done && (_d = query_1.return)) _d.call(query_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                    method = ((options === null || options === void 0 ? void 0 : options.method) || 'GET').toUpperCase();
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 3, , 5]);
+                    return [4 /*yield*/, fetch(url.toString(), options)];
+                case 2: return [2 /*return*/, _e.sent()];
+                case 3:
+                    error_1 = _e.sent();
+                    networkError = error_1 instanceof TypeError ||
+                        (error_1 && typeof error_1 === 'object' && error_1.name === 'NetworkError');
+                    if (!networkError || !['GET', 'HEAD'].includes(method) || ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+                        throw error_1;
+                    }
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 250); })];
+                case 4:
+                    _e.sent();
+                    if ((_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.aborted)
+                        throw error_1;
+                    return [2 /*return*/, fetch(url.toString(), options)];
+                case 5: return [2 /*return*/];
             }
-            finally { if (e_1) throw e_1.error; }
-        }
-    }
-    return fetch(url.toString(), options);
+        });
+    });
 }
 export function apiFetch(baseUrl, resource, options, expectEmptyResponse) {
     return backendFetch(baseUrl, resource, options).then(function (response) {
         if (response.status < 200 || response.status > 299) {
-            return response.json().then(function (json) {
-                var err = new ApiError(json);
-                return Promise.reject(err);
+            return response.json().catch(function () { return null; }).then(function (json) {
+                var fields = json && typeof json === 'object' ? json : {};
+                throw new ApiError(__assign(__assign({}, fields), { statusCode: response.status, message: typeof json === 'string' && json ? json : fields.message ||
+                        "Request failed (HTTP ".concat(response.status, ")") }));
             });
         }
         else {

package/dist/request.test.js

@@ -1,4 +1,51 @@
-import { apiFetch, ApiError } from './request.js';
+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 };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { apiFetch, backendFetch, ApiError } from './request.js';
 import { ErrorType } from './constants/errors.js';
 import { setup, mockFetch } from './test_util.js';
 setup();
@@ -17,11 +64,11 @@ test('can pass through data from server with override url', function () {
 });
 test('404 creates ApiError', function () {
     mockFetch(false, { 'statusCode': 404, 'errorCode': ErrorType.RESOURCE_NOT_FOUND }, 404);
-    apiFetch('https://api.merchi.co/', '/test').catch(function (e) {
+    return apiFetch('https://api.merchi.co/', '/test').catch(function (e) {
         expect(e.statusCode).toBe(404);
         expect(e.name).toBe('ApiError');
         expect(e.errorCode).toBe(ErrorType.RESOURCE_NOT_FOUND);
-        expect(e.errorMessage).toBe('No error message');
+        expect(e.errorMessage).toBe('Request failed (HTTP 404)');
     });
 });
 test('will get default errorCode', function () {
@@ -87,3 +134,196 @@ test('ApiError leaves details undefined when the server omits them', function ()
         expect(e.details).toBeUndefined();
     });
 });
+test.each([null, undefined])('ApiError accepts an empty response body (%s)', function (value) {
+    var error = new ApiError(value);
+    expect(error.message).toBe('No error message');
+    expect(error.statusCode).toBeUndefined();
+});
+test.each(['GET', 'HEAD', undefined])('retries one lost %s response', function (method) { return __awaiter(void 0, void 0, void 0, function () {
+    var response, fetch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                response = { status: 200, json: function () { return Promise.resolve({ cart: { id: 42 } }); } };
+                fetch = jest.fn().mockRejectedValueOnce(new TypeError('Load failed')).mockResolvedValue(response);
+                global.fetch = fetch;
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/carts/42/', { method: method })).resolves.toEqual({ cart: { id: 42 } })];
+            case 1:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledTimes(2);
+                expect(fetch.mock.calls[0]).toEqual(fetch.mock.calls[1]);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('retries Safari NetworkError reads', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var error, fetch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                error = Object.assign(new Error('A network error occurred.'), { name: 'NetworkError' });
+                fetch = jest.fn().mockRejectedValueOnce(error).mockResolvedValue({ status: 200, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, ({})];
+                    }); }); } });
+                global.fetch = fetch;
+                return [4 /*yield*/, apiFetch('https://api.merchi.co/', '/carts/42/')];
+            case 1:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledTimes(2);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('read retry is bounded and preserves the final failure', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var error, fetch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                error = new TypeError('Failed to fetch');
+                fetch = jest.fn().mockRejectedValue(error);
+                global.fetch = fetch;
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toBe(error)];
+            case 1:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledTimes(2);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test.each(['POST', 'PATCH', 'PUT', 'DELETE'])('never retries %s after a lost response', function (method) { return __awaiter(void 0, void 0, void 0, function () {
+    var error, fetch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                error = new TypeError('Load failed');
+                fetch = jest.fn().mockRejectedValue(error);
+                global.fetch = fetch;
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/carts/', { method: method })).rejects.toBe(error)];
+            case 1:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledTimes(1);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('does not retry aborts or unrelated exceptions', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b, error, fetch_1, e_1_1;
+    var e_1, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _d.trys.push([0, 5, 6, 7]);
+                _a = __values([Object.assign(new Error('Cancelled'), { name: 'AbortError' }), new Error('unexpected failure')]), _b = _a.next();
+                _d.label = 1;
+            case 1:
+                if (!!_b.done) return [3 /*break*/, 4];
+                error = _b.value;
+                fetch_1 = jest.fn().mockRejectedValue(error);
+                global.fetch = fetch_1;
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toBe(error)];
+            case 2:
+                _d.sent();
+                expect(fetch_1).toHaveBeenCalledTimes(1);
+                _d.label = 3;
+            case 3:
+                _b = _a.next();
+                return [3 /*break*/, 1];
+            case 4: return [3 /*break*/, 7];
+            case 5:
+                e_1_1 = _d.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 7];
+            case 6:
+                try {
+                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 7: return [2 /*return*/];
+        }
+    });
+}); });
+test('does not retry a network error after its signal is aborted', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var controller, error;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                controller = new AbortController();
+                error = new TypeError('Load failed');
+                global.fetch = jest.fn().mockImplementation(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                    controller.abort();
+                    throw error;
+                }); }); });
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/carts/42/', { signal: controller.signal })).rejects.toBe(error)];
+            case 1:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledTimes(1);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('cancelling during the retry delay prevents a second request', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var controller, error, pending;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                controller = new AbortController();
+                error = new TypeError('Load failed');
+                global.fetch = jest.fn().mockRejectedValue(error);
+                pending = apiFetch('https://api.merchi.co/', '/carts/42/', { signal: controller.signal });
+                return [4 /*yield*/, Promise.resolve()];
+            case 1:
+                _a.sent();
+                controller.abort();
+                return [4 /*yield*/, expect(pending).rejects.toBe(error)];
+            case 2:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledTimes(1);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('query parameters survive retries without duplication', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var fetch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                fetch = jest.fn().mockRejectedValueOnce(new TypeError('Load failed')).mockResolvedValue({ status: 200 });
+                global.fetch = fetch;
+                return [4 /*yield*/, backendFetch('https://api.merchi.co/v6/', '/carts/42/', { query: [['cart_token', 'test-token']], method: 'GET' })];
+            case 1:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledWith('https://api.merchi.co/v6/carts/42/?cart_token=test-token', { method: 'GET', query: [['cart_token', 'test-token']] });
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('non-JSON gateway failures preserve their HTTP status without exposing HTML', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var fetch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                fetch = jest.fn().mockResolvedValue({ status: 502, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        throw new SyntaxError('private gateway HTML');
+                    }); }); } });
+                global.fetch = fetch;
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toMatchObject({ name: 'ApiError', statusCode: 502, message: 'Request failed (HTTP 502)' })];
+            case 1:
+                _a.sent();
+                expect(fetch).toHaveBeenCalledTimes(1);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test.each([null, 'Service unavailable', { statusCode: 200, message: 'Service unavailable' }])('HTTP status is authoritative for error body %s', function (body) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                mockFetch(false, body, 503);
+                return [4 /*yield*/, expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toMatchObject({ name: 'ApiError', statusCode: 503 })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merchi/sdk",
-  "version": "1.42.18",
+  "version": "1.42.19",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/request.test.ts

@@ -1,4 +1,4 @@
-import { apiFetch, ApiError } from './request.js';
+import { apiFetch, backendFetch, ApiError } from './request.js';
 import { ErrorType } from './constants/errors.js';
 import { setup, mockFetch } from './test_util.js';
 
@@ -21,11 +21,11 @@ test('can pass through data from server with override url', () => {
 
 test('404 creates ApiError', () => {
   mockFetch(false, {'statusCode': 404, 'errorCode': ErrorType.RESOURCE_NOT_FOUND}, 404);
-  apiFetch('https://api.merchi.co/', '/test').catch(e => {
+  return apiFetch('https://api.merchi.co/', '/test').catch(e => {
     expect(e.statusCode).toBe(404);
     expect(e.name).toBe('ApiError');
     expect(e.errorCode).toBe(ErrorType.RESOURCE_NOT_FOUND);
-    expect(e.errorMessage).toBe('No error message');
+    expect(e.errorMessage).toBe('Request failed (HTTP 404)');
   });
 });
 
@@ -98,3 +98,89 @@ test('ApiError leaves details undefined when the server omits them', () => {
     expect(e.details).toBeUndefined();
   });
 });
+
+test.each([null, undefined])('ApiError accepts an empty response body (%s)', value => {
+  const error = new ApiError(value);
+  expect(error.message).toBe('No error message');
+  expect(error.statusCode).toBeUndefined();
+});
+
+test.each(['GET', 'HEAD', undefined])('retries one lost %s response', async method => {
+  const response = { status: 200, json: () => Promise.resolve({ cart: { id: 42 } }) };
+  const fetch = jest.fn().mockRejectedValueOnce(new TypeError('Load failed')).mockResolvedValue(response);
+  (global as any).fetch = fetch;
+  await expect(apiFetch('https://api.merchi.co/', '/carts/42/', { method })).resolves.toEqual({ cart: { id: 42 } });
+  expect(fetch).toHaveBeenCalledTimes(2);
+  expect(fetch.mock.calls[0]).toEqual(fetch.mock.calls[1]);
+});
+
+test('retries Safari NetworkError reads', async () => {
+  const error = Object.assign(new Error('A network error occurred.'), { name: 'NetworkError' });
+  const fetch = jest.fn().mockRejectedValueOnce(error).mockResolvedValue({ status: 200, json: async () => ({}) });
+  (global as any).fetch = fetch;
+  await apiFetch('https://api.merchi.co/', '/carts/42/');
+  expect(fetch).toHaveBeenCalledTimes(2);
+});
+
+test('read retry is bounded and preserves the final failure', async () => {
+  const error = new TypeError('Failed to fetch');
+  const fetch = jest.fn().mockRejectedValue(error);
+  (global as any).fetch = fetch;
+  await expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toBe(error);
+  expect(fetch).toHaveBeenCalledTimes(2);
+});
+
+test.each(['POST', 'PATCH', 'PUT', 'DELETE'])('never retries %s after a lost response', async method => {
+  const error = new TypeError('Load failed');
+  const fetch = jest.fn().mockRejectedValue(error);
+  (global as any).fetch = fetch;
+  await expect(apiFetch('https://api.merchi.co/', '/carts/', { method })).rejects.toBe(error);
+  expect(fetch).toHaveBeenCalledTimes(1);
+});
+
+test('does not retry aborts or unrelated exceptions', async () => {
+  for (const error of [Object.assign(new Error('Cancelled'), { name: 'AbortError' }), new Error('unexpected failure')]) {
+    const fetch = jest.fn().mockRejectedValue(error);
+    (global as any).fetch = fetch;
+    await expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toBe(error);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  }
+});
+
+test('does not retry a network error after its signal is aborted', async () => {
+  const controller = new AbortController();
+  const error = new TypeError('Load failed');
+  (global as any).fetch = jest.fn().mockImplementation(async () => { controller.abort(); throw error; });
+  await expect(apiFetch('https://api.merchi.co/', '/carts/42/', { signal: controller.signal })).rejects.toBe(error);
+  expect(fetch).toHaveBeenCalledTimes(1);
+});
+
+test('cancelling during the retry delay prevents a second request', async () => {
+  const controller = new AbortController();
+  const error = new TypeError('Load failed');
+  (global as any).fetch = jest.fn().mockRejectedValue(error);
+  const pending = apiFetch('https://api.merchi.co/', '/carts/42/', { signal: controller.signal });
+  await Promise.resolve();
+  controller.abort();
+  await expect(pending).rejects.toBe(error);
+  expect(fetch).toHaveBeenCalledTimes(1);
+});
+
+test('query parameters survive retries without duplication', async () => {
+  const fetch = jest.fn().mockRejectedValueOnce(new TypeError('Load failed')).mockResolvedValue({ status: 200 });
+  (global as any).fetch = fetch;
+  await backendFetch('https://api.merchi.co/v6/', '/carts/42/', { query: [['cart_token', 'test-token']], method: 'GET' });
+  expect(fetch).toHaveBeenCalledWith('https://api.merchi.co/v6/carts/42/?cart_token=test-token', { method: 'GET', query: [['cart_token', 'test-token']] });
+});
+
+test('non-JSON gateway failures preserve their HTTP status without exposing HTML', async () => {
+  const fetch = jest.fn().mockResolvedValue({ status: 502, json: async () => { throw new SyntaxError('private gateway HTML'); } });
+  (global as any).fetch = fetch;
+  await expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toMatchObject({ name: 'ApiError', statusCode: 502, message: 'Request failed (HTTP 502)' });
+  expect(fetch).toHaveBeenCalledTimes(1);
+});
+
+test.each([null, 'Service unavailable', { statusCode: 200, message: 'Service unavailable' }])('HTTP status is authoritative for error body %s', async body => {
+  mockFetch(false, body, 503);
+  await expect(apiFetch('https://api.merchi.co/', '/carts/42/')).rejects.toMatchObject({ name: 'ApiError', statusCode: 503 });
+});

package/src/request.ts

@@ -65,10 +65,11 @@ export class ApiError extends Error {
     const message = resolveApiErrorMessage(err);
     /* istanbul ignore next */
     super(message);
-    this.statusCode = err.statusCode;
-    this.errorCode = getErrorFromCode(err.errorCode);
+    const fields = err && typeof err === 'object' ? err : {};
+    this.statusCode = fields.statusCode;
+    this.errorCode = getErrorFromCode(fields.errorCode);
     this.errorMessage = message;
-    this.details = err.details;
+    this.details = fields.details;
     this.name = 'ApiError';
     this.original = err;
   }
@@ -108,17 +109,32 @@ function ensureVersionInUri(baseUrl: string): UriComponents {
   };
 }
 
-export function backendFetch(baseUrl: string, resource: string, options?: RequestOptions) {
+export async function backendFetch(baseUrl: string, resource: string, options?: RequestOptions) {
   const { baseUrl: cleanBaseUrl, version: apiVersion } = ensureVersionInUri(baseUrl);
   // Remove leading slash from resource if it exists to prevent double slashes
   const cleanResource = resource.startsWith('/') ? resource.slice(1) : resource;
   const url = new URL(cleanBaseUrl + apiVersion + '/' + cleanResource);
-  if (options && options.query) {
-    for (const entry of options.query) {
+  const query = options?.query;
+  if (query) {
+    for (const entry of query) {
       url.searchParams.append(entry[0], entry[1]);
     }
   }
-  return fetch(url.toString(), options);
+  const method = (options?.method || 'GET').toUpperCase();
+  try {
+    return await fetch(url.toString(), options);
+  } catch (error) {
+    // Only reads are safe to repeat when the browser loses a response. A cart
+    // creation or payment may already have succeeded on the server.
+    const networkError = error instanceof TypeError ||
+      (error && typeof error === 'object' && (error as Error).name === 'NetworkError');
+    if (!networkError || !['GET', 'HEAD'].includes(method) || options?.signal?.aborted) {
+      throw error;
+    }
+    await new Promise(resolve => setTimeout(resolve, 250));
+    if (options?.signal?.aborted) throw error;
+    return fetch(url.toString(), options);
+  }
 }
 
 export function apiFetch(
@@ -130,9 +146,14 @@ export function apiFetch(
   return backendFetch(baseUrl, resource, options as RequestInit | undefined).then(
     function (response) {
       if (response.status < 200 || response.status > 299) {
-        return response.json().then(function (json) {
-          const err = new ApiError(json);
-          return Promise.reject(err);
+        return response.json().catch(() => null).then(function (json) {
+          const fields = json && typeof json === 'object' ? json : {};
+          throw new ApiError({
+            ...fields,
+            statusCode: response.status,
+            message: typeof json === 'string' && json ? json : fields.message ||
+              `Request failed (HTTP ${response.status})`,
+          });
         });
       } else {
         return expectEmptyResponse ? '' : response.json();