@aws-amplify/datastore 3.11.4-unstable.2 → 3.11.4-unstable.9

package/dist/aws-amplify-datastore.js

@@ -83081,6 +83081,17 @@ 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 generateAndEmitSnapshot() {
           var snapshot = generateSnapshot();
@@ -83098,6 +83109,24 @@ function () {
         var sortOptions = sort ? {
           sort: sort
         } : undefined;
+        var modelDefinition = getModelDefinition(model);
+
+        if (isQueryOne(criteria)) {
+          predicate = _predicates__WEBPACK_IMPORTED_MODULE_5__["ModelPredicateCreator"].createForId(modelDefinition, criteria);
+        } else {
+          if (Object(_predicates__WEBPACK_IMPORTED_MODULE_5__["isPredicatesAll"])(criteria)) {
+            // Predicates.ALL means "all records", so no predicate (undefined)
+            predicate = undefined;
+          } else {
+            predicate = _predicates__WEBPACK_IMPORTED_MODULE_5__["ModelPredicateCreator"].createFromExisting(modelDefinition, criteria);
+          }
+        }
+
+        var _a = _predicates__WEBPACK_IMPORTED_MODULE_5__["ModelPredicateCreator"].getPredicates(predicate, false) || {},
+            predicates = _a.predicates,
+            predicateGroupType = _a.type;
+
+        var hasPredicate = !!predicates;
 
         (function () {
           return __awaiter(_this, void 0, void 0, function () {
@@ -83118,16 +83147,31 @@ function () {
                   // first, query and return any locally-available records
                   _a.sent().forEach(function (item) {
                     return items.set(item.id, item);
-                  }); // observe the model and send a stream of updates (debounced)
+                  }); // 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, // @ts-ignore TODO: fix this TSlint error
-                  criteria).subscribe(function (_a) {
+                  handle = this.observe(model).subscribe(function (_a) {
                     var element = _a.element,
                         model = _a.model,
                         opType = _a.opType;
 
-                    var _b, _c; // Flag items which have been recently deleted
+                    var _b, _c;
+
+                    if (hasPredicate && !Object(_util__WEBPACK_IMPORTED_MODULE_9__["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
                     // depends on the LATEST record (for a given id).
@@ -83169,7 +83213,13 @@ 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 generateSnapshot() {
@@ -83196,6 +83246,15 @@ 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 emitSnapshot(snapshot) {
           // send the generated snapshot to the primary subscription
@@ -83204,6 +83263,13 @@ 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 sortItems(itemsToSort) {
           var modelDefinition = getModelDefinition(model);
@@ -83216,7 +83282,15 @@ function () {
             var compareFn = Object(_util__WEBPACK_IMPORTED_MODULE_9__["sortCompareFunction"])(sortPredicates);
             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 hubCallback(_a) {
@@ -92381,57 +92455,85 @@ var __values = undefined && undefined.__values || function (o) {
   throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
 
+var connectionTimeout = function connectionTimeout(error) {
+  return /^Connection failed: Connection Timeout/.test(error.message);
+};
+
+var serverError = function serverError(error) {
+  return /^Error: Request failed with status code 5\d\d/.test(error.message);
+};
+
 var mutationErrorMap = {
+  BadModel: function BadModel() {
+    return false;
+  },
   BadRecord: function BadRecord(error) {
-    return /^Cannot return \w+ for [\w-_]+ type/.test(error.message);
+    var message = error.message;
+    return /^Cannot return \w+ for [\w-_]+ type/.test(message) || /^Variable '.+' has coerced Null value for NonNull type/.test(message); // newly required field, out of date client
   },
   ConfigError: function ConfigError() {
     return false;
   },
-  Transient: function Transient() {
-    return false;
+  Transient: function Transient(error) {
+    return connectionTimeout(error) || serverError(error);
   },
-  Unauthorized: function Unauthorized() {
-    return false;
+  Unauthorized: function Unauthorized(error) {
+    return /^Request failed with status code 401/.test(error.message);
   }
 };
 var subscriptionErrorMap = {
+  BadModel: function BadModel() {
+    return false;
+  },
   BadRecord: function BadRecord() {
     return false;
   },
   ConfigError: function ConfigError() {
     return false;
   },
-  Transient: function Transient() {
-    return false;
+  Transient: function Transient(observableError) {
+    var error = unwrapObservableError(observableError);
+    return connectionTimeout(error) || serverError(error);
   },
-  Unauthorized: function Unauthorized(givenError) {
-    var _a = givenError.error,
-        _b = __read((_a === void 0 ? {
-      errors: []
-    } : _a).errors, 1),
-        _c = _b[0],
-        _d = (_c === void 0 ? {} : _c).message,
-        message = _d === void 0 ? '' : _d;
-
-    var regex = /Connection failed.+Unauthorized/;
-    return regex.test(message);
+  Unauthorized: function Unauthorized(observableError) {
+    var error = unwrapObservableError(observableError);
+    return /Connection failed.+Unauthorized/.test(error.message);
   }
 };
 var syncErrorMap = {
+  BadModel: function BadModel() {
+    return false;
+  },
   BadRecord: function BadRecord(error) {
     return /^Cannot return \w+ for [\w-_]+ type/.test(error.message);
   },
   ConfigError: function ConfigError() {
     return false;
   },
-  Transient: function Transient() {
-    return false;
+  Transient: function Transient(error) {
+    return connectionTimeout(error) || serverError(error);
   },
   Unauthorized: function Unauthorized() {
     return false;
   }
 };
+/**
+ * Get the first error reason of an observable.
+ * Allows for error maps to be easily applied to observable errors
+ *
+ * @param observableError an error from ZenObservable subscribe error callback
+ */
+
+function unwrapObservableError(observableError) {
+  var _a = observableError.error,
+      _b = __read((_a === void 0 ? {
+    errors: []
+  } : _a).errors, 1),
+      error = _b[0];
+
+  return error;
+}
+
 function getMutationErrorType(error) {
   return mapErrorToType(mutationErrorMap, error);
 }