@aws-amplify/datastore 5.0.1-api-v6-models.c1977f8.0 → 5.0.1-api-v6-models.891fe0d.0

package/lib-esm/sync/outbox.js

@@ -1,314 +1,161 @@
-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 __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 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
@@ -326,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];
@@ -341,7 +187,6 @@ var MutationEventOutbox = /** @class */ (function () {
         delete record[createdTimestampKey];
         delete record[updatedTimestampKey];
         return record;
-    };
-    return MutationEventOutbox;
-}());
+    }
+}
 export { MutationEventOutbox };

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

@@ -1,77 +1,37 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-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 { resolveServiceErrorStatusCode } from '../utils';
-var connectionTimeout = function (error) {
-    return /^Connection failed: Connection Timeout/.test(error.message);
-};
-var serverError = function (error) { return resolveServiceErrorStatusCode(error) >= 500; };
-export var mutationErrorMap = {
-    BadModel: function () { return false; },
-    BadRecord: function (error) {
-        var message = error.message;
+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' ||
-            resolveServiceErrorStatusCode(error) === 401;
-    },
+    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.
@@ -80,8 +40,9 @@ export var syncErrorMap = {
  * @param observableError an error from ZenObservable subscribe error callback
  */
 function unwrapObservableError(observableError) {
-    var _a;
-    var _b = __read((_a = __read(observableError.errors, 0), observableError).errors, 1), error = _b[0];
+    const { errors: [error], } = ({
+        errors: [],
+    } = observableError);
     return error;
 }
 export function getMutationErrorType(error) {
@@ -100,23 +61,12 @@ export function getSyncErrorType(error) {
  * @param error The underying error to categorize.
  */
 export function mapErrorToType(errorMap, error) {
-    var e_1, _a;
-    var errorTypes = __spreadArray([], __read(Object.keys(errorMap)), false);
-    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';
 }