@aws-amplify/datastore 4.7.22 → 4.7.26

package/lib-esm/sync/index.js

@@ -1,4 +1,4 @@
-import { __awaiter, __generator, __read, __spread, __values } from "tslib";
+import { __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { browserOrNode, ConsoleLogger as Logger, BackgroundProcessManager, Hub, } from '@aws-amplify/core';
@@ -32,8 +32,8 @@ export var ControlMessage;
 })(ControlMessage || (ControlMessage = {}));
 var SyncEngine = /** @class */ (function () {
     function SyncEngine(schema, namespaceResolver, modelClasses, userModelClasses, storage, modelInstanceCreator, conflictHandler, errorHandler, syncPredicates, amplifyConfig, authModeStrategy, amplifyContext, connectivityMonitor) {
-        var _this = this;
         if (amplifyConfig === void 0) { amplifyConfig = {}; }
+        var _this = this;
         this.schema = schema;
         this.namespaceResolver = namespaceResolver;
         this.modelClasses = modelClasses;
@@ -86,107 +86,143 @@ var SyncEngine = /** @class */ (function () {
                             return [2 /*return*/];
                         case 3:
                             startPromise = new Promise(function (doneStarting, failedStarting) {
-                                _this.datastoreConnectivity.status().subscribe(function (_a) {
-                                    var online = _a.online;
-                                    return __awaiter(_this, void 0, void 0, function () {
-                                        var _this = this;
-                                        return __generator(this, function (_b) {
-                                            return [2 /*return*/, this.runningProcesses.isOpen &&
-                                                    this.runningProcesses.add(function (onTerminate) { return __awaiter(_this, void 0, void 0, function () {
-                                                        var ctlSubsObservable_1, dataSubsObservable, err_2, error_1;
-                                                        var _a;
-                                                        var _this = this;
-                                                        return __generator(this, function (_b) {
-                                                            switch (_b.label) {
-                                                                case 0:
-                                                                    if (!(online && !this.online)) return [3 /*break*/, 10];
-                                                                    this.online = online;
-                                                                    observer.next({
-                                                                        type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
-                                                                        data: {
-                                                                            active: this.online,
-                                                                        },
-                                                                    });
-                                                                    dataSubsObservable = void 0;
-                                                                    if (!isNode) return [3 /*break*/, 1];
-                                                                    logger.warn('Realtime disabled when in a server-side environment');
-                                                                    return [3 /*break*/, 6];
-                                                                case 1:
-                                                                    this.stopDisruptionListener =
-                                                                        this.startDisruptionListener();
-                                                                    //#region GraphQL Subscriptions
-                                                                    _a = __read(this.subscriptionsProcessor.start(), 2), ctlSubsObservable_1 = _a[0], dataSubsObservable = _a[1];
-                                                                    _b.label = 2;
-                                                                case 2:
-                                                                    _b.trys.push([2, 4, , 5]);
-                                                                    return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                                                            onTerminate.then(reject);
-                                                                            var ctlSubsSubscription = ctlSubsObservable_1.subscribe({
-                                                                                next: function (msg) {
-                                                                                    if (msg === CONTROL_MSG.CONNECTED) {
-                                                                                        resolve();
-                                                                                    }
-                                                                                },
-                                                                                error: function (err) {
-                                                                                    reject(err);
-                                                                                    var handleDisconnect = _this.disconnectionHandler();
-                                                                                    handleDisconnect(err);
-                                                                                },
-                                                                            });
-                                                                            subscriptions.push(ctlSubsSubscription);
-                                                                        })];
-                                                                case 3:
-                                                                    _b.sent();
-                                                                    return [3 /*break*/, 5];
-                                                                case 4:
-                                                                    err_2 = _b.sent();
-                                                                    observer.error(err_2);
-                                                                    failedStarting();
-                                                                    return [2 /*return*/];
-                                                                case 5:
-                                                                    logger.log('Realtime ready');
-                                                                    observer.next({
-                                                                        type: ControlMessage.SYNC_ENGINE_SUBSCRIPTIONS_ESTABLISHED,
-                                                                    });
-                                                                    _b.label = 6;
-                                                                case 6:
-                                                                    _b.trys.push([6, 8, , 9]);
-                                                                    return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                                                            var syncQuerySubscription = _this.syncQueriesObservable().subscribe({
-                                                                                next: function (message) {
-                                                                                    var type = message.type;
-                                                                                    if (type ===
-                                                                                        ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY) {
-                                                                                        resolve();
-                                                                                    }
-                                                                                    observer.next(message);
-                                                                                },
-                                                                                complete: function () {
+                                _this.datastoreConnectivity.status().subscribe(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                    var _this = this;
+                                    var online = _b.online;
+                                    return __generator(this, function (_c) {
+                                        return [2 /*return*/, this.runningProcesses.isOpen &&
+                                                this.runningProcesses.add(function (onTerminate) { return __awaiter(_this, void 0, void 0, function () {
+                                                    var ctlSubsObservable_1, dataSubsObservable, err_2, error_1;
+                                                    var _a;
+                                                    var _this = this;
+                                                    return __generator(this, function (_b) {
+                                                        switch (_b.label) {
+                                                            case 0:
+                                                                if (!(online && !this.online)) return [3 /*break*/, 10];
+                                                                this.online = online;
+                                                                observer.next({
+                                                                    type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
+                                                                    data: {
+                                                                        active: this.online,
+                                                                    },
+                                                                });
+                                                                dataSubsObservable = void 0;
+                                                                if (!isNode) return [3 /*break*/, 1];
+                                                                logger.warn('Realtime disabled when in a server-side environment');
+                                                                return [3 /*break*/, 6];
+                                                            case 1:
+                                                                this.stopDisruptionListener =
+                                                                    this.startDisruptionListener();
+                                                                //#region GraphQL Subscriptions
+                                                                _a = __read(this.subscriptionsProcessor.start(), 2), ctlSubsObservable_1 = _a[0], dataSubsObservable = _a[1];
+                                                                _b.label = 2;
+                                                            case 2:
+                                                                _b.trys.push([2, 4, , 5]);
+                                                                return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                                                        onTerminate.then(reject);
+                                                                        var ctlSubsSubscription = ctlSubsObservable_1.subscribe({
+                                                                            next: function (msg) {
+                                                                                if (msg === CONTROL_MSG.CONNECTED) {
                                                                                     resolve();
-                                                                                },
-                                                                                error: function (error) {
-                                                                                    reject(error);
-                                                                                },
-                                                                            });
-                                                                            if (syncQuerySubscription) {
-                                                                                subscriptions.push(syncQuerySubscription);
+                                                                                }
+                                                                            },
+                                                                            error: function (err) {
+                                                                                reject(err);
+                                                                                var handleDisconnect = _this.disconnectionHandler();
+                                                                                handleDisconnect(err);
+                                                                            },
+                                                                        });
+                                                                        subscriptions.push(ctlSubsSubscription);
+                                                                    })];
+                                                            case 3:
+                                                                _b.sent();
+                                                                return [3 /*break*/, 5];
+                                                            case 4:
+                                                                err_2 = _b.sent();
+                                                                observer.error(err_2);
+                                                                failedStarting();
+                                                                return [2 /*return*/];
+                                                            case 5:
+                                                                logger.log('Realtime ready');
+                                                                observer.next({
+                                                                    type: ControlMessage.SYNC_ENGINE_SUBSCRIPTIONS_ESTABLISHED,
+                                                                });
+                                                                _b.label = 6;
+                                                            case 6:
+                                                                _b.trys.push([6, 8, , 9]);
+                                                                return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                                                        var syncQuerySubscription = _this.syncQueriesObservable().subscribe({
+                                                                            next: function (message) {
+                                                                                var type = message.type;
+                                                                                if (type ===
+                                                                                    ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY) {
+                                                                                    resolve();
+                                                                                }
+                                                                                observer.next(message);
+                                                                            },
+                                                                            complete: function () {
+                                                                                resolve();
+                                                                            },
+                                                                            error: function (error) {
+                                                                                reject(error);
+                                                                            },
+                                                                        });
+                                                                        if (syncQuerySubscription) {
+                                                                            subscriptions.push(syncQuerySubscription);
+                                                                        }
+                                                                    })];
+                                                            case 7:
+                                                                _b.sent();
+                                                                return [3 /*break*/, 9];
+                                                            case 8:
+                                                                error_1 = _b.sent();
+                                                                observer.error(error_1);
+                                                                failedStarting();
+                                                                return [2 /*return*/];
+                                                            case 9:
+                                                                //#endregion
+                                                                //#region process mutations (outbox)
+                                                                subscriptions.push(this.mutationsProcessor
+                                                                    .start()
+                                                                    .subscribe(function (_a) {
+                                                                    var modelDefinition = _a.modelDefinition, item = _a.model, hasMore = _a.hasMore;
+                                                                    return _this.runningProcesses.add(function () { return __awaiter(_this, void 0, void 0, function () {
+                                                                        var modelConstructor, model;
+                                                                        var _this = this;
+                                                                        return __generator(this, function (_a) {
+                                                                            switch (_a.label) {
+                                                                                case 0:
+                                                                                    modelConstructor = this.userModelClasses[modelDefinition.name];
+                                                                                    model = this.modelInstanceCreator(modelConstructor, item);
+                                                                                    return [4 /*yield*/, this.storage.runExclusive(function (storage) {
+                                                                                            return _this.modelMerger.merge(storage, model, modelDefinition);
+                                                                                        })];
+                                                                                case 1:
+                                                                                    _a.sent();
+                                                                                    observer.next({
+                                                                                        type: ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED,
+                                                                                        data: {
+                                                                                            model: modelConstructor,
+                                                                                            element: model,
+                                                                                        },
+                                                                                    });
+                                                                                    observer.next({
+                                                                                        type: ControlMessage.SYNC_ENGINE_OUTBOX_STATUS,
+                                                                                        data: {
+                                                                                            isEmpty: !hasMore,
+                                                                                        },
+                                                                                    });
+                                                                                    return [2 /*return*/];
                                                                             }
-                                                                        })];
-                                                                case 7:
-                                                                    _b.sent();
-                                                                    return [3 /*break*/, 9];
-                                                                case 8:
-                                                                    error_1 = _b.sent();
-                                                                    observer.error(error_1);
-                                                                    failedStarting();
-                                                                    return [2 /*return*/];
-                                                                case 9:
-                                                                    //#endregion
-                                                                    //#region process mutations (outbox)
-                                                                    subscriptions.push(this.mutationsProcessor
-                                                                        .start()
-                                                                        .subscribe(function (_a) {
-                                                                        var modelDefinition = _a.modelDefinition, item = _a.model, hasMore = _a.hasMore;
+                                                                        });
+                                                                    }); }, 'mutation processor event');
+                                                                }));
+                                                                //#endregion
+                                                                //#region Merge subscriptions buffer
+                                                                // TODO: extract to function
+                                                                if (!isNode) {
+                                                                    subscriptions.push(dataSubsObservable.subscribe(function (_a) {
+                                                                        var _b = __read(_a, 3), _transformerMutationType = _b[0], modelDefinition = _b[1], item = _b[2];
                                                                         return _this.runningProcesses.add(function () { return __awaiter(_this, void 0, void 0, function () {
                                                                             var modelConstructor, model;
                                                                             var _this = this;
@@ -200,72 +236,34 @@ var SyncEngine = /** @class */ (function () {
                                                                                             })];
                                                                                     case 1:
                                                                                         _a.sent();
-                                                                                        observer.next({
-                                                                                            type: ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED,
-                                                                                            data: {
-                                                                                                model: modelConstructor,
-                                                                                                element: model,
-                                                                                            },
-                                                                                        });
-                                                                                        observer.next({
-                                                                                            type: ControlMessage.SYNC_ENGINE_OUTBOX_STATUS,
-                                                                                            data: {
-                                                                                                isEmpty: !hasMore,
-                                                                                            },
-                                                                                        });
                                                                                         return [2 /*return*/];
                                                                                 }
                                                                             });
-                                                                        }); }, 'mutation processor event');
+                                                                        }); }, 'subscription dataSubsObservable event');
                                                                     }));
-                                                                    //#endregion
-                                                                    //#region Merge subscriptions buffer
-                                                                    // TODO: extract to function
-                                                                    if (!isNode) {
-                                                                        subscriptions.push(dataSubsObservable.subscribe(function (_a) {
-                                                                            var _b = __read(_a, 3), _transformerMutationType = _b[0], modelDefinition = _b[1], item = _b[2];
-                                                                            return _this.runningProcesses.add(function () { return __awaiter(_this, void 0, void 0, function () {
-                                                                                var modelConstructor, model;
-                                                                                var _this = this;
-                                                                                return __generator(this, function (_a) {
-                                                                                    switch (_a.label) {
-                                                                                        case 0:
-                                                                                            modelConstructor = this.userModelClasses[modelDefinition.name];
-                                                                                            model = this.modelInstanceCreator(modelConstructor, item);
-                                                                                            return [4 /*yield*/, this.storage.runExclusive(function (storage) {
-                                                                                                    return _this.modelMerger.merge(storage, model, modelDefinition);
-                                                                                                })];
-                                                                                        case 1:
-                                                                                            _a.sent();
-                                                                                            return [2 /*return*/];
-                                                                                    }
-                                                                                });
-                                                                            }); }, 'subscription dataSubsObservable event');
-                                                                        }));
-                                                                    }
-                                                                    return [3 /*break*/, 11];
-                                                                case 10:
-                                                                    if (!online) {
-                                                                        this.online = online;
-                                                                        observer.next({
-                                                                            type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
-                                                                            data: {
-                                                                                active: this.online,
-                                                                            },
-                                                                        });
-                                                                        subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
-                                                                        subscriptions = [];
-                                                                    }
-                                                                    _b.label = 11;
-                                                                case 11:
-                                                                    doneStarting();
-                                                                    return [2 /*return*/];
-                                                            }
-                                                        });
-                                                    }); }, 'datastore connectivity event')];
-                                        });
+                                                                }
+                                                                return [3 /*break*/, 11];
+                                                            case 10:
+                                                                if (!online) {
+                                                                    this.online = online;
+                                                                    observer.next({
+                                                                        type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
+                                                                        data: {
+                                                                            active: this.online,
+                                                                        },
+                                                                    });
+                                                                    subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
+                                                                    subscriptions = [];
+                                                                }
+                                                                _b.label = 11;
+                                                            case 11:
+                                                                doneStarting();
+                                                                return [2 /*return*/];
+                                                        }
+                                                    });
+                                                }); }, 'datastore connectivity event')];
                                     });
