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

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

@@ -1,101 +1,15 @@
-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;
-};
-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 { InternalAPI } from '@aws-amplify/api/internals';
 import { Category, DataStoreAction, jitteredBackoff, NonRetryableError, retry, BackgroundProcessManager, } from '@aws-amplify/core/internals/utils';
-import { ConsoleLogger } from '@aws-amplify/core';
 import { Observable } from 'rxjs';
 import { DISCARD, isModelFieldType, isTargetNameAssociation, OpType, ProcessName, } from '../../types';
 import { extractTargetNamesFromSrc, USER, ID } from '../../util';
 import { buildGraphQLOperation, createMutationInstanceFromModelOperation, getModelAuthModes, TransformerMutationType, getTokenForCustomAuth, } from '../utils';
 import { getMutationErrorType } from './errorMaps';
-var MAX_ATTEMPTS = 10;
-var logger = new ConsoleLogger('DataStore');
-var MutationProcessor = /** @class */ (function () {
-    function MutationProcessor(schema, storage, userClasses, outbox, modelInstanceCreator, MutationEvent, amplifyConfig, authModeStrategy, errorHandler, conflictHandler, amplifyContext) {
-        if (amplifyConfig === void 0) { amplifyConfig = {}; }
+import { ConsoleLogger } from '@aws-amplify/core';
+const MAX_ATTEMPTS = 10;
+const logger = new ConsoleLogger('DataStore');
+class MutationProcessor {
+    constructor(schema, storage, userClasses, outbox, modelInstanceCreator, MutationEvent, amplifyConfig = {}, authModeStrategy, errorHandler, conflictHandler, amplifyContext) {
         this.schema = schema;
         this.storage = storage;
         this.userClasses = userClasses;
@@ -114,446 +28,299 @@ var MutationProcessor = /** @class */ (function () {
             this.amplifyContext.InternalAPI || InternalAPI;
         this.generateQueries();
     }
-    MutationProcessor.prototype.generateQueries = function () {
-        var _this = this;
-        Object.values(this.schema.namespaces).forEach(function (namespace) {
+    generateQueries() {
+        Object.values(this.schema.namespaces).forEach(namespace => {
             Object.values(namespace.models)
-                .filter(function (_a) {
-                var syncable = _a.syncable;
-                return syncable;
-            })
-                .forEach(function (model) {
-                var _a = __read(buildGraphQLOperation(namespace, model, 'CREATE'), 1), createMutation = _a[0];
-                var _b = __read(buildGraphQLOperation(namespace, model, 'UPDATE'), 1), updateMutation = _b[0];
-                var _c = __read(buildGraphQLOperation(namespace, model, 'DELETE'), 1), deleteMutation = _c[0];
-                _this.typeQuery.set(model, [
+                .filter(({ syncable }) => syncable)
+                .forEach(model => {
+                const [createMutation] = buildGraphQLOperation(namespace, model, 'CREATE');
+                const [updateMutation] = buildGraphQLOperation(namespace, model, 'UPDATE');
+                const [deleteMutation] = buildGraphQLOperation(namespace, model, 'DELETE');
+                this.typeQuery.set(model, [
                     createMutation,
                     updateMutation,
                     deleteMutation,
                 ]);
             });
         });
-    };
-    MutationProcessor.prototype.isReady = function () {
+    }
+    isReady() {
         return this.observer !== undefined;
-    };
-    MutationProcessor.prototype.start = function () {
-        var _this = this;
+    }
+    start() {
         this.runningProcesses = new BackgroundProcessManager();
-        var observable = new Observable(function (observer) {
-            _this.observer = observer;
+        const observable = new Observable(observer => {
+            this.observer = observer;
             try {
-                _this.resume();
+                this.resume();
             }
             catch (error) {
                 logger.error('mutations processor start error', error);
                 throw error;
             }
-            return _this.runningProcesses.addCleaner(function () { return __awaiter(_this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    // The observer has unsubscribed and/or `stop()` has been called.
-                    this.removeObserver();
-                    this.pause();
-                    return [2 /*return*/];
-                });
-            }); });
-        });
-        return observable;
-    };
-    MutationProcessor.prototype.stop = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.removeObserver();
-                        return [4 /*yield*/, this.runningProcesses.close()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.runningProcesses.open()];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+            return this.runningProcesses.addCleaner(async () => {
+                // The observer has unsubscribed and/or `stop()` has been called.
+                this.removeObserver();
+                this.pause();
             });
         });
-    };
-    MutationProcessor.prototype.removeObserver = function () {
-        var _a, _b;
-        (_b = (_a = this.observer) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+        return observable;
+    }
+    async stop() {
+        this.removeObserver();
+        await this.runningProcesses.close();
+        await this.runningProcesses.open();
+    }
+    removeObserver() {
+        this.observer?.complete?.();
         this.observer = undefined;
-    };
-    MutationProcessor.prototype.resume = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.runningProcesses.isOpen) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.runningProcesses.add(function (onTerminate) { return __awaiter(_this, void 0, void 0, function () {
-                                var head, namespaceName, _loop_1, this_1, _a;
-                                var _this = this;
-                                var _b, _c;
-                                return __generator(this, function (_d) {
-                                    switch (_d.label) {
-                                        case 0:
-                                            if (this.processing ||
-                                                !this.isReady() ||
-                                                !this.runningProcesses.isOpen) {
-                                                return [2 /*return*/];
-                                            }
-                                            this.processing = true;
-                                            namespaceName = USER;
-                                            _loop_1 = function () {
-                                                var model, operation, data, condition, modelConstructor, result, opName, modelDefinition, modelAuthModes, operationAuthModes_1, authModeAttempts_1, authModeRetry_1, error_1, record, hasMore;
-                                                var _e;
-                                                return __generator(this, function (_f) {
-                                                    switch (_f.label) {
-                                                        case 0:
-                                                            model = head.model, operation = head.operation, data = head.data, condition = head.condition;
-                                                            modelConstructor = this_1.userClasses[model];
-                                                            result = undefined;
-                                                            opName = undefined;
-                                                            modelDefinition = undefined;
-                                                            _f.label = 1;
-                                                        case 1:
-                                                            _f.trys.push([1, 4, , 5]);
-                                                            return [4 /*yield*/, getModelAuthModes({
-                                                                    authModeStrategy: this_1.authModeStrategy,
-                                                                    defaultAuthMode: this_1.amplifyConfig.aws_appsync_authenticationType,
-                                                                    modelName: model,
-                                                                    schema: this_1.schema,
-                                                                })];
-                                                        case 2:
-                                                            modelAuthModes = _f.sent();
-                                                            operationAuthModes_1 = modelAuthModes[operation.toUpperCase()];
-                                                            authModeAttempts_1 = 0;
-                                                            authModeRetry_1 = function () { return __awaiter(_this, void 0, void 0, function () {
-                                                                var response, error_2, e_1;
-                                                                return __generator(this, function (_a) {
-                                                                    switch (_a.label) {
-                                                                        case 0:
-                                                                            _a.trys.push([0, 2, , 9]);
-                                                                            logger.debug("Attempting mutation with authMode: ".concat(operationAuthModes_1[authModeAttempts_1]));
-                                                                            return [4 /*yield*/, this.jitteredRetry(namespaceName, model, operation, data, condition, modelConstructor, this.MutationEvent, head, operationAuthModes_1[authModeAttempts_1], onTerminate)];
-                                                                        case 1:
-                                                                            response = _a.sent();
-                                                                            logger.debug("Mutation sent successfully with authMode: ".concat(operationAuthModes_1[authModeAttempts_1]));
-                                                                            return [2 /*return*/, response];
-                                                                        case 2:
-                                                                            error_2 = _a.sent();
-                                                                            authModeAttempts_1++;
-                                                                            if (!(authModeAttempts_1 >= operationAuthModes_1.length)) return [3 /*break*/, 7];
-                                                                            logger.debug("Mutation failed with authMode: ".concat(operationAuthModes_1[authModeAttempts_1 - 1]));
-                                                                            _a.label = 3;
-                                                                        case 3:
-                                                                            _a.trys.push([3, 5, , 6]);
-                                                                            return [4 /*yield*/, this.errorHandler({
-                                                                                    recoverySuggestion: 'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
-                                                                                    localModel: null,
-                                                                                    message: error_2.message,
-                                                                                    model: modelConstructor.name,
-                                                                                    operation: opName,
-                                                                                    errorType: getMutationErrorType(error_2),
-                                                                                    process: ProcessName.sync,
-                                                                                    remoteModel: null,
-                                                                                    cause: error_2,
-                                                                                })];
-                                                                        case 4:
-                                                                            _a.sent();
-                                                                            return [3 /*break*/, 6];
-                                                                        case 5:
-                                                                            e_1 = _a.sent();
-                                                                            logger.error('Mutation error handler failed with:', e_1);
-                                                                            return [3 /*break*/, 6];
-                                                                        case 6: throw error_2;
-                                                                        case 7:
-                                                                            logger.debug("Mutation failed with authMode: ".concat(operationAuthModes_1[authModeAttempts_1 - 1], ". Retrying with authMode: ").concat(operationAuthModes_1[authModeAttempts_1]));
-                                                                            return [4 /*yield*/, authModeRetry_1()];
-                                                                        case 8: return [2 /*return*/, _a.sent()];
-                                                                        case 9: return [2 /*return*/];
-                                                                    }
-                                                                });
-                                                            }); };
-                                                            return [4 /*yield*/, authModeRetry_1()];
-                                                        case 3:
-                                                            _e = __read.apply(void 0, [_f.sent(), 3]), result = _e[0], opName = _e[1], modelDefinition = _e[2];
-                                                            return [3 /*break*/, 5];
-                                                        case 4:
-                                                            error_1 = _f.sent();
-                                                            if (error_1.message === 'Offline' ||
-                                                                error_1.message === 'RetryMutation') {
-                                                                return [2 /*return*/, "continue"];
-                                                            }
-                                                            return [3 /*break*/, 5];
-                                                        case 5:
-                                                            if (!(result === undefined)) return [3 /*break*/, 7];
-                                                            logger.debug('done retrying');
-                                                            return [4 /*yield*/, this_1.storage.runExclusive(function (storage) { return __awaiter(_this, void 0, void 0, function () {
-                                                                    return __generator(this, function (_a) {
-                                                                        switch (_a.label) {
-                                                                            case 0: return [4 /*yield*/, this.outbox.dequeue(storage)];
-                                                                            case 1:
-                                                                                _a.sent();
-                                                                                return [2 /*return*/];
-                                                                        }
-                                                                    });
-                                                                }); })];
-                                                        case 6:
-                                                            _f.sent();
-                                                            return [2 /*return*/, "continue"];
-                                                        case 7:
-                                                            record = result.data[opName];
-                                                            hasMore = false;
-                                                            return [4 /*yield*/, this_1.storage.runExclusive(function (storage) { return __awaiter(_this, void 0, void 0, function () {
-                                                                    return __generator(this, function (_a) {
-                                                                        switch (_a.label) {
-                                                                            case 0: 
-                                                                            // using runExclusive to prevent possible race condition
-                                                                            // when another record gets enqueued between dequeue and peek
-                                                                            return [4 /*yield*/, this.outbox.dequeue(storage, record, operation)];
-                                                                            case 1:
-                                                                                // using runExclusive to prevent possible race condition
-                                                                                // when another record gets enqueued between dequeue and peek
-                                                                                _a.sent();
-                                                                                return [4 /*yield*/, this.outbox.peek(storage)];
-                                                                            case 2:
-                                                                                hasMore = (_a.sent()) !== undefined;
-                                                                                return [2 /*return*/];
-                                                                        }
-                                                                    });
-                                                                }); })];
-                                                        case 8:
-                                                            _f.sent();
-                                                            (_c = (_b = this_1.observer) === null || _b === void 0 ? void 0 : _b.next) === null || _c === void 0 ? void 0 : _c.call(_b, {
-                                                                operation: operation,
-                                                                modelDefinition: modelDefinition,
-                                                                model: record,
-                                                                hasMore: hasMore,
-                                                            });
-                                                            return [2 /*return*/];
-                                                    }
-                                                });
-                                            };
-                                            this_1 = this;
-                                            _d.label = 1;
-                                        case 1:
-                                            _a = this.processing &&
-                                                this.runningProcesses.isOpen;
-                                            if (!_a) return [3 /*break*/, 3];
-                                            return [4 /*yield*/, this.outbox.peek(this.storage)];
-                                        case 2:
-                                            _a = (head = _d.sent()) !== undefined;
-                                            _d.label = 3;
-                                        case 3:
-                                            if (!_a) return [3 /*break*/, 5];
-                                            return [5 /*yield**/, _loop_1()];
-                                        case 4:
-                                            _d.sent();
-                                            return [3 /*break*/, 1];
-                                        case 5:
-                                            // pauses itself
-                                            this.pause();
-                                            return [2 /*return*/];
+    }
+    async resume() {
+        if (this.runningProcesses.isOpen) {
+            await this.runningProcesses.add(async (onTerminate) => {
+                if (this.processing ||
+                    !this.isReady() ||
+                    !this.runningProcesses.isOpen) {
+                    return;
+                }
+                this.processing = true;
+                let head;
+                const namespaceName = USER;
+                // start to drain outbox
+                while (this.processing &&
+                    this.runningProcesses.isOpen &&
+                    (head = await this.outbox.peek(this.storage)) !== undefined) {
+                    const { model, operation, data, condition } = head;
+                    const modelConstructor = this.userClasses[model];
+                    let result = undefined;
+                    let opName = undefined;
+                    let modelDefinition = undefined;
+                    try {
+                        const modelAuthModes = await getModelAuthModes({
+                            authModeStrategy: this.authModeStrategy,
+                            defaultAuthMode: this.amplifyConfig.aws_appsync_authenticationType,
+                            modelName: model,
+                            schema: this.schema,
+                        });
+                        const operationAuthModes = modelAuthModes[operation.toUpperCase()];
+                        let authModeAttempts = 0;
+                        const authModeRetry = async () => {
+                            try {
+                                logger.debug(`Attempting mutation with authMode: ${operationAuthModes[authModeAttempts]}`);
+                                const response = await this.jitteredRetry(namespaceName, model, operation, data, condition, modelConstructor, this.MutationEvent, head, operationAuthModes[authModeAttempts], onTerminate);
+                                logger.debug(`Mutation sent successfully with authMode: ${operationAuthModes[authModeAttempts]}`);
+                                return response;
+                            }
+                            catch (error) {
+                                authModeAttempts++;
+                                if (authModeAttempts >= operationAuthModes.length) {
+                                    logger.debug(`Mutation failed with authMode: ${operationAuthModes[authModeAttempts - 1]}`);
+                                    try {
+                                        await this.errorHandler({
+                                            recoverySuggestion: 'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
+                                            localModel: null,
+                                            message: error.message,
+                                            model: modelConstructor.name,
+                                            operation: opName,
+                                            errorType: getMutationErrorType(error),
+                                            process: ProcessName.sync,
+                                            remoteModel: null,
+                                            cause: error,
+                                        });
                                     }
-                                });
-                            }); }, 'mutation resume loop')];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/];
+                                    catch (e) {
+                                        logger.error('Mutation error handler failed with:', e);
+                                    }
+                                    throw error;
+                                }
+                                logger.debug(`Mutation failed with authMode: ${operationAuthModes[authModeAttempts - 1]}. Retrying with authMode: ${operationAuthModes[authModeAttempts]}`);
+                                return await authModeRetry();
+                            }
+                        };
+                        [result, opName, modelDefinition] = await authModeRetry();
+                    }
+                    catch (error) {
+                        if (error.message === 'Offline' ||
+                            error.message === 'RetryMutation') {
+                            continue;
+                        }
+                    }
+                    if (result === undefined) {
+                        logger.debug('done retrying');
+                        await this.storage.runExclusive(async (storage) => {
+                            await this.outbox.dequeue(storage);
+                        });
+                        continue;
+                    }
+                    const record = result.data[opName];
+                    let hasMore = false;
+                    await this.storage.runExclusive(async (storage) => {
+                        // using runExclusive to prevent possible race condition
+                        // when another record gets enqueued between dequeue and peek
+                        await this.outbox.dequeue(storage, record, operation);
+                        hasMore = (await this.outbox.peek(storage)) !== undefined;
+                    });
+                    this.observer?.next?.({
+                        operation,
+                        modelDefinition,
+                        model: record,
+                        hasMore,
+                    });
                 }
-            });
-        });
-    };
-    MutationProcessor.prototype.jitteredRetry = function (namespaceName, model, operation, data, condition, modelConstructor, MutationEvent, mutationEvent, authMode, onTerminate) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, retry(function (model, operation, data, condition, modelConstructor, MutationEvent, mutationEvent) { return __awaiter(_this, void 0, void 0, function () {
-                            var _a, query, variables, graphQLCondition, opName, modelDefinition, authToken, tryWith, attempt, opType, customUserAgentDetails, result, err_1, _b, error, _c, _d, _e, code, retryWith, err_2, _f, _g, opName_1, query_1, authToken_1, serverData, namespace, updatedMutation;
-                            var _h;
-                            return __generator(this, function (_j) {
-                                switch (_j.label) {
-                                    case 0:
-                                        _a = __read(this.createQueryVariables(namespaceName, model, operation, data, condition), 5), query = _a[0], variables = _a[1], graphQLCondition = _a[2], opName = _a[3], modelDefinition = _a[4];
-                                        return [4 /*yield*/, getTokenForCustomAuth(authMode, this.amplifyConfig)];
-                                    case 1:
-                                        authToken = _j.sent();
-                                        tryWith = {
-                                            query: query,
-                                            variables: variables,
-                                            authMode: authMode,
-                                            authToken: authToken,
-                                        };
-                                        attempt = 0;
-                                        opType = this.opTypeFromTransformerOperation(operation);
-                                        customUserAgentDetails = {
-                                            category: Category.DataStore,
-                                            action: DataStoreAction.GraphQl,
-                                        };
-                                        _j.label = 2;
-                                    case 2:
-                                        _j.trys.push([2, 4, , 17]);
-                                        return [4 /*yield*/, this.amplifyContext.InternalAPI.graphql(tryWith, undefined, customUserAgentDetails)];
-                                    case 3:
-                                        result = (_j.sent());
-                                        // Use `as any` because TypeScript doesn't seem to like passing tuples
-                                        // through generic params.
-                                        return [2 /*return*/, [result, opName, modelDefinition]];
-                                    case 4:
-                                        err_1 = _j.sent();
-                                        if (!(err_1.errors && err_1.errors.length > 0)) return [3 /*break*/, 15];
-                                        _b = __read(err_1.errors, 1), error = _b[0];
-                                        _c = error.originalError, _d = _c === void 0 ? {} : _c, _e = _d.code, code = _e === void 0 ? null : _e;
-                                        if (error.errorType === 'Unauthorized') {
-                                            throw new NonRetryableError('Unauthorized');
-                                        }
-                                        if (error.message === 'Network Error' ||
-                                            code === 'ECONNABORTED' // refers to axios timeout error caused by device's bad network condition
-                                        ) {
-                                            if (!this.processing) {
-                                                throw new NonRetryableError('Offline');
-                                            }
-                                            // TODO: Check errors on different env (react-native or other browsers)
-                                            throw new Error('Network Error');
-                                        }
-                                        if (!(error.errorType === 'ConflictUnhandled')) return [3 /*break*/, 13];
-                                        // TODO: add on ConflictConditionalCheck error query last from server
-                                        attempt++;
-                                        retryWith = void 0;
-                                        if (!(attempt > MAX_ATTEMPTS)) return [3 /*break*/, 5];
-                                        retryWith = DISCARD;
-                                        return [3 /*break*/, 8];
-                                    case 5:
-                                        _j.trys.push([5, 7, , 8]);
-                                        return [4 /*yield*/, this.conflictHandler({
-                                                modelConstructor: modelConstructor,
-                                                localModel: this.modelInstanceCreator(modelConstructor, variables.input),
-                                                remoteModel: this.modelInstanceCreator(modelConstructor, error.data),
-                                                operation: opType,
-                                                attempts: attempt,
-                                            })];
-                                    case 6:
-                                        retryWith = _j.sent();
-                                        return [3 /*break*/, 8];
-                                    case 7:
-                                        err_2 = _j.sent();
-                                        logger.warn('conflict trycatch', err_2);
-                                        return [3 /*break*/, 17];
-                                    case 8:
-                                        if (!(retryWith === DISCARD)) return [3 /*break*/, 11];
-                                        _f = __read(buildGraphQLOperation(this.schema.namespaces[namespaceName], modelDefinition, 'GET'), 1), _g = __read(_f[0], 3), opName_1 = _g[1], query_1 = _g[2];
-                                        return [4 /*yield*/, getTokenForCustomAuth(authMode, this.amplifyConfig)];
-                                    case 9:
-                                        authToken_1 = _j.sent();
-                                        return [4 /*yield*/, this.amplifyContext.InternalAPI.graphql({
-                                                query: query_1,
-                                                variables: { id: variables.input.id },
-                                                authMode: authMode,
-                                                authToken: authToken_1,
-                                            }, undefined, customUserAgentDetails)];
-                                    case 10:
-                                        serverData = _j.sent();
-                                        // onTerminate cancel graphql()
-                                        return [2 /*return*/, [serverData, opName_1, modelDefinition]];
-                                    case 11:
-                                        namespace = this.schema.namespaces[namespaceName];
-                                        updatedMutation = createMutationInstanceFromModelOperation(namespace.relationships, modelDefinition, opType, modelConstructor, retryWith, graphQLCondition, MutationEvent, this.modelInstanceCreator, mutationEvent.id);
-                                        return [4 /*yield*/, this.storage.save(updatedMutation)];
-                                    case 12:
-                                        _j.sent();
-                                        throw new NonRetryableError('RetryMutation');
-                                    case 13:
-                                        try {
-                                            this.errorHandler({
-                                                recoverySuggestion: 'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
-                                                localModel: variables.input,
-                                                message: error.message,
-                                                operation: operation,
-                                                errorType: getMutationErrorType(error),
-                                                errorInfo: error.errorInfo,
-                                                process: ProcessName.mutate,
-                                                cause: error,
-                                                remoteModel: error.data
-                                                    ? this.modelInstanceCreator(modelConstructor, error.data)
-                                                    : null,
-                                            });
-                                        }
-                                        catch (err) {
-                                            logger.warn('Mutation error handler failed with:', err);
-                                        }
-                                        finally {
-                                            // Return empty tuple, dequeues the mutation
-                                            return [2 /*return*/, error.data
-                                                    ? [
-                                                        { data: (_h = {}, _h[opName] = error.data, _h) },
-                                                        opName,
-                                                        modelDefinition,
-                                                    ]
-                                                    : []];
-                                        }
-                                        _j.label = 14;
-                                    case 14: return [3 /*break*/, 16];
-                                    case 15: 
-                                    // Catch-all for client-side errors that don't come back in the `GraphQLError` format.
-                                    // These errors should not be retried.
-                                    throw new NonRetryableError(err_1);
-                                    case 16: return [3 /*break*/, 17];
-                                    case 17:
-                                        if (tryWith) return [3 /*break*/, 2];
-                                        _j.label = 18;
-                                    case 18: return [2 /*return*/];
+                // pauses itself
+                this.pause();
+            }, 'mutation resume loop');
+        }
+    }
+    async jitteredRetry(namespaceName, model, operation, data, condition, modelConstructor, MutationEvent, mutationEvent, authMode, onTerminate) {
+        return await retry(async (model, operation, data, condition, modelConstructor, MutationEvent, mutationEvent) => {
+            const [query, variables, graphQLCondition, opName, modelDefinition] = this.createQueryVariables(namespaceName, model, operation, data, condition);
+            const authToken = await getTokenForCustomAuth(authMode, this.amplifyConfig);
+            const tryWith = {
+                query,
+                variables,
+                authMode,
+                authToken,
+            };
+            let attempt = 0;
+            const opType = this.opTypeFromTransformerOperation(operation);
+            const customUserAgentDetails = {
+                category: Category.DataStore,
+                action: DataStoreAction.GraphQl,
+            };
+            do {
+                try {
+                    const result = (await this.amplifyContext.InternalAPI.graphql(tryWith, undefined, customUserAgentDetails));
+                    // Use `as any` because TypeScript doesn't seem to like passing tuples
+                    // through generic params.
+                    return [result, opName, modelDefinition];
+                }
+                catch (err) {
+                    if (err.errors && err.errors.length > 0) {
+                        const [error] = err.errors;
+                        const { originalError: { code = null } = {} } = error;
+                        if (error.errorType === 'Unauthorized') {
+                            throw new NonRetryableError('Unauthorized');
+                        }
+                        if (error.message === 'Network Error' ||
+                            code === 'ECONNABORTED' // refers to axios timeout error caused by device's bad network condition
+                        ) {
+                            if (!this.processing) {
+                                throw new NonRetryableError('Offline');
+                            }
+                            // TODO: Check errors on different env (react-native or other browsers)
+                            throw new Error('Network Error');
+                        }
+                        if (error.errorType === 'ConflictUnhandled') {
+                            // TODO: add on ConflictConditionalCheck error query last from server
+                            attempt++;
+                            let retryWith;
+                            if (attempt > MAX_ATTEMPTS) {
+                                retryWith = DISCARD;
+                            }
+                            else {
+                                try {
+                                    retryWith = await this.conflictHandler({
+                                        modelConstructor,
+                                        localModel: this.modelInstanceCreator(modelConstructor, variables.input),
+                                        remoteModel: this.modelInstanceCreator(modelConstructor, error.data),
+                                        operation: opType,
+                                        attempts: attempt,
+                                    });
                                 }
-                            });
-                        }); }, [
-                            model,
-                            operation,
-                            data,
-                            condition,
-                            modelConstructor,
-                            MutationEvent,
-                            mutationEvent,
-                        ], safeJitteredBackoff, onTerminate)];
-                    case 1: return [2 /*return*/, _a.sent()];
+                                catch (err) {
+                                    logger.warn('conflict trycatch', err);
+                                    continue;
+                                }
+                            }
+                            if (retryWith === DISCARD) {
+                                // Query latest from server and notify merger
+                                const [[, opName, query]] = buildGraphQLOperation(this.schema.namespaces[namespaceName], modelDefinition, 'GET');
+                                const authToken = await getTokenForCustomAuth(authMode, this.amplifyConfig);
+                                const serverData = await this.amplifyContext.InternalAPI.graphql({
+                                    query,
+                                    variables: { id: variables.input.id },
+                                    authMode,
+                                    authToken,
+                                }, undefined, customUserAgentDetails);
+                                // onTerminate cancel graphql()
+                                return [serverData, opName, modelDefinition];
+                            }
+                            const namespace = this.schema.namespaces[namespaceName];
+                            // convert retry with to tryWith
+                            const updatedMutation = createMutationInstanceFromModelOperation(namespace.relationships, modelDefinition, opType, modelConstructor, retryWith, graphQLCondition, MutationEvent, this.modelInstanceCreator, mutationEvent.id);
+                            await this.storage.save(updatedMutation);
+                            throw new NonRetryableError('RetryMutation');
+                        }
+                        else {
+                            try {
+                                this.errorHandler({
+                                    recoverySuggestion: 'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
+                                    localModel: variables.input,
+                                    message: error.message,
+                                    operation,
+                                    errorType: getMutationErrorType(error),
+                                    errorInfo: error.errorInfo,
+                                    process: ProcessName.mutate,
+                                    cause: error,
+                                    remoteModel: error.data
+                                        ? this.modelInstanceCreator(modelConstructor, error.data)
+                                        : null,
+                                });
+                            }
+                            catch (err) {
+                                logger.warn('Mutation error handler failed with:', err);
+                            }
+                            finally {
+                                // Return empty tuple, dequeues the mutation
+                                return error.data
+                                    ? [
+                                        { data: { [opName]: error.data } },
+                                        opName,
+                                        modelDefinition,
+                                    ]
+                                    : [];
+                            }
+                        }
+                    }
+                    else {
+                        // Catch-all for client-side errors that don't come back in the `GraphQLError` format.
+                        // These errors should not be retried.
+                        throw new NonRetryableError(err);
+                    }
                 }
-            });
-        });
-    };
-    MutationProcessor.prototype.createQueryVariables = function (namespaceName, model, operation, data, condition) {
-        var e_2, _a, e_3, _b, e_4, _c;
-        var _d, _e;
-        var modelDefinition = this.schema.namespaces[namespaceName].models[model];
-        var primaryKey = this.schema.namespaces[namespaceName].keys[model].primaryKey;
-        var auth = (_d = modelDefinition.attributes) === null || _d === void 0 ? void 0 : _d.find(function (a) { return a.type === 'auth'; });
-        var ownerFields = ((_e = auth === null || auth === void 0 ? void 0 : auth.properties) === null || _e === void 0 ? void 0 : _e.rules.map(function (rule) { return rule.ownerField; }).filter(function (f) { return f; })) || ['owner'];
-        var queriesTuples = this.typeQuery.get(modelDefinition);
-        var _f = __read(queriesTuples.find(function (_a) {
-            var _b = __read(_a, 1), transformerMutationType = _b[0];
-            return transformerMutationType === operation;
-        }), 3), opName = _f[1], query = _f[2];
-        var _g = JSON.parse(data), _version = _g._version, parsedData = __rest(_g, ["_version"]);
+            } while (tryWith);
+        }, [
+            model,
+            operation,
+            data,
+            condition,
+            modelConstructor,
+            MutationEvent,
+            mutationEvent,
+        ], safeJitteredBackoff, onTerminate);
+    }
+    createQueryVariables(namespaceName, model, operation, data, condition) {
+        const modelDefinition = this.schema.namespaces[namespaceName].models[model];
+        const { primaryKey } = this.schema.namespaces[namespaceName].keys[model];
+        const auth = modelDefinition.attributes?.find(a => a.type === 'auth');
+        const ownerFields = auth?.properties?.rules
+            .map(rule => rule.ownerField)
+            .filter(f => f) || ['owner'];
+        const queriesTuples = this.typeQuery.get(modelDefinition);
+        const [, opName, query] = queriesTuples.find(([transformerMutationType]) => transformerMutationType === operation);
+        const { _version, ...parsedData } = JSON.parse(data);
         // include all the fields that comprise a custom PK if one is specified
-        var deleteInput = {};
+        const deleteInput = {};
         if (primaryKey && primaryKey.length) {
-            try {
-                for (var primaryKey_1 = __values(primaryKey), primaryKey_1_1 = primaryKey_1.next(); !primaryKey_1_1.done; primaryKey_1_1 = primaryKey_1.next()) {
-                    var pkField = primaryKey_1_1.value;
-                    deleteInput[pkField] = parsedData[pkField];
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (primaryKey_1_1 && !primaryKey_1_1.done && (_a = primaryKey_1.return)) _a.call(primaryKey_1);
-                }
-                finally { if (e_2) throw e_2.error; }
+            for (const pkField of primaryKey) {
+                deleteInput[pkField] = parsedData[pkField];
             }
         }
         else {
             deleteInput[ID] = parsedData.id;
         }
-        var mutationInput;
+        let mutationInput;
         if (operation === TransformerMutationType.DELETE) {
             // For DELETE mutations, only the key(s) are included in the input
             mutationInput = deleteInput;
@@ -561,75 +328,61 @@ var MutationProcessor = /** @class */ (function () {
         else {
             // Otherwise, we construct the mutation input with the following logic
             mutationInput = {};
-            var modelFields = Object.values(modelDefinition.fields);
-            try {
-                for (var modelFields_1 = __values(modelFields), modelFields_1_1 = modelFields_1.next(); !modelFields_1_1.done; modelFields_1_1 = modelFields_1.next()) {
-                    var _h = modelFields_1_1.value, name_1 = _h.name, type = _h.type, association = _h.association, isReadOnly = _h.isReadOnly;
-                    // omit readonly fields. cloud storage doesn't need them and won't take them!
-                    if (isReadOnly) {
-                        continue;
-                    }
-                    // omit owner fields if it's `null`. cloud storage doesn't allow it.
-                    if (ownerFields.includes(name_1) && parsedData[name_1] === null) {
-                        continue;
-                    }
-                    // model fields should be stripped out from the input
-                    if (isModelFieldType(type)) {
-                        // except for belongs to relations - we need to replace them with the correct foreign key(s)
-                        if (isTargetNameAssociation(association) &&
-                            association.connectionType === 'BELONGS_TO') {
-                            var targetNames = extractTargetNamesFromSrc(association);
-                            if (targetNames) {
-                                try {
-                                    // instead of including the connected model itself, we add its key(s) to the mutation input
-                                    for (var targetNames_1 = (e_4 = void 0, __values(targetNames)), targetNames_1_1 = targetNames_1.next(); !targetNames_1_1.done; targetNames_1_1 = targetNames_1.next()) {
-                                        var targetName = targetNames_1_1.value;
-                                        mutationInput[targetName] = parsedData[targetName];
-                                    }
-                                }
-                                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                                finally {
-                                    try {
-                                        if (targetNames_1_1 && !targetNames_1_1.done && (_c = targetNames_1.return)) _c.call(targetNames_1);
-                                    }
-                                    finally { if (e_4) throw e_4.error; }
-                                }
+            const modelFields = Object.values(modelDefinition.fields);
+            for (const { name, type, association, isReadOnly } of modelFields) {
+                // omit readonly fields. cloud storage doesn't need them and won't take them!
+                if (isReadOnly) {
+                    continue;
+                }
+                // omit owner fields if it's `null`. cloud storage doesn't allow it.
+                if (ownerFields.includes(name) && parsedData[name] === null) {
+                    continue;
+                }
+                // model fields should be stripped out from the input
+                if (isModelFieldType(type)) {
+                    // except for belongs to relations - we need to replace them with the correct foreign key(s)
+                    if (isTargetNameAssociation(association) &&
+                        association.connectionType === 'BELONGS_TO') {
+                        const targetNames = extractTargetNamesFromSrc(association);
+                        if (targetNames) {
+                            // instead of including the connected model itself, we add its key(s) to the mutation input
+                            for (const targetName of targetNames) {
+                                mutationInput[targetName] = parsedData[targetName];
                             }
                         }
-                        continue;
-                    }
-                    // scalar fields / non-model types
-                    if (operation === TransformerMutationType.UPDATE) {
-                        if (!parsedData.hasOwnProperty(name_1)) {
-                            // for update mutations - strip out a field if it's unchanged
-                            continue;
-                        }
                     }
-                    // all other fields are added to the input object
-                    mutationInput[name_1] = parsedData[name_1];
+                    continue;
                 }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (modelFields_1_1 && !modelFields_1_1.done && (_b = modelFields_1.return)) _b.call(modelFields_1);
+                // scalar fields / non-model types
+                if (operation === TransformerMutationType.UPDATE) {
+                    if (!parsedData.hasOwnProperty(name)) {
+                        // for update mutations - strip out a field if it's unchanged
+                        continue;
+                    }
                 }
-                finally { if (e_3) throw e_3.error; }
+                // all other fields are added to the input object
+                mutationInput[name] = parsedData[name];
             }
         }
         // Build mutation variables input object
-        var input = __assign(__assign({}, mutationInput), { _version: _version });
-        var graphQLCondition = JSON.parse(condition);
-        var variables = __assign({ input: input }, (operation === TransformerMutationType.CREATE
-            ? {}
-            : {
-                condition: Object.keys(graphQLCondition).length > 0
-                    ? graphQLCondition
-                    : null,
-            }));
+        const input = {
+            ...mutationInput,
+            _version,
+        };
+        const graphQLCondition = JSON.parse(condition);
+        const variables = {
+            input,
+            ...(operation === TransformerMutationType.CREATE
+                ? {}
+                : {
+                    condition: Object.keys(graphQLCondition).length > 0
+                        ? graphQLCondition
+                        : null,
+                }),
+        };
         return [query, variables, graphQLCondition, opName, modelDefinition];
-    };
-    MutationProcessor.prototype.opTypeFromTransformerOperation = function (operation) {
+    }
+    opTypeFromTransformerOperation(operation) {
         switch (operation) {
             case TransformerMutationType.CREATE:
                 return OpType.INSERT;
@@ -640,18 +393,17 @@ var MutationProcessor = /** @class */ (function () {
             case TransformerMutationType.GET: // Intentionally blank
                 break;
             default:
-                throw new Error("Invalid operation ".concat(operation));
+                throw new Error(`Invalid operation ${operation}`);
         }
         // because it makes TS happy ...
         return undefined;
-    };
-    MutationProcessor.prototype.pause = function () {
+    }
+    pause() {
         this.processing = false;
-    };
-    return MutationProcessor;
-}());
-var MAX_RETRY_DELAY_MS = 5 * 60 * 1000;
-var originalJitteredBackoff = jitteredBackoff(MAX_RETRY_DELAY_MS);
+    }
+}
+const MAX_RETRY_DELAY_MS = 5 * 60 * 1000;
+const originalJitteredBackoff = jitteredBackoff(MAX_RETRY_DELAY_MS);
 /**
  * @private
  * Internal use of Amplify only.
@@ -667,8 +419,8 @@ var originalJitteredBackoff = jitteredBackoff(MAX_RETRY_DELAY_MS);
  * @param error tested to see if `.message` is 'Network Error'
  * @returns number | false :
  */
-export var safeJitteredBackoff = function (attempt, _args, error) {
-    var attemptResult = originalJitteredBackoff(attempt);
+export const safeJitteredBackoff = (attempt, _args, error) => {
+    const attemptResult = originalJitteredBackoff(attempt);
     // If this is the last attempt and it is a network error, we retry indefinitively every 5 minutes
     if (attemptResult === false &&
         (error || {}).message === 'Network Error') {