@aws-amplify/datastore 4.7.6-api-v6-models.b3abc9b.0 → 5.0.0

package/lib-esm/sync/merger.js

@@ -1,9 +1,8 @@
-import { __awaiter, __generator, __read, __spread, __values } from "tslib";
 import { OpType, } from '../types';
 import { getIdentifierValue } from './utils';
 // https://github.com/aws-amplify/amplify-js/blob/datastore-docs/packages/datastore/docs/sync-engine.md#merger
-var ModelMerger = /** @class */ (function () {
-    function ModelMerger(outbox, ownSymbol) {
+class ModelMerger {
+    constructor(outbox, ownSymbol) {
         this.outbox = outbox;
         this.ownSymbol = ownSymbol;
     }
@@ -13,62 +12,30 @@ var ModelMerger = /** @class */ (function () {
      * @param model The model from an outbox mutation.
      * @returns The type of operation (INSERT/UPDATE/DELETE)
      */
-    ModelMerger.prototype.merge = function (storage, model, modelDefinition) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, mutationsForModel, isDelete;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.outbox.getForModel(storage, model, modelDefinition)];
-                    case 1:
-                        mutationsForModel = _c.sent();
-                        isDelete = model._deleted;
-                        if (!(mutationsForModel.length === 0)) return [3 /*break*/, 5];
-                        if (!isDelete) return [3 /*break*/, 3];
-                        result = OpType.DELETE;
-                        return [4 /*yield*/, storage.delete(model, undefined, this.ownSymbol)];
-                    case 2:
-                        _c.sent();
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, storage.save(model, undefined, this.ownSymbol)];
-                    case 4:
-                        _a = __read.apply(void 0, [_c.sent(), 1]), _b = __read(_a[0], 2), result = _b[1];
-                        _c.label = 5;
-                    case 5: return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    ModelMerger.prototype.mergePage = function (storage, modelConstructor, items, modelDefinition) {
-        return __awaiter(this, void 0, void 0, function () {
-            var itemsMap, items_1, items_1_1, item, modelId, page;
-            var e_1, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        itemsMap = new Map();
-                        try {
-                            for (items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
-                                item = items_1_1.value;
-                                modelId = getIdentifierValue(modelDefinition, item);
-                                itemsMap.set(modelId, item);
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        page = __spread(itemsMap.values());
-                        return [4 /*yield*/, storage.batchSave(modelConstructor, page, this.ownSymbol)];
-                    case 1: return [2 /*return*/, _b.sent()];
-                }
-            });
-        });
-    };
-    return ModelMerger;
-}());
+    async merge(storage, model, modelDefinition) {
+        let result;
+        const mutationsForModel = await this.outbox.getForModel(storage, model, modelDefinition);
+        const isDelete = model._deleted;
+        if (mutationsForModel.length === 0) {
+            if (isDelete) {
+                result = OpType.DELETE;
+                await storage.delete(model, undefined, this.ownSymbol);
+            }
+            else {
+                [[, result]] = await storage.save(model, undefined, this.ownSymbol);
+            }
+        }
+        return result;
+    }
+    async mergePage(storage, modelConstructor, items, modelDefinition) {
+        const itemsMap = new Map();
+        for (const item of items) {
+            // merge items by model id. Latest record for a given id remains.
+            const modelId = getIdentifierValue(modelDefinition, item);
+            itemsMap.set(modelId, item);
+        }
+        const page = [...itemsMap.values()];
+        return await storage.batchSave(modelConstructor, page, this.ownSymbol);
+    }
+}
 export { ModelMerger };
-//# sourceMappingURL=merger.js.map

package/lib-esm/sync/outbox.js

@@ -1,243 +1,161 @@
-import { __assign, __awaiter, __generator, __read, __rest } from "tslib";
 import { ModelPredicateCreator } from '../predicates';
 import { QueryOne, } from '../types';
 import { USER, SYNC, valuesEqual } from '../util';
 import { getIdentifierValue, TransformerMutationType } from './utils';
 // TODO: Persist deleted ids
 // https://github.com/aws-amplify/amplify-js/blob/datastore-docs/packages/datastore/docs/sync-engine.md#outbox