-                                });
+                                }); });
                             });
                             this.storage
                                 .observe(null, null, ownSymbol)
@@ -275,51 +273,49 @@ var SyncEngine = /** @class */ (function () {
                                 return modelDefinition.syncable === true;
                             })
                                 .subscribe({
-                                next: function (_a) {
-                                    var opType = _a.opType, model = _a.model, element = _a.element, condition = _a.condition;
-                                    return __awaiter(_this, void 0, void 0, function () {
-                                        var _this = this;
-                                        return __generator(this, function (_b) {
-                                            return [2 /*return*/, this.runningProcesses.add(function () { return __awaiter(_this, void 0, void 0, function () {
-                                                    var namespace, MutationEventConstructor, modelDefinition, graphQLCondition, mutationEvent;
-                                                    return __generator(this, function (_a) {
-                                                        switch (_a.label) {
-                                                            case 0:
-                                                                namespace = this.schema.namespaces[this.namespaceResolver(model)];
-                                                                MutationEventConstructor = this.modelClasses['MutationEvent'];
-                                                                modelDefinition = this.getModelDefinition(model);
-                                                                graphQLCondition = predicateToGraphQLCondition(condition, modelDefinition);
-                                                                mutationEvent = createMutationInstanceFromModelOperation(namespace.relationships, this.getModelDefinition(model), opType, model, element, graphQLCondition, MutationEventConstructor, this.modelInstanceCreator);
-                                                                return [4 /*yield*/, this.outbox.enqueue(this.storage, mutationEvent)];
-                                                            case 1:
-                                                                _a.sent();
-                                                                observer.next({
-                                                                    type: ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_ENQUEUED,
-                                                                    data: {
-                                                                        model: model,
-                                                                        element: element,
-                                                                    },
-                                                                });
-                                                                observer.next({
-                                                                    type: ControlMessage.SYNC_ENGINE_OUTBOX_STATUS,
-                                                                    data: {
-                                                                        isEmpty: false,
-                                                                    },
-                                                                });
-                                                                return [4 /*yield*/, startPromise];
-                                                            case 2:
-                                                                _a.sent();
-                                                                // Set by the this.datastoreConnectivity.status().subscribe() loop
-                                                                if (this.online) {
-                                                                    this.mutationsProcessor.resume();
-                                                                }
-                                                                return [2 /*return*/];
-                                                        }
-                                                    });
-                                                }); }, 'storage event')];
-                                        });
+                                next: function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                    var _this = this;
+                                    var opType = _b.opType, model = _b.model, element = _b.element, condition = _b.condition;
+                                    return __generator(this, function (_c) {
+                                        return [2 /*return*/, this.runningProcesses.add(function () { return __awaiter(_this, void 0, void 0, function () {
+                                                var namespace, MutationEventConstructor, modelDefinition, graphQLCondition, mutationEvent;
+                                                return __generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            namespace = this.schema.namespaces[this.namespaceResolver(model)];
+                                                            MutationEventConstructor = this.modelClasses['MutationEvent'];
+                                                            modelDefinition = this.getModelDefinition(model);
+                                                            graphQLCondition = predicateToGraphQLCondition(condition, modelDefinition);
+                                                            mutationEvent = createMutationInstanceFromModelOperation(namespace.relationships, this.getModelDefinition(model), opType, model, element, graphQLCondition, MutationEventConstructor, this.modelInstanceCreator);
+                                                            return [4 /*yield*/, this.outbox.enqueue(this.storage, mutationEvent)];
+                                                        case 1:
+                                                            _a.sent();
+                                                            observer.next({
+                                                                type: ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_ENQUEUED,
+                                                                data: {
+                                                                    model: model,
+                                                                    element: element,
+                                                                },
+                                                            });
+                                                            observer.next({
+                                                                type: ControlMessage.SYNC_ENGINE_OUTBOX_STATUS,
+                                                                data: {
+                                                                    isEmpty: false,
+                                                                },
+                                                            });
+                                                            return [4 /*yield*/, startPromise];
+                                                        case 2:
+                                                            _a.sent();
+                                                            // Set by the this.datastoreConnectivity.status().subscribe() loop
+                                                            if (this.online) {
+                                                                this.mutationsProcessor.resume();
+                                                            }
+                                                            return [2 /*return*/];
+                                                    }
+                                                });
+                                            }); }, 'storage event')];
                                     });
-                                },
+                                }); },
                             });
                             observer.next({
                                 type: ControlMessage.SYNC_ENGINE_STORAGE_SUBSCRIBED,
@@ -388,13 +384,13 @@ var SyncEngine = /** @class */ (function () {
                                 terminated = false;
                                 _loop_1 = function () {
                                     var count, modelLastSync, paginatingModels, lastFullSyncStartedAt, syncInterval, start, syncDuration, lastStartedAt, msNextFullSync;
-                                    return __generator(this, function (_a) {
-                                        switch (_a.label) {
+                                    return __generator(this, function (_b) {
+                                        switch (_b.label) {
                                             case 0:
                                                 count = new WeakMap();
                                                 return [4 /*yield*/, this_1.getModelsMetadataWithNextFullSync(Date.now())];
                                             case 1:
-                                                modelLastSync = _a.sent();
+                                                modelLastSync = _b.sent();
                                                 paginatingModels = new Set(modelLastSync.keys());
                                                 return [4 /*yield*/, new Promise(function (resolve, reject) {
                                                         if (!_this.runningProcesses.isOpen)
@@ -403,158 +399,157 @@ var SyncEngine = /** @class */ (function () {
                                                         syncQueriesSubscription = _this.syncQueriesProcessor
                                                             .start(modelLastSync)
                                                             .subscribe({
-                                                            next: function (_a) {
-                                                                var namespace = _a.namespace, modelDefinition = _a.modelDefinition, items = _a.items, done = _a.done, startedAt = _a.startedAt, isFullSync = _a.isFullSync;
-                                                                return __awaiter(_this, void 0, void 0, function () {
-                                                                    var modelConstructor, modelName, modelMetadata_1, lastFullSync, fullSyncInterval, counts;
-                                                                    var _this = this;
-                                                                    return __generator(this, function (_b) {
-                                                                        switch (_b.label) {
-                                                                            case 0:
-                                                                                modelConstructor = this.userModelClasses[modelDefinition.name];
-                                                                                if (!count.has(modelConstructor)) {
-                                                                                    count.set(modelConstructor, {
-                                                                                        new: 0,
-                                                                                        updated: 0,
-                                                                                        deleted: 0,
-                                                                                    });
-                                                                                    start = getNow();
-                                                                                    lastStartedAt =
-                                                                                        lastStartedAt === undefined
-                                                                                            ? startedAt
-                                                                                            : Math.max(lastStartedAt, startedAt);
-                                                                                }
-                                                                                /**
-                                                                                 * If there are mutations in the outbox for a given id, those need to be
-                                                                                 * merged individually. Otherwise, we can merge them in batches.
-                                                                                 */
-                                                                                return [4 /*yield*/, this.storage.runExclusive(function (storage) { return __awaiter(_this, void 0, void 0, function () {
-                                                                                        var idsInOutbox, oneByOne, page, opTypeCount, oneByOne_1, oneByOne_1_1, item, opType, e_1_1, _a, _b, _c, counts;
-                                                                                        var e_1, _d;
-                                                                                        return __generator(this, function (_e) {
-                                                                                            switch (_e.label) {
-                                                                                                case 0: return [4 /*yield*/, this.outbox.getModelIds(storage)];
-                                                                                                case 1:
-                                                                                                    idsInOutbox = _e.sent();
-                                                                                                    oneByOne = [];
-                                                                                                    page = items.filter(function (item) {
-                                                                                                        var itemId = getIdentifierValue(modelDefinition, item);
-                                                                                                        if (!idsInOutbox.has(itemId)) {
-                                                                                                            return true;
-                                                                                                        }
-                                                                                                        oneByOne.push(item);
-                                                                                                        return false;
-                                                                                                    });
-                                                                                                    opTypeCount = [];
-                                                                                                    _e.label = 2;
-                                                                                                case 2:
-                                                                                                    _e.trys.push([2, 7, 8, 9]);
-                                                                                                    oneByOne_1 = __values(oneByOne), oneByOne_1_1 = oneByOne_1.next();
-                                                                                                    _e.label = 3;
-                                                                                                case 3:
-                                                                                                    if (!!oneByOne_1_1.done) return [3 /*break*/, 6];
-                                                                                                    item = oneByOne_1_1.value;
-                                                                                                    return [4 /*yield*/, this.modelMerger.merge(storage, item, modelDefinition)];
-                                                                                                case 4:
-                                                                                                    opType = _e.sent();
-                                                                                                    if (opType !== undefined) {
-                                                                                                        opTypeCount.push([item, opType]);
+                                                            next: function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                                                var modelConstructor, modelName, modelMetadata_1, lastFullSync, fullSyncInterval, counts;
+                                                                var _this = this;
+                                                                var namespace = _b.namespace, modelDefinition = _b.modelDefinition, items = _b.items, done = _b.done, startedAt = _b.startedAt, isFullSync = _b.isFullSync;
+                                                                return __generator(this, function (_c) {
+                                                                    switch (_c.label) {
+                                                                        case 0:
+                                                                            modelConstructor = this.userModelClasses[modelDefinition.name];
+                                                                            if (!count.has(modelConstructor)) {
+                                                                                count.set(modelConstructor, {
+                                                                                    new: 0,
+                                                                                    updated: 0,
+                                                                                    deleted: 0,
+                                                                                });
+                                                                                start = getNow();
+                                                                                lastStartedAt =
+                                                                                    lastStartedAt === undefined
+                                                                                        ? startedAt
+                                                                                        : Math.max(lastStartedAt, startedAt);
+                                                                            }
+                                                                            /**
+                                                                             * If there are mutations in the outbox for a given id, those need to be
+                                                                             * merged individually. Otherwise, we can merge them in batches.
+                                                                             */
+                                                                            return [4 /*yield*/, this.storage.runExclusive(function (storage) { return __awaiter(_this, void 0, void 0, function () {
+                                                                                    var idsInOutbox, oneByOne, page, opTypeCount, oneByOne_1, oneByOne_1_1, item, opType, e_1_1, _a, _b, _c, _d, counts;
+                                                                                    var e_1, _e;
+                                                                                    return __generator(this, function (_f) {
+                                                                                        switch (_f.label) {
+                                                                                            case 0: return [4 /*yield*/, this.outbox.getModelIds(storage)];
+                                                                                            case 1:
+                                                                                                idsInOutbox = _f.sent();
+                                                                                                oneByOne = [];
+                                                                                                page = items.filter(function (item) {
+                                                                                                    var itemId = getIdentifierValue(modelDefinition, item);
+                                                                                                    if (!idsInOutbox.has(itemId)) {
+                                                                                                        return true;
                                                                                                     }
-                                                                                                    _e.label = 5;
-                                                                                                case 5:
-                                                                                                    oneByOne_1_1 = oneByOne_1.next();
-                                                                                                    return [3 /*break*/, 3];
-                                                                                                case 6: return [3 /*break*/, 9];
-                                                                                                case 7:
-                                                                                                    e_1_1 = _e.sent();
-                                                                                                    e_1 = { error: e_1_1 };
-                                                                                                    return [3 /*break*/, 9];
-                                                                                                case 8:
-                                                                                                    try {
-                                                                                                        if (oneByOne_1_1 && !oneByOne_1_1.done && (_d = oneByOne_1.return)) _d.call(oneByOne_1);
+                                                                                                    oneByOne.push(item);
+                                                                                                    return false;
+                                                                                                });
+                                                                                                opTypeCount = [];
+                                                                                                _f.label = 2;
+                                                                                            case 2:
+                                                                                                _f.trys.push([2, 7, 8, 9]);
+                                                                                                oneByOne_1 = __values(oneByOne), oneByOne_1_1 = oneByOne_1.next();
+                                                                                                _f.label = 3;
+                                                                                            case 3:
+                                                                                                if (!!oneByOne_1_1.done) return [3 /*break*/, 6];
+                                                                                                item = oneByOne_1_1.value;
+                                                                                                return [4 /*yield*/, this.modelMerger.merge(storage, item, modelDefinition)];
+                                                                                            case 4:
+                                                                                                opType = _f.sent();
+                                                                                                if (opType !== undefined) {
+                                                                                                    opTypeCount.push([item, opType]);
+                                                                                                }
+                                                                                                _f.label = 5;
+                                                                                            case 5:
+                                                                                                oneByOne_1_1 = oneByOne_1.next();
+                                                                                                return [3 /*break*/, 3];
+                                                                                            case 6: return [3 /*break*/, 9];
+                                                                                            case 7:
+                                                                                                e_1_1 = _f.sent();
+                                                                                                e_1 = { error: e_1_1 };
+                                                                                                return [3 /*break*/, 9];
+                                                                                            case 8:
+                                                                                                try {
+                                                                                                    if (oneByOne_1_1 && !oneByOne_1_1.done && (_e = oneByOne_1.return)) _e.call(oneByOne_1);
+                                                                                                }
+                                                                                                finally { if (e_1) throw e_1.error; }
+                                                                                                return [7 /*endfinally*/];
+                                                                                            case 9:
+                                                                                                _b = (_a = opTypeCount.push).apply;
+                                                                                                _c = [opTypeCount];
+                                                                                                _d = [[]];
+                                                                                                return [4 /*yield*/, this.modelMerger.mergePage(storage, modelConstructor, page, modelDefinition)];
+                                                                                            case 10:
+                                                                                                _b.apply(_a, _c.concat([__spreadArray.apply(void 0, _d.concat([__read.apply(void 0, [(_f.sent())]), false]))]));
+                                                                                                counts = count.get(modelConstructor);
+                                                                                                opTypeCount.forEach(function (_a) {
+                                                                                                    var _b = __read(_a, 2), opType = _b[1];
+                                                                                                    switch (opType) {
+                                                                                                        case OpType.INSERT:
+                                                                                                            counts.new++;
+                                                                                                            break;
+                                                                                                        case OpType.UPDATE:
+                                                                                                            counts.updated++;
+                                                                                                            break;
+                                                                                                        case OpType.DELETE:
+                                                                                                            counts.deleted++;
+                                                                                                            break;
+                                                                                                        default:
+                                                                                                            throw new Error("Invalid opType ".concat(opType));
                                                                                                     }
-                                                                                                    finally { if (e_1) throw e_1.error; }
-                                                                                                    return [7 /*endfinally*/];
-                                                                                                case 9:
-                                                                                                    _b = (_a = opTypeCount.push).apply;
-                                                                                                    _c = [opTypeCount];
-                                                                                                    return [4 /*yield*/, this.modelMerger.mergePage(storage, modelConstructor, page, modelDefinition)];
-                                                                                                case 10:
-                                                                                                    _b.apply(_a, _c.concat([__spread.apply(void 0, [(_e.sent())])]));
-                                                                                                    counts = count.get(modelConstructor);
-                                                                                                    opTypeCount.forEach(function (_a) {
-                                                                                                        var _b = __read(_a, 2), opType = _b[1];
-                                                                                                        switch (opType) {
-                                                                                                            case OpType.INSERT:
-                                                                                                                counts.new++;
-                                                                                                                break;
-                                                                                                            case OpType.UPDATE:
-                                                                                                                counts.updated++;
-                                                                                                                break;
-                                                                                                            case OpType.DELETE:
-                                                                                                                counts.deleted++;
-                                                                                                                break;
-                                                                                                            default:
-                                                                                                                throw new Error("Invalid opType " + opType);
-                                                                                                        }
-                                                                                                    });
-                                                                                                    return [2 /*return*/];
-                                                                                            }
-                                                                                        });
-                                                                                    }); })];
-                                                                            case 1:
-                                                                                /**
-                                                                                 * If there are mutations in the outbox for a given id, those need to be
-                                                                                 * merged individually. Otherwise, we can merge them in batches.
-                                                                                 */
-                                                                                _b.sent();
-                                                                                if (!done) return [3 /*break*/, 4];
-                                                                                modelName = modelDefinition.name;
-                                                                                return [4 /*yield*/, this.getModelMetadata(namespace, modelName)];
-                                                                            case 2:
-                                                                                modelMetadata_1 = _b.sent();
-                                                                                lastFullSync = modelMetadata_1.lastFullSync, fullSyncInterval = modelMetadata_1.fullSyncInterval;
-                                                                                syncInterval = fullSyncInterval;
-                                                                                lastFullSyncStartedAt =
-                                                                                    lastFullSyncStartedAt === undefined
-                                                                                        ? lastFullSync
-                                                                                        : Math.max(lastFullSyncStartedAt, isFullSync ? startedAt : lastFullSync);
-                                                                                modelMetadata_1 = this.modelClasses
-                                                                                    .ModelMetadata.copyOf(modelMetadata_1, function (draft) {
-                                                                                    draft.lastSync = startedAt;
-                                                                                    draft.lastFullSync = isFullSync
-                                                                                        ? startedAt
-                                                                                        : modelMetadata_1.lastFullSync;
-                                                                                });
-                                                                                return [4 /*yield*/, this.storage.save(modelMetadata_1, undefined, ownSymbol)];
-                                                                            case 3:
-                                                                                _b.sent();
-                                                                                counts = count.get(modelConstructor);
-                                                                                this.modelSyncedStatus.set(modelConstructor, true);
+                                                                                                });
+                                                                                                return [2 /*return*/];
+                                                                                        }
+                                                                                    });
+                                                                                }); })];
+                                                                        case 1:
+                                                                            /**
+                                                                             * If there are mutations in the outbox for a given id, those need to be
+                                                                             * merged individually. Otherwise, we can merge them in batches.
+                                                                             */
+                                                                            _c.sent();
+                                                                            if (!done) return [3 /*break*/, 4];
+                                                                            modelName = modelDefinition.name;
+                                                                            return [4 /*yield*/, this.getModelMetadata(namespace, modelName)];
+                                                                        case 2:
+                                                                            modelMetadata_1 = _c.sent();
+                                                                            lastFullSync = modelMetadata_1.lastFullSync, fullSyncInterval = modelMetadata_1.fullSyncInterval;
+                                                                            syncInterval = fullSyncInterval;
+                                                                            lastFullSyncStartedAt =
+                                                                                lastFullSyncStartedAt === undefined
+                                                                                    ? lastFullSync
+                                                                                    : Math.max(lastFullSyncStartedAt, isFullSync ? startedAt : lastFullSync);
+                                                                            modelMetadata_1 = this.modelClasses
+                                                                                .ModelMetadata.copyOf(modelMetadata_1, function (draft) {
+                                                                                draft.lastSync = startedAt;
+                                                                                draft.lastFullSync = isFullSync
+                                                                                    ? startedAt
+                                                                                    : modelMetadata_1.lastFullSync;
+                                                                            });
+                                                                            return [4 /*yield*/, this.storage.save(modelMetadata_1, undefined, ownSymbol)];
+                                                                        case 3:
+                                                                            _c.sent();
+                                                                            counts = count.get(modelConstructor);
+                                                                            this.modelSyncedStatus.set(modelConstructor, true);
+                                                                            observer.next({
+                                                                                type: ControlMessage.SYNC_ENGINE_MODEL_SYNCED,
+                                                                                data: {
+                                                                                    model: modelConstructor,
+                                                                                    isFullSync: isFullSync,
+                                                                                    isDeltaSync: !isFullSync,
+                                                                                    counts: counts,
+                                                                                },
+                                                                            });
+                                                                            paginatingModels.delete(modelDefinition);
+                                                                            if (paginatingModels.size === 0) {
+                                                                                syncDuration = getNow() - start;
+                                                                                resolve();
                                                                                 observer.next({
-                                                                                    type: ControlMessage.SYNC_ENGINE_MODEL_SYNCED,
-                                                                                    data: {
-                                                                                        model: modelConstructor,
-                                                                                        isFullSync: isFullSync,
-                                                                                        isDeltaSync: !isFullSync,
-                                                                                        counts: counts,
-                                                                                    },
+                                                                                    type: ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY,
                                                                                 });
-                                                                                paginatingModels.delete(modelDefinition);
-                                                                                if (paginatingModels.size === 0) {
-                                                                                    syncDuration = getNow() - start;
-                                                                                    resolve();
-                                                                                    observer.next({
-                                                                                        type: ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY,
-                                                                                    });
-                                                                                    syncQueriesSubscription.unsubscribe();
-                                                                                }
-                                                                                _b.label = 4;
-                                                                            case 4: return [2 /*return*/];
-                                                                        }
-                                                                    });
+                                                                                syncQueriesSubscription.unsubscribe();
+                                                                            }
+                                                                            _c.label = 4;
+                                                                        case 4: return [2 /*return*/];
+                                                                    }
                                                                 });
-                                                            },
+                                                            }); },
                                                             error: function (error) {
                                                                 observer.error(error);
                                                             },
@@ -570,7 +565,7 @@ var SyncEngine = /** @class */ (function () {
                                                         });
                                                     })];
                                             case 2:
-                                                _a.sent();
+                                                _b.sent();
                                                 if (!lastFullSyncStartedAt) {
                                                     msNextFullSync = syncInterval - syncDuration;
                                                 }
@@ -580,7 +575,7 @@ var SyncEngine = /** @class */ (function () {
                                                             syncInterval -
                                                             (lastStartedAt + syncDuration);
                                                 }
-                                                logger.debug("Next fullSync in " + msNextFullSync / 1000 + " seconds. (" + new Date(Date.now() + msNextFullSync) + ")");
+                                                logger.debug("Next fullSync in ".concat(msNextFullSync / 1000, " seconds. (").concat(new Date(Date.now() + msNextFullSync), ")"));
                                                 // TODO: create `BackgroundProcessManager.sleep()` ... but, need to put
                                                 // a lot of thought into what that contract looks like to
                                                 //  support possible use-cases:
@@ -626,7 +621,7 @@ var SyncEngine = /** @class */ (function () {
                                                 // TLDR; this is a lot of complexity here for a sleep(),
                                                 // but, it's not clear to me yet how to support an
                                                 // extensible, centralized cancelable `sleep()` elegantly.
-                                                _a.sent();
+                                                _b.sent();
                                                 this_1.unsleepSyncQueriesObservable = null;
                                                 this_1.waitForSleepState = new Promise(function (resolve) {
                                                     _this.syncQueriesObservableStartSleeping = resolve;
@@ -743,55 +738,53 @@ var SyncEngine = /** @class */ (function () {
                                 }
                             });
                         });
-                        promises = models.map(function (_a) {
-                            var _b = __read(_a, 2), namespace = _b[0], model = _b[1];
-                            return __awaiter(_this, void 0, void 0, function () {
-                                var modelMetadata, syncPredicate, lastSyncPredicate, prevSyncPredicate, syncPredicateUpdated_1;
-                                var _c, _d, _e, _f;
-                                return __generator(this, function (_g) {
-                                    switch (_g.label) {
-                                        case 0: return [4 /*yield*/, this.getModelMetadata(namespace, model.name)];
-                                        case 1:
-                                            modelMetadata = _g.sent();
-                                            syncPredicate = ModelPredicateCreator.getPredicates(this.syncPredicates.get(model), false);
-                                            lastSyncPredicate = syncPredicate
-                                                ? JSON.stringify(syncPredicate)
-                                                : null;
-                                            if (!(modelMetadata === undefined)) return [3 /*break*/, 3];
-                                            return [4 /*yield*/, this.storage.save(this.modelInstanceCreator(ModelMetadataConstructor, {
-                                                    model: model.name,
-                                                    namespace: namespace,
-                                                    lastSync: null,
-                                                    fullSyncInterval: fullSyncInterval,
-                                                    lastFullSync: null,
-                                                    lastSyncPredicate: lastSyncPredicate,
-                                                }), undefined, ownSymbol)];
-                                        case 2:
-                                            _c = __read.apply(void 0, [_g.sent(), 1]), _d = __read(_c[0], 1), savedModel = _d[0];
-                                            return [3 /*break*/, 5];
-                                        case 3:
-                                            prevSyncPredicate = modelMetadata.lastSyncPredicate
-                                                ? modelMetadata.lastSyncPredicate
-                                                : null;
-                                            syncPredicateUpdated_1 = prevSyncPredicate !== lastSyncPredicate;
-                                            return [4 /*yield*/, this.storage.save(ModelMetadataConstructor.copyOf(modelMetadata, function (draft) {
-                                                    draft.fullSyncInterval = fullSyncInterval;
-                                                    // perform a base sync if the syncPredicate changed in between calls to DataStore.start
-                                                    // ensures that the local store contains all the data specified by the syncExpression
-                                                    if (syncPredicateUpdated_1) {
-                                                        draft.lastSync = null;
-                                                        draft.lastFullSync = null;
-                                                        draft.lastSyncPredicate = lastSyncPredicate;
-                                                    }
-                                                }))];
-                                        case 4:
-                                            _e = __read.apply(void 0, [_g.sent(), 1]), _f = __read(_e[0], 1), savedModel = _f[0];
-                                            _g.label = 5;
-                                        case 5: return [2 /*return*/, savedModel];
-                                    }
-                                });
+                        promises = models.map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                            var modelMetadata, syncPredicate, lastSyncPredicate, prevSyncPredicate, syncPredicateUpdated_1;
+                            var _c, _d, _e, _f;
+                            var _g = __read(_b, 2), namespace = _g[0], model = _g[1];
+                            return __generator(this, function (_h) {
+                                switch (_h.label) {
+                                    case 0: return [4 /*yield*/, this.getModelMetadata(namespace, model.name)];
+                                    case 1:
+                                        modelMetadata = _h.sent();
+                                        syncPredicate = ModelPredicateCreator.getPredicates(this.syncPredicates.get(model), false);
+                                        lastSyncPredicate = syncPredicate
+                                            ? JSON.stringify(syncPredicate)
+                                            : null;
+                                        if (!(modelMetadata === undefined)) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this.storage.save(this.modelInstanceCreator(ModelMetadataConstructor, {
+                                                model: model.name,
+                                                namespace: namespace,
+                                                lastSync: null,
+                                                fullSyncInterval: fullSyncInterval,
+                                                lastFullSync: null,
+                                                lastSyncPredicate: lastSyncPredicate,
+                                            }), undefined, ownSymbol)];
+                                    case 2:
+                                        _c = __read.apply(void 0, [_h.sent(), 1]), _d = __read(_c[0], 1), savedModel = _d[0];
+                                        return [3 /*break*/, 5];
+                                    case 3:
+                                        prevSyncPredicate = modelMetadata.lastSyncPredicate
+                                            ? modelMetadata.lastSyncPredicate
+                                            : null;
+                                        syncPredicateUpdated_1 = prevSyncPredicate !== lastSyncPredicate;
+                                        return [4 /*yield*/, this.storage.save(ModelMetadataConstructor.copyOf(modelMetadata, function (draft) {
+                                                draft.fullSyncInterval = fullSyncInterval;
+                                                // perform a base sync if the syncPredicate changed in between calls to DataStore.start
+                                                // ensures that the local store contains all the data specified by the syncExpression
+                                                if (syncPredicateUpdated_1) {
+                                                    draft.lastSync = null;
+                                                    draft.lastFullSync = null;
+                                                    draft.lastSyncPredicate = lastSyncPredicate;
+                                                }
+                                            }))];
+                                    case 4:
+                                        _e = __read.apply(void 0, [_h.sent(), 1]), _f = __read(_e[0], 1), savedModel = _f[0];
+                                        _h.label = 5;
+                                    case 5: return [2 /*return*/, savedModel];
+                                }
                             });
-                        });
+                        }); });
                         result = {};
                         _d.label = 1;
                     case 1: