@aws-amplify/datastore 3.7.3 → 3.7.4-custom-pk.79

package/lib-esm/datastore/datastore.js

@@ -87,7 +87,10 @@ var __spread = (this && this.__spread) || function () {
     for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
     return ar;
 };
+import API from '@aws-amplify/api';
 import { Amplify, ConsoleLogger as Logger, Hub, JS } from '@aws-amplify/core';
+import { Auth } from '@aws-amplify/auth';
+import Cache from '@aws-amplify/cache';
 import { immerable, produce, setAutoFreeze, enablePatches, } from 'immer';
 import { v4 as uuid4 } from 'uuid';
 import Observable from 'zen-observable-ts';
@@ -95,8 +98,8 @@ import { defaultAuthStrategy, multiAuthStrategy } from '../authModeStrategies';
 import { isPredicatesAll, ModelPredicateCreator, ModelSortPredicateCreator, } from '../predicates';
 import { ExclusiveStorage as Storage } from '../storage/storage';
 import { ControlMessage, SyncEngine } from '../sync';
-import { GraphQLScalarType, isGraphQLScalarType, AuthModeStrategyType, isNonModelFieldType, isModelFieldType, } from '../types';
-import { DATASTORE, establishRelationAndKeys, exhaustiveCheck, isModelConstructor, monotonicUlidFactory, STORAGE, SYNC, USER, isNullOrUndefined, registerNonModelClass, sortCompareFunction, DeferredCallbackResolver, } from '../util';
+import { GraphQLScalarType, isGraphQLScalarType, AuthModeStrategyType, isNonModelFieldType, isModelFieldType, __modelMeta__, isIdentifierObject, } from '../types';
+import { DATASTORE, establishRelationAndKeys, exhaustiveCheck, isModelConstructor, monotonicUlidFactory, STORAGE, SYNC, USER, isNullOrUndefined, registerNonModelClass, sortCompareFunction, DeferredCallbackResolver, extractPrimaryKeyFieldNames, isIdManaged, isIdOptionallyManaged, validatePredicate, mergePatches, } from '../util';
 setAutoFreeze(true);
 enablePatches();
 var logger = new Logger('DataStore');
@@ -201,6 +204,18 @@ var initSchema = function (userSchema) {
     });
     return userClasses;
 };