-var MutationEventOutbox = /** @class */ (function () {
-    function MutationEventOutbox(schema, MutationEvent, modelInstanceCreator, ownSymbol) {
+class MutationEventOutbox {
+    constructor(schema, MutationEvent, modelInstanceCreator, ownSymbol) {
         this.schema = schema;
         this.MutationEvent = MutationEvent;
         this.modelInstanceCreator = modelInstanceCreator;
         this.ownSymbol = ownSymbol;
     }
-    MutationEventOutbox.prototype.enqueue = function (storage, mutationEvent) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, storage.runExclusive(function (s) { return __awaiter(_this, void 0, void 0, function () {
-                            var mutationEventModelDefinition, predicate, _a, first, incomingMutationType, merged_1, incomingConditionJSON, incomingCondition, merged;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        mutationEventModelDefinition = this.schema.namespaces[SYNC].models['MutationEvent'];
-                                        predicate = ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
-                                            and: [
-                                                { modelId: { eq: mutationEvent.modelId } },
-                                                { id: { ne: this.inProgressMutationEventId } },
-                                            ],
-                                        });
-                                        return [4 /*yield*/, s.query(this.MutationEvent, predicate)];
-                                    case 1:
-                                        _a = __read.apply(void 0, [_b.sent(), 1]), first = _a[0];
-                                        if (!(first === undefined)) return [3 /*break*/, 3];
-                                        return [4 /*yield*/, s.save(mutationEvent, undefined, this.ownSymbol)];
-                                    case 2:
-                                        _b.sent();
-                                        return [2 /*return*/];
-                                    case 3:
-                                        incomingMutationType = mutationEvent.operation;
-                                        if (!(first.operation === TransformerMutationType.CREATE)) return [3 /*break*/, 8];
-                                        if (!(incomingMutationType === TransformerMutationType.DELETE)) return [3 /*break*/, 5];
-                                        return [4 /*yield*/, s.delete(this.MutationEvent, predicate)];
-                                    case 4:
-                                        _b.sent();
-                                        return [3 /*break*/, 7];
-                                    case 5:
-                                        merged_1 = this.mergeUserFields(first, mutationEvent);
-                                        return [4 /*yield*/, s.save(this.MutationEvent.copyOf(first, function (draft) {
-                                                draft.data = merged_1.data;
-                                            }), undefined, this.ownSymbol)];
-                                    case 6:
-                                        _b.sent();
-                                        _b.label = 7;
-                                    case 7: return [3 /*break*/, 12];
-                                    case 8:
-                                        incomingConditionJSON = mutationEvent.condition;
-                                        incomingCondition = JSON.parse(incomingConditionJSON);
-                                        merged = void 0;
-                                        if (!(Object.keys(incomingCondition).length === 0)) return [3 /*break*/, 10];
-                                        merged = this.mergeUserFields(first, mutationEvent);
-                                        // delete all for model
-                                        return [4 /*yield*/, s.delete(this.MutationEvent, predicate)];
-                                    case 9:
-                                        // delete all for model
-                                        _b.sent();
-                                        _b.label = 10;
-                                    case 10:
-                                        merged = merged || mutationEvent;
-                                        // Enqueue new one
-                                        return [4 /*yield*/, s.save(merged, undefined, this.ownSymbol)];
-                                    case 11:
-                                        // Enqueue new one
-                                        _b.sent();
-                                        _b.label = 12;
-                                    case 12: return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+    async enqueue(storage, mutationEvent) {
+        await storage.runExclusive(async (s) => {
+            const mutationEventModelDefinition = this.schema.namespaces[SYNC].models['MutationEvent'];
+            // `id` is the key for the record in the mutationEvent;
+            // `modelId` is the key for the actual record that was mutated
+            const predicate = ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
+                and: [
+                    { modelId: { eq: mutationEvent.modelId } },
+                    { id: { ne: this.inProgressMutationEventId } },
+                ],
             });
-        });
-    };
-    MutationEventOutbox.prototype.dequeue = function (storage, record, recordOp) {
-        return __awaiter(this, void 0, void 0, function () {
-            var head;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.peek(storage)];
-                    case 1:
-                        head = _a.sent();
-                        if (!record) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.syncOutboxVersionsOnDequeue(storage, record, head, recordOp)];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3: return [4 /*yield*/, storage.delete(head)];
-                    case 4:
-                        _a.sent();
-                        this.inProgressMutationEventId = undefined;
-                        return [2 /*return*/, head];
+            // Check if there are any other records with same id
+            const [first] = await s.query(this.MutationEvent, predicate);
+            // No other record with same modelId, so enqueue
+            if (first === undefined) {
+                await s.save(mutationEvent, undefined, this.ownSymbol);
+                return;
+            }
+            // There was an enqueued mutation for the modelId, so continue
+            const { operation: incomingMutationType } = mutationEvent;
+            if (first.operation === TransformerMutationType.CREATE) {
+                if (incomingMutationType === TransformerMutationType.DELETE) {
+                    await s.delete(this.MutationEvent, predicate);
                 }
-            });
+                else {
+                    // first gets updated with the incoming mutation's data, condition intentionally skipped
+                    // we need to merge the fields for a create and update mutation to prevent
+                    // data loss, since update mutations only include changed fields
+                    const merged = this.mergeUserFields(first, mutationEvent);
+                    await s.save(this.MutationEvent.copyOf(first, draft => {
+                        draft.data = merged.data;
+                    }), undefined, this.ownSymbol);
+                }
+            }
+            else {
+                const { condition: incomingConditionJSON } = mutationEvent;
+                const incomingCondition = JSON.parse(incomingConditionJSON);
+                let merged;
+                // If no condition
+                if (Object.keys(incomingCondition).length === 0) {
+                    merged = this.mergeUserFields(first, mutationEvent);
+                    // delete all for model
+                    await s.delete(this.MutationEvent, predicate);
+                }
+                merged = merged || mutationEvent;
+                // Enqueue new one
+                await s.save(merged, undefined, this.ownSymbol);
+            }
         });
-    };
+    }
+    async dequeue(storage, record, recordOp) {
+        const head = await this.peek(storage);
+        if (record) {
+            await this.syncOutboxVersionsOnDequeue(storage, record, head, recordOp);
+        }
+        await storage.delete(head);
+        this.inProgressMutationEventId = undefined;
+        return head;
+    }
     /**
      * Doing a peek() implies that the mutation goes "inProgress"
      *
      * @param storage
      */
-    MutationEventOutbox.prototype.peek = function (storage) {
-        return __awaiter(this, void 0, void 0, function () {
-            var head;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, storage.queryOne(this.MutationEvent, QueryOne.FIRST)];
-                    case 1:
-                        head = _a.sent();
-                        this.inProgressMutationEventId = head ? head.id : undefined;
-                        return [2 /*return*/, head];
-                }
-            });
-        });
-    };
-    MutationEventOutbox.prototype.getForModel = function (storage, model, userModelDefinition) {
-        return __awaiter(this, void 0, void 0, function () {
-            var mutationEventModelDefinition, modelId, mutationEvents;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        mutationEventModelDefinition = this.schema.namespaces[SYNC].models.MutationEvent;
-                        modelId = getIdentifierValue(userModelDefinition, model);
-                        return [4 /*yield*/, storage.query(this.MutationEvent, ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
-                                and: { modelId: { eq: modelId } },
-                            }))];
-                    case 1:
-                        mutationEvents = _a.sent();
-                        return [2 /*return*/, mutationEvents];
-                }
-            });
-        });
-    };
-    MutationEventOutbox.prototype.getModelIds = function (storage) {
-        return __awaiter(this, void 0, void 0, function () {
-            var mutationEvents, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, storage.query(this.MutationEvent)];
-                    case 1:
-                        mutationEvents = _a.sent();
-                        result = new Set();
-                        mutationEvents.forEach(function (_a) {
-                            var modelId = _a.modelId;
-                            return result.add(modelId);
-                        });
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
+    async peek(storage) {
+        const head = await storage.queryOne(this.MutationEvent, QueryOne.FIRST);
+        this.inProgressMutationEventId = head ? head.id : undefined;
+        return head;
+    }
+    async getForModel(storage, model, userModelDefinition) {
+        const mutationEventModelDefinition = this.schema.namespaces[SYNC].models.MutationEvent;
+        const modelId = getIdentifierValue(userModelDefinition, model);
+        const mutationEvents = await storage.query(this.MutationEvent, ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
+            and: { modelId: { eq: modelId } },
+        }));
+        return mutationEvents;
+    }
+    async getModelIds(storage) {
+        const mutationEvents = await storage.query(this.MutationEvent);
+        const result = new Set();
+        mutationEvents.forEach(({ modelId }) => result.add(modelId));
+        return result;
+    }
     // applies _version from the AppSync mutation response to other items
     // in the mutation queue with the same id
     // see https://github.com/aws-amplify/amplify-js/pull/7354 for more details
-    MutationEventOutbox.prototype.syncOutboxVersionsOnDequeue = function (storage, record, head, recordOp) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _version, _lastChangedAt, _deleted, _incomingData, incomingData, data, __version, __lastChangedAt, __deleted, _outgoingData, outgoingData, mutationEventModelDefinition, userModelDefinition, recordId, predicate, outdatedMutations, reconciledMutations;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (head.operation !== recordOp) {
-                            return [2 /*return*/];
-                        }
-                        _version = record._version, _lastChangedAt = record._lastChangedAt, _deleted = record._deleted, _incomingData = __rest(record, ["_version", "_lastChangedAt", "_deleted"]);
-                        incomingData = this.removeTimestampFields(head.model, _incomingData);
-                        data = JSON.parse(head.data);
-                        if (!data) {
-                            return [2 /*return*/];
-                        }
-                        __version = data._version, __lastChangedAt = data._lastChangedAt, __deleted = data._deleted, _outgoingData = __rest(data, ["_version", "_lastChangedAt", "_deleted"]);
-                        outgoingData = this.removeTimestampFields(head.model, _outgoingData);
-                        // Don't sync the version when the data in the response does not match the data
-                        // in the request, i.e., when there's a handled conflict
-                        //
-                        // NOTE: `incomingData` contains all the fields in the record, and `outgoingData`
-                        // only contains updated fields, resulting in an error when doing a comparison
-                        // of two equal mutations. Fix this, or mitigate otherwise.
-                        if (!valuesEqual(incomingData, outgoingData, true)) {
-                            return [2 /*return*/];
-                        }
-                        mutationEventModelDefinition = this.schema.namespaces[SYNC].models['MutationEvent'];
-                        userModelDefinition = this.schema.namespaces['user'].models[head.model];
-                        recordId = getIdentifierValue(userModelDefinition, record);
-                        predicate = ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
-                            and: [
-                                { modelId: { eq: recordId } },
-                                { id: { ne: this.inProgressMutationEventId } },
-                            ],
-                        });
-                        return [4 /*yield*/, storage.query(this.MutationEvent, predicate)];
-                    case 1:
-                        outdatedMutations = _a.sent();
-                        if (!outdatedMutations.length) {
-                            return [2 /*return*/];
-                        }
-                        reconciledMutations = outdatedMutations.map(function (m) {
-                            var oldData = JSON.parse(m.data);
-                            var newData = __assign(__assign({}, oldData), { _version: _version, _lastChangedAt: _lastChangedAt });
-                            return _this.MutationEvent.copyOf(m, function (draft) {
-                                draft.data = JSON.stringify(newData);
-                            });
-                        });
-                        return [4 /*yield*/, storage.delete(this.MutationEvent, predicate)];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, Promise.all(reconciledMutations.map(function (m) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, storage.save(m, undefined, this.ownSymbol)];
-                                    case 1: return [2 /*return*/, _a.sent()];
-                                }
-                            }); }); }))];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+    async syncOutboxVersionsOnDequeue(storage, record, head, recordOp) {
+        if (head.operation !== recordOp) {
+            return;
+        }
+        const { _version, _lastChangedAt, _deleted, ..._incomingData } = record;
+        const incomingData = this.removeTimestampFields(head.model, _incomingData);
+        const data = JSON.parse(head.data);
+        if (!data) {
+            return;
+        }
+        const { _version: __version, _lastChangedAt: __lastChangedAt, _deleted: __deleted, ..._outgoingData } = data;
+        const outgoingData = this.removeTimestampFields(head.model, _outgoingData);
+        // Don't sync the version when the data in the response does not match the data
+        // in the request, i.e., when there's a handled conflict
+        //
+        // NOTE: `incomingData` contains all the fields in the record, and `outgoingData`
+        // only contains updated fields, resulting in an error when doing a comparison
+        // of two equal mutations. Fix this, or mitigate otherwise.
+        if (!valuesEqual(incomingData, outgoingData, true)) {
+            return;
+        }
+        const mutationEventModelDefinition = this.schema.namespaces[SYNC].models['MutationEvent'];
+        const userModelDefinition = this.schema.namespaces['user'].models[head.model];
+        const recordId = getIdentifierValue(userModelDefinition, record);
+        const predicate = ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
+            and: [
+                { modelId: { eq: recordId } },
+                { id: { ne: this.inProgressMutationEventId } },
+            ],
+        });
+        const outdatedMutations = await storage.query(this.MutationEvent, predicate);
+        if (!outdatedMutations.length) {
+            return;
+        }
+        const reconciledMutations = outdatedMutations.map(m => {
+            const oldData = JSON.parse(m.data);
+            const newData = { ...oldData, _version, _lastChangedAt };
+            return this.MutationEvent.copyOf(m, draft => {
+                draft.data = JSON.stringify(newData);
             });
         });
-    };
-    MutationEventOutbox.prototype.mergeUserFields = function (previous, current) {
-        var _a = JSON.parse(previous.data), _version = _a._version, _lastChangedAt = _a._lastChangedAt, _deleted = _a._deleted, previousData = __rest(_a, ["_version", "_lastChangedAt", "_deleted"]);
-        var _b = JSON.parse(current.data), __version = _b._version, __lastChangedAt = _b._lastChangedAt, __deleted = _b._deleted, currentData = __rest(_b, ["_version", "_lastChangedAt", "_deleted"]);
-        var data = JSON.stringify(__assign(__assign({ _version: _version,
-            _lastChangedAt: _lastChangedAt,
-            _deleted: _deleted }, previousData), currentData));
-        return this.modelInstanceCreator(this.MutationEvent, __assign(__assign({}, current), { data: data }));
-    };
+        await storage.delete(this.MutationEvent, predicate);
+        await Promise.all(reconciledMutations.map(async (m) => await storage.save(m, undefined, this.ownSymbol)));
+    }
+    mergeUserFields(previous, current) {
+        const { _version, _lastChangedAt, _deleted, ...previousData } = JSON.parse(previous.data);
+        const { _version: __version, _lastChangedAt: __lastChangedAt, _deleted: __deleted, ...currentData } = JSON.parse(current.data);
+        const data = JSON.stringify({
+            _version,
+            _lastChangedAt,
+            _deleted,
+            ...previousData,
+            ...currentData,
+        });
+        return this.modelInstanceCreator(this.MutationEvent, {
+            ...current,
+            data,
+        });
+    }
     /*
     if a model is using custom timestamp fields
     the custom field names will be stored in the model attributes
@@ -255,14 +173,13 @@ var MutationEventOutbox = /** @class */ (function () {
     }
     ]
     */
-    MutationEventOutbox.prototype.removeTimestampFields = function (model, record) {
-        var _a, _b;
-        var CREATED_AT_DEFAULT_KEY = 'createdAt';
-        var UPDATED_AT_DEFAULT_KEY = 'updatedAt';
-        var createdTimestampKey = CREATED_AT_DEFAULT_KEY;
-        var updatedTimestampKey = UPDATED_AT_DEFAULT_KEY;
-        var modelAttributes = (_a = this.schema.namespaces[USER].models[model].attributes) === null || _a === void 0 ? void 0 : _a.find(function (attr) { return attr.type === 'model'; });
-        var timestampFieldsMap = (_b = modelAttributes === null || modelAttributes === void 0 ? void 0 : modelAttributes.properties) === null || _b === void 0 ? void 0 : _b.timestamps;
+    removeTimestampFields(model, record) {
+        const CREATED_AT_DEFAULT_KEY = 'createdAt';
+        const UPDATED_AT_DEFAULT_KEY = 'updatedAt';
+        let createdTimestampKey = CREATED_AT_DEFAULT_KEY;
+        let updatedTimestampKey = UPDATED_AT_DEFAULT_KEY;
+        const modelAttributes = this.schema.namespaces[USER].models[model].attributes?.find(attr => attr.type === 'model');
+        const timestampFieldsMap = modelAttributes?.properties?.timestamps;
         if (timestampFieldsMap) {
             createdTimestampKey = timestampFieldsMap[CREATED_AT_DEFAULT_KEY];
             updatedTimestampKey = timestampFieldsMap[UPDATED_AT_DEFAULT_KEY];
@@ -270,8 +187,6 @@ var MutationEventOutbox = /** @class */ (function () {
         delete record[createdTimestampKey];
         delete record[updatedTimestampKey];
         return record;
-    };
-    return MutationEventOutbox;
-}());
+    }
+}
 export { MutationEventOutbox };
-//# sourceMappingURL=outbox.js.map

package/lib-esm/sync/processors/errorMaps.d.ts

@@ -1,5 +1,5 @@
 import { ErrorType } from '../../types';