+/* Checks if the schema has been initialized by initSchema().
+ *
+ * Call this function before accessing schema.
+ * Currently this only needs to be called in start() and clear() because all other functions will call start first.
+ */
+var checkSchemaInitialized = function () {
+    if (schema === undefined) {
+        var message = 'Schema is not initialized. DataStore will not function as expected. This could happen if you have multiple versions of DataStore installed. Please see https://docs.amplify.aws/lib/troubleshooting/upgrading/q/platform/js/#check-for-duplicate-versions';
+        logger.error(message);
+        throw new Error(message);
+    }
+};
 var createTypeClasses = function (namespace) {
     var classes = {};
     Object.entries(namespace.models).forEach(function (_a) {
@@ -329,21 +344,29 @@ var createModelClass = function (modelDefinition) {
         function Model(init) {
             var instance = produce(this, function (draft) {
                 initializeInstance(init, modelDefinition, draft);
-                var modelInstanceMetadata = instancesMetadata.has(init)
+                // model is initialized inside a DataStore component (e.g. by Sync Engine, Storage Engine, etc.)
+                var isInternallyInitialized = instancesMetadata.has(init);
+                var modelInstanceMetadata = isInternallyInitialized
                     ? init
                     : {};
-                var _id = modelInstanceMetadata.id, _version = modelInstanceMetadata._version, _lastChangedAt = modelInstanceMetadata._lastChangedAt, _deleted = modelInstanceMetadata._deleted;
-                // instancesIds are set by modelInstanceCreator, it is accessible only internally
-                var isInternal = _id !== null && _id !== undefined;
-                var id = isInternal
-                    ? _id
-                    : modelDefinition.syncable
-                        ? uuid4()
-                        : ulid();
-                if (!isInternal) {
+                var _id = modelInstanceMetadata.id;
+                if (isIdManaged(modelDefinition)) {
+                    var isInternalModel = _id !== null && _id !== undefined;
+                    var id = isInternalModel
+                        ? _id
+                        : modelDefinition.syncable
+                            ? uuid4()
+                            : ulid();
+                    draft.id = id;
+                }
+                else if (isIdOptionallyManaged(modelDefinition)) {
+                    // only auto-populate if the id was not provided
+                    draft.id = draft.id || uuid4();
+                }
+                if (!isInternallyInitialized) {
                     checkReadOnlyPropertyOnCreate(draft, modelDefinition);
                 }
-                draft.id = id;
+                var _version = modelInstanceMetadata._version, _lastChangedAt = modelInstanceMetadata._lastChangedAt, _deleted = modelInstanceMetadata._deleted;
                 if (modelDefinition.syncable) {
                     draft._version = _version;
                     draft._lastChangedAt = _lastChangedAt;
@@ -362,7 +385,11 @@ var createModelClass = function (modelDefinition) {
             var patches;
             var model = produce(source, function (draft) {
                 fn(draft);
-                draft.id = source.id;
+                var keyNames = extractPrimaryKeyFieldNames(modelDefinition);
+                // Keys are immutable
+                // CPK TODO: Previous comment from Ivan:
+                // @ts-ignore TODO: fix type
+                keyNames.forEach(function (key) { return (draft[key] = source[key]); });
                 var modelValidator = validateModelFields(modelDefinition);
                 Object.entries(draft).forEach(function (_a) {
                     var _b = __read(_a, 2), k = _b[0], v = _b[1];
@@ -370,9 +397,18 @@ var createModelClass = function (modelDefinition) {
                     modelValidator(k, parsedValue);
                 });
             }, function (p) { return (patches = p); });
-            if (patches.length) {
-                modelPatchesMap.set(model, [patches, source]);
-                checkReadOnlyPropertyOnUpdate(patches, modelDefinition);
+            var hasExistingPatches = modelPatchesMap.has(source);
+            if (patches.length || hasExistingPatches) {
+                if (hasExistingPatches) {
+                    var _a = __read(modelPatchesMap.get(source), 2), existingPatches = _a[0], existingSource = _a[1];
+                    var mergedPatches = mergePatches(existingSource, existingPatches, patches);
+                    modelPatchesMap.set(model, [mergedPatches, existingSource]);
+                    checkReadOnlyPropertyOnUpdate(mergedPatches, modelDefinition);
+                }
+                else {
+                    modelPatchesMap.set(model, [patches, source]);
+                    checkReadOnlyPropertyOnUpdate(patches, modelDefinition);
+                }
             }
             return model;
         };
@@ -486,7 +522,6 @@ function checkSchemaVersion(storage, version) {
                             return __generator(this, function (_b) {
                                 switch (_b.label) {
                                     case 0: return [4 /*yield*/, s.query(Setting, ModelPredicateCreator.createFromExisting(modelDefinition, function (c) {
-                                            // @ts-ignore Argument of type '"eq"' is not assignable to parameter of type 'never'.
                                             return c.key('eq', SETTING_SCHEMA_VERSION);
                                         }), { page: 0, limit: 1 })];
                                     case 1:
@@ -558,8 +593,18 @@ function getNamespace() {
 var DataStore = /** @class */ (function () {
     function DataStore() {
         var _this = this;
+        // reference to configured category instances. Used for preserving SSR context
+        this.Auth = Auth;
+        this.API = API;
+        this.Cache = Cache;
         this.amplifyConfig = {};
         this.syncPredicates = new WeakMap();
+        // object that gets passed to descendent classes. Allows us to pass these down by reference
+        this.amplifyContext = {
+            Auth: this.Auth,
+            API: this.API,
+            Cache: this.Cache,
+        };
         this.start = function () { return __awaiter(_this, void 0, void 0, function () {
             var aws_appsync_graphqlEndpoint, _a, fullSyncIntervalInMilliseconds;
             var _this = this;
@@ -582,6 +627,7 @@ var DataStore = /** @class */ (function () {
                         return [4 /*yield*/, this.storage.init()];
                     case 4:
                         _b.sent();
+                        checkSchemaInitialized();
                         return [4 /*yield*/, checkSchemaVersion(this.storage, schema.version)];
                     case 5:
                         _b.sent();
@@ -592,7 +638,7 @@ var DataStore = /** @class */ (function () {
                         return [4 /*yield*/, this.processSyncExpressions()];
                     case 6:
                         _a.syncPredicates = _b.sent();
-                        this.sync = new SyncEngine(schema, namespaceResolver, syncClasses, userClasses, this.storage, modelInstanceCreator, this.maxRecordsToSync, this.syncPageSize, this.conflictHandler, this.errorHandler, this.syncPredicates, this.amplifyConfig, this.authModeStrategy);
+                        this.sync = new SyncEngine(schema, namespaceResolver, syncClasses, userClasses, this.storage, modelInstanceCreator, this.conflictHandler, this.errorHandler, this.syncPredicates, this.amplifyConfig, this.authModeStrategy, this.amplifyContext);
                         fullSyncIntervalInMilliseconds = this.fullSyncInterval * 1000 * 60;
                         syncSubscription = this.sync
                             .start({ fullSyncInterval: fullSyncIntervalInMilliseconds })
@@ -631,8 +677,8 @@ var DataStore = /** @class */ (function () {
                 }
             });
         }); };
-        this.query = function (modelConstructor, idOrCriteria, paginationProducer) { return __awaiter(_this, void 0, void 0, function () {
-            var msg, modelDefinition, predicate, pagination, result;
+        this.query = function (modelConstructor, identifierOrCriteria, paginationProducer) { return __awaiter(_this, void 0, void 0, function () {
+            var msg, modelDefinition, keyFields, predicate, pagination, result, isSingleFieldIdentifier, returnOne;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.start()];
@@ -644,22 +690,27 @@ var DataStore = /** @class */ (function () {
                             logger.error(msg, { modelConstructor: modelConstructor });
                             throw new Error(msg);
                         }
-                        if (typeof idOrCriteria === 'string') {
+                        if (typeof identifierOrCriteria === 'string') {
                             if (paginationProducer !== undefined) {
                                 logger.warn('Pagination is ignored when querying by id');
                             }
                         }
                         modelDefinition = getModelDefinition(modelConstructor);
-                        if (isQueryOne(idOrCriteria)) {
-                            predicate = ModelPredicateCreator.createForId(modelDefinition, idOrCriteria);
+                        keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+                        if (isQueryOne(identifierOrCriteria)) {
+                            predicate = ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], identifierOrCriteria);
                         }
                         else {
-                            if (isPredicatesAll(idOrCriteria)) {
+                            // Object is being queried using object literal syntax
+                            if (isIdentifierObject(identifierOrCriteria, modelDefinition)) {
+                                predicate = ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
+                            }
+                            else if (isPredicatesAll(identifierOrCriteria)) {
                                 // Predicates.ALL means "all records", so no predicate (undefined)
                                 predicate = undefined;
                             }
                             else {
-                                predicate = ModelPredicateCreator.createFromExisting(modelDefinition, idOrCriteria);
+                                predicate = ModelPredicateCreator.createFromExisting(modelDefinition, identifierOrCriteria);
                             }
                         }
                         pagination = this.processPagination(modelDefinition, paginationProducer);
@@ -672,7 +723,11 @@ var DataStore = /** @class */ (function () {
                         return [4 /*yield*/, this.storage.query(modelConstructor, predicate, pagination)];
                     case 2:
                         result = _a.sent();
-                        return [2 /*return*/, isQueryOne(idOrCriteria) ? result[0] : result];
+                        isSingleFieldIdentifier = keyFields.length === 1;
+                        returnOne = isSingleFieldIdentifier &&
+                            (isQueryOne(identifierOrCriteria) ||
+                                isIdentifierObject(identifierOrCriteria, modelDefinition));
+                        return [2 /*return*/, returnOne ? result[0] : result];
                 }
             });
         }); };
@@ -701,7 +756,7 @@ var DataStore = /** @class */ (function () {
                                         case 0: return [4 /*yield*/, s.save(model, producedCondition, undefined, patchesTuple)];
                                         case 1:
                                             _a.sent();
-                                            return [2 /*return*/, s.query(modelConstructor, ModelPredicateCreator.createForId(modelDefinition, model.id))];
+                                            return [2 /*return*/, s.query(modelConstructor, ModelPredicateCreator.createForPk(modelDefinition, model))];
                                     }
                                 });
                             }); })];
@@ -737,13 +792,13 @@ var DataStore = /** @class */ (function () {
             }
             return _this.errorHandler || defaultErrorHandler;
         };
-        this.delete = function (modelOrConstructor, idOrCriteria) { return __awaiter(_this, void 0, void 0, function () {
-            var condition, msg, modelConstructor, msg, msg, _a, deleted, model, modelConstructor, msg, modelDefinition, idPredicate, msg, _b, _c, deleted;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+        this.delete = function (modelOrConstructor, identifierOrCriteria) { return __awaiter(_this, void 0, void 0, function () {
+            var condition, msg, modelConstructor, msg, modelDefinition, _a, keyField, msg, _b, deleted, model, modelConstructor, msg, modelDefinition, pkPredicate, msg, _c, _d, deleted;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0: return [4 /*yield*/, this.start()];
                     case 1:
-                        _d.sent();
+                        _e.sent();
                         if (!modelOrConstructor) {
                             msg = 'Model or Model Constructor required';
                             logger.error(msg, { modelOrConstructor: modelOrConstructor });
@@ -751,21 +806,28 @@ var DataStore = /** @class */ (function () {
                         }
                         if (!isValidModelConstructor(modelOrConstructor)) return [3 /*break*/, 3];
                         modelConstructor = modelOrConstructor;
-                        if (!idOrCriteria) {
+                        if (!identifierOrCriteria) {
                             msg = 'Id to delete or criteria required. Do you want to delete all? Pass Predicates.ALL';
-                            logger.error(msg, { idOrCriteria: idOrCriteria });
+                            logger.error(msg, { identifierOrCriteria: identifierOrCriteria });
                             throw new Error(msg);
                         }
-                        if (typeof idOrCriteria === 'string') {
-                            condition = ModelPredicateCreator.createForId(getModelDefinition(modelConstructor), idOrCriteria);
+                        modelDefinition = getModelDefinition(modelConstructor);
+                        if (typeof identifierOrCriteria === 'string') {
+                            _a = __read(extractPrimaryKeyFieldNames(modelDefinition), 1), keyField = _a[0];
+                            condition = ModelPredicateCreator.createForSingleField(getModelDefinition(modelConstructor), keyField, identifierOrCriteria);
                         }
                         else {
-                            condition = ModelPredicateCreator.createFromExisting(getModelDefinition(modelConstructor), 
-                            /**
-                             * idOrCriteria is always a ProducerModelPredicate<T>, never a symbol.
-                             * The symbol is used only for typing purposes. e.g. see Predicates.ALL
-                             */
-                            idOrCriteria);
+                            if (isIdentifierObject(identifierOrCriteria, modelDefinition)) {
+                                condition = ModelPredicateCreator.createForPk(modelDefinition, identifierOrCriteria);
+                            }
+                            else {
+                                condition = ModelPredicateCreator.createFromExisting(modelDefinition, 
+                                /**
+                                 * idOrCriteria is always a ProducerModelPredicate<T>, never a symbol.
+                                 * The symbol is used only for typing purposes. e.g. see Predicates.ALL
+                                 */
+                                identifierOrCriteria);
+                            }
                             if (!condition || !ModelPredicateCreator.isValidPredicate(condition)) {
                                 msg = 'Criteria required. Do you want to delete all? Pass Predicates.ALL';
                                 logger.error(msg, { condition: condition });
@@ -774,7 +836,7 @@ var DataStore = /** @class */ (function () {
                         }
                         return [4 /*yield*/, this.storage.delete(modelConstructor, condition)];
                     case 2:
-                        _a = __read.apply(void 0, [_d.sent(), 1]), deleted = _a[0];
+                        _b = __read.apply(void 0, [_e.sent(), 1]), deleted = _b[0];
                         return [2 /*return*/, deleted];
                     case 3:
                         model = modelOrConstructor;
@@ -786,26 +848,26 @@ var DataStore = /** @class */ (function () {
                             throw new Error(msg);
                         }
                         modelDefinition = getModelDefinition(modelConstructor);
-                        idPredicate = ModelPredicateCreator.createForId(modelDefinition, model.id);
-                        if (idOrCriteria) {
-                            if (typeof idOrCriteria !== 'function') {
+                        pkPredicate = ModelPredicateCreator.createForPk(modelDefinition, model);
+                        if (identifierOrCriteria) {
+                            if (typeof identifierOrCriteria !== 'function') {
                                 msg = 'Invalid criteria';
-                                logger.error(msg, { idOrCriteria: idOrCriteria });
+                                logger.error(msg, { identifierOrCriteria: identifierOrCriteria });
                                 throw new Error(msg);
                             }
-                            condition = idOrCriteria(idPredicate);
+                            condition = identifierOrCriteria(pkPredicate);
                         }
                         else {
-                            condition = idPredicate;
+                            condition = pkPredicate;
                         }
                         return [4 /*yield*/, this.storage.delete(model, condition)];
                     case 4:
-                        _b = __read.apply(void 0, [_d.sent(), 1]), _c = __read(_b[0], 1), deleted = _c[0];
+                        _c = __read.apply(void 0, [_e.sent(), 1]), _d = __read(_c[0], 1), deleted = _d[0];
                         return [2 /*return*/, deleted];
                 }
             });
         }); };
-        this.observe = function (modelOrConstructor, idOrCriteria) {
+        this.observe = function (modelOrConstructor, identifierOrCriteria) {
             var predicate;
             var modelConstructor = modelOrConstructor && isValidModelConstructor(modelOrConstructor)
                 ? modelOrConstructor
@@ -814,10 +876,10 @@ var DataStore = /** @class */ (function () {
                 var model = modelOrConstructor;
                 var modelConstructor_1 = model && Object.getPrototypeOf(model).constructor;
                 if (isValidModelConstructor(modelConstructor_1)) {
-                    if (idOrCriteria) {
+                    if (identifierOrCriteria) {
                         logger.warn('idOrCriteria is ignored when using a model instance', {
                             model: model,
-                            idOrCriteria: idOrCriteria,
+                            identifierOrCriteria: identifierOrCriteria,
                         });
                     }
                     return _this.observe(modelConstructor_1, model.id);
@@ -828,9 +890,9 @@ var DataStore = /** @class */ (function () {
                     throw new Error(msg);
                 }
             }
-            if (idOrCriteria !== undefined && modelConstructor === undefined) {
+            if (identifierOrCriteria !== undefined && modelConstructor === undefined) {
                 var msg = 'Cannot provide criteria without a modelConstructor';
-                logger.error(msg, idOrCriteria);
+                logger.error(msg, identifierOrCriteria);
                 throw new Error(msg);
             }
             if (modelConstructor && !isValidModelConstructor(modelConstructor)) {
@@ -838,29 +900,60 @@ var DataStore = /** @class */ (function () {
                 logger.error(msg, { modelConstructor: modelConstructor });
                 throw new Error(msg);
             }
-            if (typeof idOrCriteria === 'string') {
-                predicate = ModelPredicateCreator.createForId(getModelDefinition(modelConstructor), idOrCriteria);
+            if (typeof identifierOrCriteria === 'string') {
+                var modelDefinition = getModelDefinition(modelConstructor);
+                var _a = __read(extractPrimaryKeyFieldNames(modelDefinition), 1), keyField = _a[0];
+                predicate = ModelPredicateCreator.createForSingleField(getModelDefinition(modelConstructor), keyField, identifierOrCriteria);
             }
             else {
-                predicate =
-                    modelConstructor &&
-                        ModelPredicateCreator.createFromExisting(getModelDefinition(modelConstructor), idOrCriteria);
+                if (isPredicatesAll(identifierOrCriteria)) {
+                    predicate = undefined;
+                }
+                else {
+                    predicate =
+                        modelConstructor &&
+                            ModelPredicateCreator.createFromExisting(getModelDefinition(modelConstructor), identifierOrCriteria);
+                }
             }
             return new Observable(function (observer) {
                 var handle;
                 (function () { return __awaiter(_this, void 0, void 0, function () {
+                    var _this = this;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0: return [4 /*yield*/, this.start()];
                             case 1:
                                 _a.sent();
+                                // Filter the events returned by Storage according to namespace,
+                                // append original element data, and subscribe to the observable
                                 handle = this.storage
                                     .observe(modelConstructor, predicate)
                                     .filter(function (_a) {
                                     var model = _a.model;
                                     return namespaceResolver(model) === USER;
                                 })
-                                    .subscribe(observer);
+                                    .subscribe({
+                                    next: function (item) { return __awaiter(_this, void 0, void 0, function () {
+                                        var message, freshElement;
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0:
+                                                    message = item;
+                                                    if (!(item.opType !== 'DELETE')) return [3 /*break*/, 2];
+                                                    return [4 /*yield*/, this.query(item.model, item.element.id)];
+                                                case 1:
+                                                    freshElement = _a.sent();
+                                                    message = __assign(__assign({}, message), { element: freshElement });
+                                                    _a.label = 2;
+                                                case 2:
+                                                    observer.next(message);
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); },
+                                    error: function (err) { return observer.error(err); },
+                                    complete: function () { return observer.complete(); },
+                                });
                                 return [2 /*return*/];
                         }
                     });
@@ -878,6 +971,17 @@ var DataStore = /** @class */ (function () {
                 var itemsChanged = new Map();
                 var deletedItemIds = [];
                 var handle;
+                var predicate;
+                /**
+                 * As the name suggests, this geneates a snapshot in the form of
+                 * 	`{items: T[], isSynced: boolean}`
+                 * and sends it to the observer.
+                 *
+                 * SIDE EFFECT: The underlying generation and emission methods may touch:
+                 * `items`, `itemsChanged`, and `deletedItemIds`.
+                 *
+                 * Refer to `generateSnapshot` and `emitSnapshot` for more details.
+                 */
                 var generateAndEmitSnapshot = function () {
                     var snapshot = generateSnapshot();
                     emitSnapshot(snapshot);
@@ -891,6 +995,22 @@ var DataStore = /** @class */ (function () {
                 });
                 var sort = (options || {}).sort;
                 var sortOptions = sort ? { sort: sort } : undefined;
+                var modelDefinition = getModelDefinition(model);
+                var keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+                if (isQueryOne(criteria)) {
+                    predicate = ModelPredicateCreator.createForSingleField(modelDefinition, keyFields[0], criteria);
+                }
+                else {
+                    if (isPredicatesAll(criteria)) {
+                        // Predicates.ALL means "all records", so no predicate (undefined)
+                        predicate = undefined;
+                    }
+                    else {
+                        predicate = ModelPredicateCreator.createFromExisting(modelDefinition, criteria);
+                    }
+                }
+                var _a = ModelPredicateCreator.getPredicates(predicate, false) || {}, predicates = _a.predicates, predicateGroupType = _a.type;
+                var hasPredicate = !!predicates;
                 (function () { return __awaiter(_this, void 0, void 0, function () {
                     var err_1;
                     var _this = this;
@@ -904,12 +1024,28 @@ var DataStore = /** @class */ (function () {
                                 (_a.sent()).forEach(function (item) {
                                     return items.set(item.id, item);
                                 });
-                                // observe the model and send a stream of updates (debounced)
-                                handle = this.observe(model, 
-                                // @ts-ignore TODO: fix this TSlint error
-                                criteria).subscribe(function (_a) {
+                                // Observe the model and send a stream of updates (debounced).
+                                // We need to post-filter results instead of passing criteria through
+                                // to have visibility into items that move from in-set to out-of-set.
+                                // We need to explicitly remove those items from the existing snapshot.
+                                handle = this.observe(model).subscribe(function (_a) {
                                     var element = _a.element, model = _a.model, opType = _a.opType;
                                     var _b, _c;
+                                    if (hasPredicate &&
+                                        !validatePredicate(element, predicateGroupType, predicates)) {
+                                        if (opType === 'UPDATE' &&
+                                            (items.has(element.id) || itemsChanged.has(element.id))) {
+                                            // tracking as a "deleted item" will include the item in
+                                            // page limit calculations and ensure it is removed from the
+                                            // final items collection, regardless of which collection(s)
+                                            // it is currently in. (I mean, it could be in both, right!?)
+                                            deletedItemIds.push(element.id);
+                                        }
+                                        else {
+                                            // ignore updates for irrelevant/filtered items.
+                                            return;
+                                        }
+                                    }
                                     // Flag items which have been recently deleted
                                     // NOTE: Merging of separate operations to the same model instance is handled upstream
                                     // in the `mergePage` method within src/sync/merger.ts. The final state of a model instance
@@ -939,7 +1075,12 @@ var DataStore = /** @class */ (function () {
                         }
                     });
                 }); })();
-                // TODO: abstract this function into a util file to be able to write better unit tests
+                /**
+                 * Combines the `items`, `itemsChanged`, and `deletedItemIds` collections into
+                 * a snapshot in the form of `{ items: T[], isSynced: boolean}`.
+                 *
+                 * SIDE EFFECT: The shared `items` collection is recreated.
+                 */
                 var generateSnapshot = function () {
                     var _a, _b;
                     var isSynced = (_b = (_a = _this.sync) === null || _a === void 0 ? void 0 : _a.getModelSyncedStatus(model)) !== null && _b !== void 0 ? _b : false;
@@ -956,6 +1097,14 @@ var DataStore = /** @class */ (function () {
                         isSynced: isSynced,
                     };
                 };
+                /**
+                 * Emits the list of items to the observer.
+                 *
+                 * SIDE EFFECT: `itemsChanged` and `deletedItemIds` are cleared to prepare
+                 * for the next snapshot.
+                 *
+                 * @param snapshot The generated items data to emit.
+                 */
                 var emitSnapshot = function (snapshot) {
                     // send the generated snapshot to the primary subscription
                     observer.next(snapshot);
@@ -963,6 +1112,12 @@ var DataStore = /** @class */ (function () {
                     itemsChanged.clear();
                     deletedItemIds = [];
                 };
+                /**
+                 * Sorts an `Array` of `T` according to the sort instructions given in the
+                 * original  `observeQuery()` call.
+                 *
+                 * @param itemsToSort A array of model type.
+                 */
                 var sortItems = function (itemsToSort) {
                     var modelDefinition = getModelDefinition(model);
                     var pagination = _this.processPagination(modelDefinition, options);
@@ -972,7 +1127,14 @@ var DataStore = /** @class */ (function () {
                         itemsToSort.sort(compareFn);
                     }
                 };
-                // send one last snapshot when the model is fully synced
+                /**
+                 * Force one last snapshot when the model is fully synced.
+                 *
+                 * This reduces latency for that last snapshot, which will otherwise
+                 * wait for the configured timeout.
+                 *
+                 * @param payload The payload from the Hub event.
+                 */
                 var hubCallback = function (_a) {
                     var payload = _a.payload;
                     var _b;
@@ -993,6 +1155,9 @@ var DataStore = /** @class */ (function () {
         };
         this.configure = function (config) {
             if (config === void 0) { config = {}; }
+            _this.amplifyContext.Auth = _this.Auth;
+            _this.amplifyContext.API = _this.API;
+            _this.amplifyContext.Cache = _this.Cache;
             var configDataStore = config.DataStore, configAuthModeStrategyType = config.authModeStrategyType, configConflictHandler = config.conflictHandler, configErrorHandler = config.errorHandler, configMaxRecordsToSync = config.maxRecordsToSync, configSyncPageSize = config.syncPageSize, configFullSyncInterval = config.fullSyncInterval, configSyncExpressions = config.syncExpressions, configAuthProviders = config.authProviders, configStorageAdapter = config.storageAdapter, configFromAmplify = __rest(config, ["DataStore", "authModeStrategyType", "conflictHandler", "errorHandler", "maxRecordsToSync", "syncPageSize", "fullSyncInterval", "syncExpressions", "authProviders", "storageAdapter"]);
             _this.amplifyConfig = __assign(__assign({}, configFromAmplify), _this.amplifyConfig);
             _this.conflictHandler = _this.setConflictHandler(config);
@@ -1002,7 +1167,7 @@ var DataStore = /** @class */ (function () {
                 AuthModeStrategyType.DEFAULT;
             switch (authModeStrategyType) {
                 case AuthModeStrategyType.MULTI_AUTH:
-                    _this.authModeStrategy = multiAuthStrategy;
+                    _this.authModeStrategy = multiAuthStrategy(_this.amplifyContext);
                     break;
                 case AuthModeStrategyType.DEFAULT:
                     _this.authModeStrategy = defaultAuthStrategy;
@@ -1016,29 +1181,31 @@ var DataStore = /** @class */ (function () {
                 (configDataStore && configDataStore.authProviders) || configAuthProviders;
             _this.syncExpressions =
                 (configDataStore && configDataStore.syncExpressions) ||
-                    _this.syncExpressions ||
-                    configSyncExpressions;
+                    configSyncExpressions ||
+                    _this.syncExpressions;
             _this.maxRecordsToSync =
                 (configDataStore && configDataStore.maxRecordsToSync) ||
                     configMaxRecordsToSync ||
+                    _this.maxRecordsToSync ||
                     10000;
             // store on config object, so that Sync, Subscription, and Mutation processors can have access
             _this.amplifyConfig.maxRecordsToSync = _this.maxRecordsToSync;
             _this.syncPageSize =
                 (configDataStore && configDataStore.syncPageSize) ||
                     configSyncPageSize ||
+                    _this.syncPageSize ||
                     1000;
             // store on config object, so that Sync, Subscription, and Mutation processors can have access
             _this.amplifyConfig.syncPageSize = _this.syncPageSize;
             _this.fullSyncInterval =
                 (configDataStore && configDataStore.fullSyncInterval) ||
-                    _this.fullSyncInterval ||
                     configFullSyncInterval ||
+                    _this.fullSyncInterval ||
                     24 * 60; // 1 day
             _this.storageAdapter =
                 (configDataStore && configDataStore.storageAdapter) ||
-                    _this.storageAdapter ||
                     configStorageAdapter ||
+                    _this.storageAdapter ||
                     undefined;
             _this.sessionId = _this.retrieveSessionId();
         };
@@ -1047,14 +1214,20 @@ var DataStore = /** @class */ (function () {
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            if (this.storage === undefined) {
-                                return [2 /*return*/];
-                            }
+                            checkSchemaInitialized();
+                            if (!(this.storage === undefined)) return [3 /*break*/, 2];
+                            // connect to storage so that it can be cleared without fully starting DataStore
+                            this.storage = new Storage(schema, namespaceResolver, getModelConstructorByModelName, modelInstanceCreator, this.storageAdapter, this.sessionId);
+                            return [4 /*yield*/, this.storage.init()];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
                             if (syncSubscription && !syncSubscription.closed) {
                                 syncSubscription.unsubscribe();
                             }
                             return [4 /*yield*/, this.storage.clear()];
-                        case 1:
+                        case 3:
                             _a.sent();
                             if (this.sync) {
                                 this.sync.unsubscribeConnectivity();
@@ -1222,9 +1395,8 @@ var DataStore = /** @class */ (function () {
                 return sessionId + "-" + appSyncId;
             }
         }
-        catch (_b) {
-            return undefined;
-        }
+        catch (_b) { }
+        return undefined;
     };
     return DataStore;
 }());