-export declare type ErrorMap = Partial<{
+export type ErrorMap = Partial<{
     [key in ErrorType]: (error: Error) => boolean;
 }>;
 export declare const mutationErrorMap: ErrorMap;

package/lib-esm/sync/processors/errorMaps.js

@@ -1,43 +1,37 @@
-import { __read, __spread, __values } from "tslib";
-var connectionTimeout = function (error) {
-    return /^Connection failed: Connection Timeout/.test(error.message);
-};
-var serverError = function (error) {
-    return /^Error: Request failed with status code 5\d\d/.test(error.message);
-};
-export var mutationErrorMap = {
-    BadModel: function () { return false; },
-    BadRecord: function (error) {
-        var message = error.message;
+import { resolveServiceErrorStatusCode } from '../utils';
+const connectionTimeout = error => /^Connection failed: Connection Timeout/.test(error.message);
+const serverError = error => resolveServiceErrorStatusCode(error) >= 500;
+export const mutationErrorMap = {
+    BadModel: () => false,
+    BadRecord: error => {
+        const { message } = error;
         return (/^Cannot return \w+ for [\w-_]+ type/.test(message) ||
             /^Variable '.+' has coerced Null value for NonNull type/.test(message)); // newly required field, out of date client
     },
-    ConfigError: function () { return false; },
-    Transient: function (error) { return connectionTimeout(error) || serverError(error); },
-    Unauthorized: function (error) {
-        return error.message === 'Unauthorized' ||
-            /^Request failed with status code 401/.test(error.message);
-    },
+    ConfigError: () => false,
+    Transient: error => connectionTimeout(error) || serverError(error),
+    Unauthorized: error => error.message === 'Unauthorized' ||
+        resolveServiceErrorStatusCode(error) === 401,
 };
-export var subscriptionErrorMap = {
-    BadModel: function () { return false; },
-    BadRecord: function () { return false; },
-    ConfigError: function () { return false; },
-    Transient: function (observableError) {
-        var error = unwrapObservableError(observableError);
+export const subscriptionErrorMap = {
+    BadModel: () => false,
+    BadRecord: () => false,
+    ConfigError: () => false,
+    Transient: observableError => {
+        const error = unwrapObservableError(observableError);
         return connectionTimeout(error) || serverError(error);
     },
-    Unauthorized: function (observableError) {
-        var error = unwrapObservableError(observableError);
+    Unauthorized: observableError => {
+        const error = unwrapObservableError(observableError);
         return /Connection failed.+Unauthorized/.test(error.message);
     },
 };
-export var syncErrorMap = {
-    BadModel: function () { return false; },
-    BadRecord: function (error) { return /^Cannot return \w+ for [\w-_]+ type/.test(error.message); },
-    ConfigError: function () { return false; },
-    Transient: function (error) { return connectionTimeout(error) || serverError(error); },
-    Unauthorized: function (error) { return error.errorType === 'Unauthorized'; },
+export const syncErrorMap = {
+    BadModel: () => false,
+    BadRecord: error => /^Cannot return \w+ for [\w-_]+ type/.test(error.message),
+    ConfigError: () => false,
+    Transient: error => connectionTimeout(error) || serverError(error),
+    Unauthorized: error => error.errorType === 'Unauthorized',
 };
 /**
  * Get the first error reason of an observable.
@@ -46,9 +40,9 @@ export var syncErrorMap = {
  * @param observableError an error from ZenObservable subscribe error callback
  */
 function unwrapObservableError(observableError) {
-    var _a = observableError.error, _b = __read((_a === void 0 ? {
+    const { errors: [error], } = ({
         errors: [],
-    } : _a).errors, 1), error = _b[0];
+    } = observableError);
     return error;
 }
 export function getMutationErrorType(error) {
@@ -67,24 +61,12 @@ export function getSyncErrorType(error) {
  * @param error The underying error to categorize.
  */
 export function mapErrorToType(errorMap, error) {
-    var e_1, _a;
-    var errorTypes = __spread(Object.keys(errorMap));
-    try {
-        for (var errorTypes_1 = __values(errorTypes), errorTypes_1_1 = errorTypes_1.next(); !errorTypes_1_1.done; errorTypes_1_1 = errorTypes_1.next()) {
-            var errorType = errorTypes_1_1.value;
-            var matcher = errorMap[errorType];
-            if (matcher === null || matcher === void 0 ? void 0 : matcher(error)) {
-                return errorType;
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (errorTypes_1_1 && !errorTypes_1_1.done && (_a = errorTypes_1.return)) _a.call(errorTypes_1);
+    const errorTypes = [...Object.keys(errorMap)];
+    for (const errorType of errorTypes) {
+        const matcher = errorMap[errorType];
+        if (matcher?.(error)) {
+            return errorType;
         }
-        finally { if (e_1) throw e_1.error; }
     }
     return 'Unknown';
 }
-//# sourceMappingURL=errorMaps.js.map