@airtable/blocks 1.9.0 → 1.10.2-experimental-640bd10-20220211

package/dist/cjs/models/table_or_view_query_result.js

@@ -12,6 +12,8 @@ require("core-js/modules/es.array.concat");
 
 require("core-js/modules/es.array.filter");
 
+require("core-js/modules/es.array.includes");
+
 require("core-js/modules/es.array.iterator");
 
 require("core-js/modules/es.array.map");
@@ -24,6 +26,8 @@ require("core-js/modules/es.promise");
 
 require("core-js/modules/es.set");
 
+require("core-js/modules/es.string.includes");
+
 require("core-js/modules/es.string.starts-with");
 
 require("core-js/modules/web.dom-collections.for-each");
@@ -59,8 +63,14 @@ var _private_utils = require("../private_utils");
 
 var _error_utils = require("../error_utils");
 
+var _airtable_interface = require("../types/airtable_interface");
+
+var _block_query_spec = require("../types/block_query_spec");
+
 var _table = _interopRequireWildcard(require("./table"));
 
+var _view = _interopRequireDefault(require("./view"));
+
 var _record_query_result = _interopRequireDefault(require("./record_query_result"));
 
 var _record_coloring = require("./record_coloring");
@@ -97,6 +107,17 @@ function (_RecordQueryResult) {
 
   /** @internal */
 
+  /**
+   * Tracks a unique ID for each model query that has been loaded.
+   * Note that hyperbase may return a new model query ID even if the
+   * query itself is identical to a previous one. Having these unique
+   * IDs allows the SDK to maintain an accurate reference count of
+   * all model loads. _loadedSourceModelQueryIds must only be updated
+   * before unloading occurs.
+   *
+   * @internal
+   */
+
   /** @internal */
 
   /** @internal */
@@ -124,17 +145,6 @@ function (_RecordQueryResult) {
   /** @internal */
   // lazily generated set of record ids
 
-  /** @internal */
-  // NOTE: when a cellValue key (cellValues or cellValuesInField:) is watched, we want
-  // to make sure we watch the associated key on the table. However, we need to make
-  // sure that we only watch the table once for each key. Otherwise, the callbacks
-  // for each key will get called more than once for each change event. This is because
-  // Watchable stores references to callbacks for each key, and on each _onChange event
-  // calls each callback for that key. If we watch the table more than once, then we'll
-  // call _onChange more than once, and each callback will be called more than once, which
-  // is undesirable. Instead, we'll store watch counts for each key to make sure we only
-  // watch the table once.
-
   /** @internal */
 
   /** @internal */
@@ -146,7 +156,8 @@ function (_RecordQueryResult) {
     (0, _classCallCheck2.default)(this, TableOrViewQueryResult);
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(TableOrViewQueryResult).call(this, sdk, normalizedOpts));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_sourceModel", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_mostRecentSourceModelLoadPromise", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_mostRecentSourceModelLoadedPromise", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_loadedSourceModelQueryIds", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_table", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_fieldIdsSetToLoadOrNullIfAllFields", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_visList", void 0);
@@ -156,10 +167,156 @@ function (_RecordQueryResult) {
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_orderedGroups", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_loadedGroupLevels", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_recordIdsSet", null);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_cellValueKeyWatchCounts", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "__groupedRecordQueryResultPool", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_watchConfigByWatchableKey", {
+      // Handles if this is a prefix
+      [_record_query_result.default.WatchableCellValuesInFieldKeyPrefix]: (key, _ref) => {
+        var callOnRecordStoreWithKey = _ref.callOnRecordStoreWithKey;
+        var fieldId = key.substring(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix.length);
+
+        if (_this._fieldIdsSetToLoadOrNullIfAllFields && !(0, _private_utils.has)(_this._fieldIdsSetToLoadOrNullIfAllFields, fieldId)) {
+          throw (0, _error_utils.spawnError)("Can't watch or unwatch field because it wasn't included in RecordQueryResult fields: %s", fieldId);
+        }
+
+        callOnRecordStoreWithKey(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
+      },
+      [_record_query_result.default.WatchableKeys.cellValues]: (key, _ref2) => {
+        var callOnRecordStoreWithKey = _ref2.callOnRecordStoreWithKey;
+
+        if (_this._fieldIdsSetToLoadOrNullIfAllFields) {
+          for (var _i = 0, _Object$keys = Object.keys(_this._fieldIdsSetToLoadOrNullIfAllFields); _i < _Object$keys.length; _i++) {
+            var fieldId = _Object$keys[_i];
+            callOnRecordStoreWithKey(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
+          }
+        } else {
+          callOnRecordStoreWithKey(_record_query_result.default.WatchableKeys.cellValues);
+        }
+      },
+      [_record_query_result.default.WatchableKeys.groupLevels]: (key, _ref3) => {
+        var callOnViewDataStoreWithKey = _ref3.callOnViewDataStoreWithKey;
+        callOnViewDataStoreWithKey(_view_data_store.WatchableViewDataStoreKeys.groupLevels);
+      },
+      [_record_query_result.default.WatchableKeys.groups]: (key, _ref4) => {
+        var callOnViewDataStoreWithKey = _ref4.callOnViewDataStoreWithKey;
+        callOnViewDataStoreWithKey(_view_data_store.WatchableViewDataStoreKeys.groups);
+      }
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_unloadDataAsync", () => {
+      var viewDataStore, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, sort, field;
+
+      return _regenerator.default.async(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!_this._mostRecentSourceModelLoadedPromise) {
+                _context.next = 3;
+                break;
+              }
+
+              _context.next = 3;
+              return _regenerator.default.awrap(_this._mostRecentSourceModelLoadedPromise);
+
+            case 3:
+              // Unload all queries that were subscribed to the entire query
+              if (_this._sourceModel instanceof _table.default) {
+                _this._recordStore.unloadCellValuesForQueryIdsThatAreSubscribedToAllCells(_this._loadedSourceModelQueryIds);
+              } else {
+                // Even if the view is deleted, we can still unsubscribe from the cells
+                _this._recordStore.unloadViewDataStoreAndCellValuesWithQueryIds(_this._loadedSourceModelQueryIds);
+              }
+
+              _this._mostRecentSourceModelLoadedPromise = null;
+
+              if (_this._sourceModel instanceof _table.default) {
+                _this._recordStore.unwatch(_record_store.WatchableRecordStoreKeys.records, _this._onRecordsChanged, (0, _assertThisInitialized2.default)(_this));
+              } else {
+                if (!_this._sourceModel.isDeleted) {
+                  viewDataStore = _this._recordStore.getViewDataStore(_this._sourceModel.id);
+                  viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.visibleRecords, _this._onRecordsChanged, (0, _assertThisInitialized2.default)(_this));
+                  viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.groups, _this._onGroupsChanged, (0, _assertThisInitialized2.default)(_this));
+                  viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.groupLevels, _this._onGroupLevelsChanged, (0, _assertThisInitialized2.default)(_this));
+                }
+              }
+
+              _this._recordStore.unwatch(_this._cellValuesForSortWatchKeys, _this._onCellValuesForSortChanged, (0, _assertThisInitialized2.default)(_this));
+
+              _this._recordStore.unwatch(_this._cellValuesForGroupWatchKeys, _this._onCellValuesForGroupChanged, (0, _assertThisInitialized2.default)(_this));
+
+              _this._table.unwatch(_table.WatchableTableKeys.fields, _this._onTableFieldsChanged, (0, _assertThisInitialized2.default)(_this)); // If the table is deleted, can't call getFieldById on it below.
+
+
+              if (!(!_this._table.isDeleted && _this._sorts)) {
+                _context.next = 29;
+                break;
+              }
+
+              _iteratorNormalCompletion = true;
+              _didIteratorError = false;
+              _iteratorError = undefined;
+              _context.prev = 13;
+
+              for (_iterator = _this._sorts[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                sort = _step.value;
+                field = _this._table.getFieldByIdIfExists(sort.fieldId);
+
+                if (field) {
+                  field.unwatch('type', _this._onFieldConfigChanged, (0, _assertThisInitialized2.default)(_this));
+                  field.unwatch('options', _this._onFieldConfigChanged, (0, _assertThisInitialized2.default)(_this));
+                }
+              }
+
+              _context.next = 21;
+              break;
+
+            case 17:
+              _context.prev = 17;
+              _context.t0 = _context["catch"](13);
+              _didIteratorError = true;
+              _iteratorError = _context.t0;
+
+            case 21:
+              _context.prev = 21;
+              _context.prev = 22;
+
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+
+            case 24:
+              _context.prev = 24;
+
+              if (!_didIteratorError) {
+                _context.next = 27;
+                break;
+              }
+
+              throw _iteratorError;
+
+            case 27:
+              return _context.finish(24);
+
+            case 28:
+              return _context.finish(21);
+
+            case 29:
+              _this._unloadOrderedGroupsIfNeeded();
+
+              _this._visList = null;
+              _this._orderedRecordIds = null;
+              _this._recordIdsSet = null;
+
+              _this._table.__tableOrViewQueryResultPool.unregisterObjectForReuseStrong((0, _assertThisInitialized2.default)(_this));
+
+            case 34:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, null, null, [[13, 17, 21, 29], [22,, 24, 28]]);
+    });
     _this._sourceModel = sourceModel;
-    _this._mostRecentSourceModelLoadPromise = null;
+    _this._mostRecentSourceModelLoadedPromise = null;
+    _this._loadedSourceModelQueryIds = [];
     _this._table = normalizedOpts.table;
     var sorts = _this._normalizedOpts.sorts;
     _this._sorts = sorts !== null && sorts !== void 0 ? sorts : null; // TODO (SeanKeenan): Placeholder until we support groups from normalizedOpts
@@ -169,58 +326,57 @@ function (_RecordQueryResult) {
     _this._orderedRecordIds = null;
     _this._orderedGroups = null;
     _this._loadedGroupLevels = null;
-    _this._cellValueKeyWatchCounts = {};
     var fieldIdsSetToLoadOrNullIfAllFields = null;
 
     if (_this._normalizedOpts.fieldIdsOrNullIfAllFields) {
       fieldIdsSetToLoadOrNullIfAllFields = {};
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
 
       try {
-        for (var _iterator = _this._normalizedOpts.fieldIdsOrNullIfAllFields[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var fieldId = _step.value;
+        for (var _iterator2 = _this._normalizedOpts.fieldIdsOrNullIfAllFields[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var fieldId = _step2.value;
           fieldIdsSetToLoadOrNullIfAllFields[fieldId] = true;
         } // Need to load data for fields we're sorting by, even if
         // they're not explicitly requested in the `fields` opt.
 
       } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
           }
         } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
+          if (_didIteratorError2) {
+            throw _iteratorError2;
           }
         }
       }
 
       if (_this._sorts !== null) {
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
+        var _iteratorNormalCompletion3 = true;
+        var _didIteratorError3 = false;
+        var _iteratorError3 = undefined;
 
         try {
-          for (var _iterator2 = _this._sorts[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var sort = _step2.value;
+          for (var _iterator3 = _this._sorts[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            var sort = _step3.value;
             fieldIdsSetToLoadOrNullIfAllFields[sort.fieldId] = true;
           }
         } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
+            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+              _iterator3.return();
             }
           } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
+            if (_didIteratorError3) {
+              throw _iteratorError3;
             }
           }
         }
@@ -260,26 +416,26 @@ function (_RecordQueryResult) {
     value: function _getOrGenerateRecordIdsSet() {
       if (!this._recordIdsSet) {
         var recordIdsSet = {};
-        var _iteratorNormalCompletion3 = true;
-        var _didIteratorError3 = false;
-        var _iteratorError3 = undefined;
+        var _iteratorNormalCompletion4 = true;
+        var _didIteratorError4 = false;
+        var _iteratorError4 = undefined;
 
         try {
-          for (var _iterator3 = this.recordIds[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-            var recordId = _step3.value;
+          for (var _iterator4 = this.recordIds[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+            var recordId = _step4.value;
             recordIdsSet[recordId] = true;
           }
         } catch (err) {
-          _didIteratorError3 = true;
-          _iteratorError3 = err;
+          _didIteratorError4 = true;
+          _iteratorError4 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-              _iterator3.return();
+            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+              _iterator4.return();
             }
           } finally {
-            if (_didIteratorError3) {
-              throw _iteratorError3;
+            if (_didIteratorError4) {
+              throw _iteratorError4;
             }
           }
         }
@@ -296,85 +452,72 @@ function (_RecordQueryResult) {
      */
 
   }, {
-    key: "_incrementCellValueKeyWatchCountAndWatchIfNecessary",
-
-    /** @internal */
-    value: function _incrementCellValueKeyWatchCountAndWatchIfNecessary(key, watchCallback) {
-      if (!this._cellValueKeyWatchCounts[key]) {
-        this._cellValueKeyWatchCounts[key] = 0;
-
-        this._recordStore.watch(key, watchCallback, this);
-      }
-
-      this._cellValueKeyWatchCounts[key]++;
-    }
-    /** @internal */
-
-  }, {
-    key: "_decrementCellValueKeyWatchCountAndUnwatchIfPossible",
-    value: function _decrementCellValueKeyWatchCountAndUnwatchIfPossible(key, watchCallback) {
-      if (!this._cellValueKeyWatchCounts[key]) {
-        // Key isn't watched, so just skip it. This matches behavior of Watchable,
-        // where calling unwatch on a key that isn't watched just no-ops.
-        return;
-      }
-
-      this._cellValueKeyWatchCounts[key]--;
-
-      if (this._cellValueKeyWatchCounts[key] === 0) {
-        // We're down to zero watches for this key, so we can actually unwatch it now.
-        this._recordStore.unwatch(key, watchCallback, this);
+    key: "watch",
 
-        delete this._cellValueKeyWatchCounts[key];
-      }
-    }
     /** @inheritdoc */
-
-  }, {
-    key: "watch",
     value: function watch(keys, callback, context) {
       var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(TableOrViewQueryResult.prototype), "watch", this).call(this, keys, callback, context);
-      var _iteratorNormalCompletion4 = true;
-      var _didIteratorError4 = false;
-      var _iteratorError4 = undefined;
 
-      try {
-        for (var _iterator4 = validKeys[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-          var _key2 = _step4.value;
+      var callWatchOnRecordStoreWithKey = keyToWatch => {
+        this._recordStore.watchWithRecordQueryResult({
+          priority: _airtable_interface.BlockQueryCallbackPriority.BLOCK_CODE,
+          recordQueryResult: this,
+          keys: keyToWatch,
+          callbackForRegistration: callback,
+          context
+        });
+      };
 
-          if (_key2.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
-            var fieldId = _key2.substring(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix.length);
+      var callWatchOnViewDataStoreWithKey = keyToWatch => {
+        (0, _error_utils.invariant)(this._sourceModel instanceof _view.default, 'To watch %s you must be subscribed to a view', keyToWatch);
 
-            if (this._fieldIdsSetToLoadOrNullIfAllFields && !(0, _private_utils.has)(this._fieldIdsSetToLoadOrNullIfAllFields, fieldId)) {
-              throw (0, _error_utils.spawnError)("Can't watch field because it wasn't included in RecordQueryResult fields: %s", fieldId);
-            }
+        var viewDataStore = this._recordStore.getViewDataStore(this._sourceModel.id);
 
-            this._incrementCellValueKeyWatchCountAndWatchIfNecessary(_key2, this._onCellValuesInFieldChanged);
-          }
+        viewDataStore.watch(keyToWatch, callback, context);
+      };
+
+      var callWatchFunctions = {
+        callOnRecordStoreWithKey: callWatchOnRecordStoreWithKey,
+        callOnViewDataStoreWithKey: callWatchOnViewDataStoreWithKey
+      };
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
 
-          if (_key2 === _record_query_result.default.WatchableKeys.cellValues) {
-            if (this._fieldIdsSetToLoadOrNullIfAllFields) {
-              for (var _i = 0, _Object$keys = Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields); _i < _Object$keys.length; _i++) {
-                var _fieldId = _Object$keys[_i];
+      try {
+        for (var _iterator5 = validKeys[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var _key2 = _step5.value;
+
+          // There are two watch systems:
+          // 1) the query-based watch
+          // 2) the non-query-based watch (through super)
+          // Depending on the key, we may use one or both of the systems.
+          // The non-query based watch system is used when when:
+          //  - watching: records, recordIds
+          //  - _loadDataAsync calls all watch keys on initial load
+          //  - Support for _watchRecordColorsIfNeeded
+          // For all changes to the remaining keys - the query-based system is used.
+          if (_key2.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
+            this._watchConfigByWatchableKey[_record_query_result.default.WatchableCellValuesInFieldKeyPrefix](_key2, callWatchFunctions);
+          } else {
+            var functionToCallWithKey = this._watchConfigByWatchableKey[_key2];
 
-                this._incrementCellValueKeyWatchCountAndWatchIfNecessary(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + _fieldId, this._onCellValuesChanged);
-              }
-            } else {
-              this._incrementCellValueKeyWatchCountAndWatchIfNecessary(_key2, this._onCellValuesChanged);
+            if (functionToCallWithKey) {
+              functionToCallWithKey(_key2, callWatchFunctions);
             }
           }
         }
       } catch (err) {
-        _didIteratorError4 = true;
-        _iteratorError4 = err;
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-            _iterator4.return();
+          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+            _iterator5.return();
           }
         } finally {
-          if (_didIteratorError4) {
-            throw _iteratorError4;
+          if (_didIteratorError5) {
+            throw _iteratorError5;
           }
         }
       }
@@ -387,41 +530,53 @@ function (_RecordQueryResult) {
     key: "unwatch",
     value: function unwatch(keys, callback, context) {
       var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(TableOrViewQueryResult.prototype), "unwatch", this).call(this, keys, callback, context);
-      var _iteratorNormalCompletion5 = true;
-      var _didIteratorError5 = false;
-      var _iteratorError5 = undefined;
+
+      var callUnwatchOnRecordStoreWithKey = keysToUnwatch => {
+        this._recordStore.unwatch(keysToUnwatch, callback, context);
+      };
+
+      var callUnwatchOnViewDataStoreWithKey = keyToWatch => {
+        (0, _error_utils.invariant)(this._sourceModel instanceof _view.default, 'To watch %s you must be subscribed to a view', keyToWatch);
+
+        var viewDataStore = this._recordStore.getViewDataStore(this._sourceModel.id);
+
+        viewDataStore.unwatch(keyToWatch, callback, context);
+      };
+
+      var callWatchFunctions = {
+        callOnRecordStoreWithKey: callUnwatchOnRecordStoreWithKey,
+        callOnViewDataStoreWithKey: callUnwatchOnViewDataStoreWithKey
+      };
+      var _iteratorNormalCompletion6 = true;
+      var _didIteratorError6 = false;
+      var _iteratorError6 = undefined;
 
       try {
-        for (var _iterator5 = validKeys[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-          var _key3 = _step5.value;
+        for (var _iterator6 = validKeys[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+          var _key3 = _step6.value;
 
+          // This is the inverse of the watch logic
           if (_key3.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
-            this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(_key3, this._onCellValuesInFieldChanged);
-          }
-
-          if (_key3 === _record_query_result.default.WatchableKeys.cellValues) {
-            if (this._fieldIdsSetToLoadOrNullIfAllFields) {
-              for (var _i2 = 0, _Object$keys2 = Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields); _i2 < _Object$keys2.length; _i2++) {
-                var fieldId = _Object$keys2[_i2];
+            this._watchConfigByWatchableKey[_record_query_result.default.WatchableCellValuesInFieldKeyPrefix](_key3, callWatchFunctions);
+          } else {
+            var functionToCallWithKey = this._watchConfigByWatchableKey[_key3];
 
-                this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, this._onCellValuesChanged);
-              }
-            } else {
-              this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(_key3, this._onCellValuesChanged);
+            if (functionToCallWithKey) {
+              functionToCallWithKey(_key3, callWatchFunctions);
             }
           }
         }
       } catch (err) {
-        _didIteratorError5 = true;
-        _iteratorError5 = err;
+        _didIteratorError6 = true;
+        _iteratorError6 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-            _iterator5.return();
+          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+            _iterator6.return();
           }
         } finally {
-          if (_didIteratorError5) {
-            throw _iteratorError5;
+          if (_didIteratorError6) {
+            throw _iteratorError6;
           }
         }
       }
@@ -433,45 +588,54 @@ function (_RecordQueryResult) {
   }, {
     key: "loadDataAsync",
     value: function loadDataAsync() {
-      var sourceModelLoadPromise, cellValuesInFieldsLoadPromise;
-      return _regenerator.default.async(function loadDataAsync$(_context) {
+      var sourceModelLoadPromise, fieldIdsToLoadOrNullIfAllFields, allFieldsToQuery, metadataFieldId, sourceModelLoadedPromise;
+      return _regenerator.default.async(function loadDataAsync$(_context2) {
         while (1) {
-          switch (_context.prev = _context.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
               if (!this._sourceModel.isDeleted) {
-                _context.next = 2;
+                _context2.next = 2;
                 break;
               }
 
               throw this._spawnErrorForDeletion();
 
             case 2:
-              if (this._fieldIdsSetToLoadOrNullIfAllFields) {
-                cellValuesInFieldsLoadPromise = this._recordStore.loadCellValuesInFieldIdsAsync(Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields));
-              } else {
-                // Load all fields.
-                cellValuesInFieldsLoadPromise = this._recordStore.loadDataAsync();
-              }
+              fieldIdsToLoadOrNullIfAllFields = this._fieldIdsSetToLoadOrNullIfAllFields ? Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields) : null;
 
               if (this._sourceModel instanceof _table.default) {
-                if (this._fieldIdsSetToLoadOrNullIfAllFields) {
-                  sourceModelLoadPromise = this._recordStore.loadRecordMetadataAsync();
+                if (fieldIdsToLoadOrNullIfAllFields) {
+                  // TODO: (#proj-blocks-sdk-record-limits) Do we need to load the recordData metadata field
+                  // in order to load any record data? If we do - this should be encapsulated entirely
+                  // inside of the RecordStore in publicAirtableInterface.
+                  // (should the queryModel be able to specify metadata requirements?)
+                  allFieldsToQuery = fieldIdsToLoadOrNullIfAllFields;
+                  metadataFieldId = this._recordStore._getFieldIdForCausingRecordMetadataToLoad();
+
+                  if (!allFieldsToQuery.includes(metadataFieldId)) {
+                    allFieldsToQuery = [...allFieldsToQuery, metadataFieldId];
+                  }
+
+                  sourceModelLoadPromise = this._recordStore.loadAllCellValuesInFieldIdsAsync(allFieldsToQuery);
                 } else {
-                  // table.loadDataAsync is a superset of loadRecordMetadataAsync,
-                  // so no need to load record metadata again.
-                  sourceModelLoadPromise = null;
+                  // Load all fields.
+                  sourceModelLoadPromise = this._recordStore.loadAllCellValuesAsync();
                 }
               } else {
-                sourceModelLoadPromise = this._recordStore.getViewDataStore(this._sourceModel.id).loadDataAsync();
-              }
+                sourceModelLoadPromise = this._recordStore.loadViewDataStoreAndCellValuesForFieldIdsAsync(this._sourceModel.id, fieldIdsToLoadOrNullIfAllFields);
+              } // See comment on _loadedSourceModelQueryIds declaration for details
+
 
-              this._mostRecentSourceModelLoadPromise = Promise.all([sourceModelLoadPromise, cellValuesInFieldsLoadPromise, this._loadRecordColorsAsync()]);
-              _context.next = 7;
+              sourceModelLoadedPromise = sourceModelLoadPromise.then(sourceModelQueryId => {
+                this._loadedSourceModelQueryIds.push(sourceModelQueryId);
+              });
+              this._mostRecentSourceModelLoadedPromise = Promise.all([sourceModelLoadedPromise, this._loadRecordColorsAsync()]);
+              _context2.next = 8;
               return _regenerator.default.awrap((0, _get2.default)((0, _getPrototypeOf2.default)(TableOrViewQueryResult.prototype), "loadDataAsync", this).call(this));
 
-            case 7:
+            case 8:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
         }
       }, null, this);
@@ -487,26 +651,26 @@ function (_RecordQueryResult) {
 
       var fieldIds = this._normalizedOpts.fieldIdsOrNullIfAllFields || this._table.fields.map(field => field.id);
 
-      var _iteratorNormalCompletion6 = true;
-      var _didIteratorError6 = false;
-      var _iteratorError6 = undefined;
+      var _iteratorNormalCompletion7 = true;
+      var _didIteratorError7 = false;
+      var _iteratorError7 = undefined;
 
       try {
-        for (var _iterator6 = fieldIds[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
-          var fieldId = _step6.value;
+        for (var _iterator7 = fieldIds[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+          var fieldId = _step7.value;
           changedKeys.push(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
         }
       } catch (err) {
-        _didIteratorError6 = true;
-        _iteratorError6 = err;
+        _didIteratorError7 = true;
+        _iteratorError7 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-            _iterator6.return();
+          if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+            _iterator7.return();
           }
         } finally {
-          if (_didIteratorError6) {
-            throw _iteratorError6;
+          if (_didIteratorError7) {
+            throw _iteratorError7;
           }
         }
       }
@@ -518,55 +682,79 @@ function (_RecordQueryResult) {
   }, {
     key: "_loadDataAsync",
     value: function _loadDataAsync() {
-      var viewDataStore, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, sort, field;
+      var viewDataStore, _iteratorNormalCompletion8, _didIteratorError8, _iteratorError8, _iterator8, _step8, sort, field;
 
-      return _regenerator.default.async(function _loadDataAsync$(_context2) {
+      return _regenerator.default.async(function _loadDataAsync$(_context3) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
               this._table.__tableOrViewQueryResultPool.registerObjectForReuseStrong(this);
 
-              (0, _error_utils.invariant)(this._mostRecentSourceModelLoadPromise, 'No source model load promises');
-              _context2.next = 4;
-              return _regenerator.default.awrap(this._mostRecentSourceModelLoadPromise);
+              (0, _error_utils.invariant)(this._mostRecentSourceModelLoadedPromise, 'No source model load promises');
+              _context3.next = 4;
+              return _regenerator.default.awrap(this._mostRecentSourceModelLoadedPromise);
 
             case 4:
               if (this._sorts) {
                 this._replaceVisList();
               }
 
-              this._orderedRecordIds = this._generateOrderedRecordIds();
-              this._orderedGroups = this._generateAndLoadOrderedGroups(); // The server provided value and developer supplied value are the same, no conversion needed
+              this._orderedRecordIds = this._generateOrderedRecordIds(); // Ensure that groups are not loaded
 
-              this._loadedGroupLevels = this._sourceModelGroupLevels;
+              this._orderedGroups = null; // The server provided value and developer supplied value are the same, no conversion needed
+
+              this._loadedGroupLevels = null;
 
               if (this._sourceModel instanceof _table.default) {
-                this._recordStore.watch(_record_store.WatchableRecordStoreKeys.records, this._onRecordsChanged, this);
+                // _onRecordsChanged actually just transforms data and passes to
+                // user provided watches
+                this._recordStore.watchWithRecordQueryResult({
+                  priority: _airtable_interface.BlockQueryCallbackPriority.BLOCK_CODE,
+                  recordQueryResult: this,
+                  keys: _record_store.WatchableRecordStoreKeys.records,
+                  callbackForRegistration: this._onRecordsChanged,
+                  context: this
+                });
               } else {
-                viewDataStore = this._recordStore.getViewDataStore(this._sourceModel.id);
-                viewDataStore.watch(_view_data_store.WatchableViewDataStoreKeys.visibleRecords, this._onRecordsChanged, this);
-                viewDataStore.watch(_view_data_store.WatchableViewDataStoreKeys.groups, this._onGroupsChanged, this);
-                viewDataStore.watch(_view_data_store.WatchableViewDataStoreKeys.groupLevels, this._onGroupLevelsChanged, this);
-              }
+                viewDataStore = this._recordStore.getViewDataStore(this._sourceModel.id); // _onRecordsChanged actually just transforms data and passes to
+                // user provided watches
 
-              this._recordStore.watch(this._cellValuesForSortWatchKeys, this._onCellValuesForSortChanged, this);
-
-              this._recordStore.watch(this._cellValuesForGroupWatchKeys, this._onCellValuesForGroupChanged, this);
+                viewDataStore.watch(_view_data_store.WatchableViewDataStoreKeys.visibleRecords, this._onRecordsChanged, this);
+                viewDataStore.watchFromSdk(_view_data_store.WatchableViewDataStoreKeys.groups, this._onGroupsChanged, this);
+                viewDataStore.watchFromSdk(_view_data_store.WatchableViewDataStoreKeys.groupLevels, this._onGroupLevelsChanged, this);
+              } // This only watches cell values if a sort is specified
+
+
+              this._recordStore.watchWithRecordQueryResult({
+                priority: _airtable_interface.BlockQueryCallbackPriority.SDK,
+                recordQueryResult: this,
+                keys: this._cellValuesForSortWatchKeys,
+                callbackForRegistration: this._onCellValuesForSortChanged,
+                context: this
+              });
+
+              this._recordStore.watchWithRecordQueryResult({
+                priority: _airtable_interface.BlockQueryCallbackPriority.SDK,
+                recordQueryResult: this,
+                keys: this._cellValuesForGroupWatchKeys,
+                callbackForRegistration: this._onCellValuesForGroupChanged,
+                context: this
+              });
 
               this._table.watch(_table.WatchableTableKeys.fields, this._onTableFieldsChanged, this);
 
               if (!this._sorts) {
-                _context2.next = 32;
+                _context3.next = 32;
                 break;
               }
 
-              _iteratorNormalCompletion7 = true;
-              _didIteratorError7 = false;
-              _iteratorError7 = undefined;
-              _context2.prev = 16;
+              _iteratorNormalCompletion8 = true;
+              _didIteratorError8 = false;
+              _iteratorError8 = undefined;
+              _context3.prev = 16;
 
-              for (_iterator7 = this._sorts[Symbol.iterator](); !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-                sort = _step7.value;
+              for (_iterator8 = this._sorts[Symbol.iterator](); !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+                sort = _step8.value;
                 field = this._table.getFieldByIdIfExists(sort.fieldId);
 
                 if (field) {
@@ -575,45 +763,45 @@ function (_RecordQueryResult) {
                 }
               }
 
-              _context2.next = 24;
+              _context3.next = 24;
               break;
 
             case 20:
-              _context2.prev = 20;
-              _context2.t0 = _context2["catch"](16);
-              _didIteratorError7 = true;
-              _iteratorError7 = _context2.t0;
+              _context3.prev = 20;
+              _context3.t0 = _context3["catch"](16);
+              _didIteratorError8 = true;
+              _iteratorError8 = _context3.t0;
 
             case 24:
-              _context2.prev = 24;
-              _context2.prev = 25;
+              _context3.prev = 24;
+              _context3.prev = 25;
 
-              if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-                _iterator7.return();
+              if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+                _iterator8.return();
               }
 
             case 27:
-              _context2.prev = 27;
+              _context3.prev = 27;
 
-              if (!_didIteratorError7) {
-                _context2.next = 30;
+              if (!_didIteratorError8) {
+                _context3.next = 30;
                 break;
               }
 
-              throw _iteratorError7;
+              throw _iteratorError8;
 
             case 30:
-              return _context2.finish(27);
+              return _context3.finish(27);
 
             case 31:
-              return _context2.finish(24);
+              return _context3.finish(24);
 
             case 32:
-              return _context2.abrupt("return", this._getChangedKeysOnLoad());
+              return _context3.abrupt("return", this._getChangedKeysOnLoad());
 
             case 33:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
         }
       }, null, this, [[16, 20, 24, 32], [25,, 27, 31]]);
@@ -625,21 +813,9 @@ function (_RecordQueryResult) {
     value: function unloadData() {
       (0, _get2.default)((0, _getPrototypeOf2.default)(TableOrViewQueryResult.prototype), "unloadData", this).call(this);
 
-      if (this._sourceModel instanceof _table.default) {
-        if (this._fieldIdsSetToLoadOrNullIfAllFields) {
-          this._recordStore.unloadRecordMetadata();
-        } else {
-          this._recordStore.unloadData();
-        }
-      } else {
-        // If the view is deleted, we can't get a data store for it.
-        if (!this._sourceModel.isDeleted) {
-          this._recordStore.getViewDataStore(this._sourceModel.id).unloadData();
-        }
-      }
-
-      if (this._fieldIdsSetToLoadOrNullIfAllFields) {
-        this._recordStore.unloadCellValuesInFieldIds(Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields));
+      if (this._loadedSourceModelQueryIds.length === 0) {
+        // Source model must have loaded a queryId to unload
+        return;
       }
 
       this._unloadRecordColors();
@@ -649,119 +825,32 @@ function (_RecordQueryResult) {
   }, {
     key: "_unloadData",
     value: function _unloadData() {
-      this._mostRecentSourceModelLoadPromise = null;
-
-      if (this._sourceModel instanceof _table.default) {
-        this._recordStore.unwatch(_record_store.WatchableRecordStoreKeys.records, this._onRecordsChanged, this);
-      } else {
-        if (!this._sourceModel.isDeleted) {
-          var viewDataStore = this._recordStore.getViewDataStore(this._sourceModel.id);
-
-          viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.visibleRecords, this._onRecordsChanged, this);
-          viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.groups, this._onGroupsChanged, this);
-          viewDataStore.unwatch(_view_data_store.WatchableViewDataStoreKeys.groupLevels, this._onGroupLevelsChanged, this);
-        }
-      }
-
-      this._recordStore.unwatch(this._cellValuesForSortWatchKeys, this._onCellValuesForSortChanged, this);
-
-      this._recordStore.unwatch(this._cellValuesForGroupWatchKeys, this._onCellValuesForGroupChanged, this);
-
-      this._table.unwatch(_table.WatchableTableKeys.fields, this._onTableFieldsChanged, this); // If the table is deleted, can't call getFieldById on it below.
-
-
-      if (!this._table.isDeleted && this._sorts) {
-        var _iteratorNormalCompletion8 = true;
-        var _didIteratorError8 = false;
-        var _iteratorError8 = undefined;
-
-        try {
-          for (var _iterator8 = this._sorts[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
-            var sort = _step8.value;
-
-            var field = this._table.getFieldByIdIfExists(sort.fieldId);
-
-            if (field) {
-              field.unwatch('type', this._onFieldConfigChanged, this);
-              field.unwatch('options', this._onFieldConfigChanged, this);
-            }
-          }
-        } catch (err) {
-          _didIteratorError8 = true;
-          _iteratorError8 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
-              _iterator8.return();
-            }
-          } finally {
-            if (_didIteratorError8) {
-              throw _iteratorError8;
-            }
-          }
-        }
-      }
-
-      this._unloadOrderedGroupsIfNeeded();
-
-      this._visList = null;
-      this._orderedRecordIds = null;
-      this._recordIdsSet = null;
-
-      this._table.__tableOrViewQueryResultPool.unregisterObjectForReuseStrong(this);
+      (0, _private_utils.fireAndForgetPromise)(this._unloadDataAsync);
     }
-    /** @internal */
-
   }, {
     key: "_addRecordIdsToVisList",
+
+    /** @internal */
     value: function _addRecordIdsToVisList(recordIds) {
       var visList = this._visList;
       (0, _error_utils.invariant)(visList, 'No vis list');
-      var _iteratorNormalCompletion9 = true;
-      var _didIteratorError9 = false;
-      var _iteratorError9 = undefined;
-
-      try {
-        for (var _iterator9 = recordIds[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
-          var recordId = _step9.value;
-
-          var record = this._recordStore.getRecordByIdIfExists(recordId);
-
-          (0, _error_utils.invariant)(record, 'Record missing in table');
-          visList.addRecordData(record._data);
-        }
-      } catch (err) {
-        _didIteratorError9 = true;
-        _iteratorError9 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
-            _iterator9.return();
-          }
-        } finally {
-          if (_didIteratorError9) {
-            throw _iteratorError9;
-          }
-        }
-      }
+      visList.addRecordIds(recordIds);
     }
     /** @internal */
 
   }, {
     key: "_onGroupLevelsChanged",
     value: function _onGroupLevelsChanged(model, key, updates) {
-      this._loadedGroupLevels = this._sourceModelGroupLevels;
-
-      this._unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches();
+      this._loadedGroupLevels = null;
 
-      this._onChange(_record_query_result.default.WatchableKeys.groupLevels);
+      this._unloadGroups();
     }
     /** @internal */
 
   }, {
     key: "_onGroupsChanged",
     value: function _onGroupsChanged(model, key, updates) {
-      this._unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches();
+      this._unloadGroups();
     }
     /** @internal */
 
@@ -784,7 +873,11 @@ function (_RecordQueryResult) {
           addedRecordIds: _addedRecordIds,
           removedRecordIds: _removedRecordIds
         };
-      }
+      } // We never need to handle an initial empty update coming from record_store
+      // since it does not issue empty initial updates.
+      // Keep the if statement for type safety. Invariant would also work, but is riskier.
+      // istanbul ignore if
+
 
       if (!updates) {
         // If there are no updates, do nothing, since we'll handle the initial
@@ -811,50 +904,50 @@ function (_RecordQueryResult) {
       }
 
       if (this._recordIdsSet) {
-        var _iteratorNormalCompletion10 = true;
-        var _didIteratorError10 = false;
-        var _iteratorError10 = undefined;
+        var _iteratorNormalCompletion9 = true;
+        var _didIteratorError9 = false;
+        var _iteratorError9 = undefined;
 
         try {
-          for (var _iterator10 = addedRecordIds[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
-            var recordId = _step10.value;
+          for (var _iterator9 = addedRecordIds[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
+            var recordId = _step9.value;
             this._recordIdsSet[recordId] = true;
           }
         } catch (err) {
-          _didIteratorError10 = true;
-          _iteratorError10 = err;
+          _didIteratorError9 = true;
+          _iteratorError9 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
-              _iterator10.return();
+            if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+              _iterator9.return();
             }
           } finally {
-            if (_didIteratorError10) {
-              throw _iteratorError10;
+            if (_didIteratorError9) {
+              throw _iteratorError9;
             }
           }
         }
 
-        var _iteratorNormalCompletion11 = true;
-        var _didIteratorError11 = false;
-        var _iteratorError11 = undefined;
+        var _iteratorNormalCompletion10 = true;
+        var _didIteratorError10 = false;
+        var _iteratorError10 = undefined;
 
         try {
-          for (var _iterator11 = removedRecordIds[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
-            var _recordId = _step11.value;
+          for (var _iterator10 = removedRecordIds[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+            var _recordId = _step10.value;
             this._recordIdsSet[_recordId] = undefined;
           }
         } catch (err) {
-          _didIteratorError11 = true;
-          _iteratorError11 = err;
+          _didIteratorError10 = true;
+          _iteratorError10 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
-              _iterator11.return();
+            if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+              _iterator10.return();
             }
           } finally {
-            if (_didIteratorError11) {
-              throw _iteratorError11;
+            if (_didIteratorError10) {
+              throw _iteratorError10;
             }
           }
         }
@@ -883,6 +976,10 @@ function (_RecordQueryResult) {
   }, {
     key: "_onCellValuesForSortChanged",
     value: function _onCellValuesForSortChanged(recordStore, key, recordIds, fieldId) {
+      // We never need to handle an initial empty update coming from record_store
+      // since it does not issue empty initial updates.
+      // Keep the if statement for type safety. Invariant would also work, but is riskier.
+      // istanbul ignore if
       if (!recordIds || !fieldId) {
         // If there are no updates, do nothing, since we'll handle the initial
         // callback when the record set is loaded (and we don't want to fire
@@ -948,13 +1045,13 @@ function (_RecordQueryResult) {
       // deleted and then undeleted.
 
       var wereAnyFieldsCreatedOrDeleted = false;
-      var _iteratorNormalCompletion12 = true;
-      var _didIteratorError12 = false;
-      var _iteratorError12 = undefined;
+      var _iteratorNormalCompletion11 = true;
+      var _didIteratorError11 = false;
+      var _iteratorError11 = undefined;
 
       try {
-        for (var _iterator12 = addedFieldIds[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
-          var fieldId = _step12.value;
+        for (var _iterator11 = addedFieldIds[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
+          var fieldId = _step11.value;
 
           // If a field that we rely on was created (i.e. it was undeleted), we need to
           // make sure we're watching it's config.
@@ -971,16 +1068,16 @@ function (_RecordQueryResult) {
         // istanbul ignore else
 
       } catch (err) {
-        _didIteratorError12 = true;
-        _iteratorError12 = err;
+        _didIteratorError11 = true;
+        _iteratorError11 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
-            _iterator12.return();
+          if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
+            _iterator11.return();
           }
         } finally {
-          if (_didIteratorError12) {
-            throw _iteratorError12;
+          if (_didIteratorError11) {
+            throw _iteratorError11;
           }
         }
       }
@@ -1010,34 +1107,6 @@ function (_RecordQueryResult) {
     }
     /** @internal */
 
-  }, {
-    key: "_onCellValuesChanged",
-    value: function _onCellValuesChanged(table, key, updates) {
-      if (!updates) {
-        // If there are no updates, do nothing, since we'll handle the initial
-        // callback when the record set is loaded (and we don't want to fire
-        // a cellValues change twice with no data).
-        return;
-      }
-
-      this._onChange(_record_query_result.default.WatchableKeys.cellValues, updates);
-    }
-    /** @internal */
-
-  }, {
-    key: "_onCellValuesInFieldChanged",
-    value: function _onCellValuesInFieldChanged(table, key, recordIds, fieldId) {
-      if (!recordIds && !fieldId) {
-        // If there are no updates, do nothing, since we'll handle the initial
-        // callback when the record set is loaded (and we don't want to fire
-        // a cellValuesInField change twice with no data).
-        return;
-      }
-
-      this._onChange(key, recordIds, fieldId);
-    }
-    /** @internal */
-
   }, {
     key: "_generateOrderedRecordIds",
     value: function _generateOrderedRecordIds() {
@@ -1055,7 +1124,6 @@ function (_RecordQueryResult) {
     value: function _generateAndLoadOrderedGroups() {
       // istanbul ignore next
       if (this._groupLevels) {
-        (0, _error_utils.invariant)(this._visList, 'Cannot generate record ids without a vis list');
         throw (0, _error_utils.spawnError)('custom group configs not supported');
       } else {
         // Get the group from the view itself
@@ -1081,26 +1149,26 @@ function (_RecordQueryResult) {
     key: "_unloadOrderedGroupsIfNeeded",
     value: function _unloadOrderedGroupsIfNeeded() {
       if (this._orderedGroups) {
-        var _iteratorNormalCompletion13 = true;
-        var _didIteratorError13 = false;
-        var _iteratorError13 = undefined;
+        var _iteratorNormalCompletion12 = true;
+        var _didIteratorError12 = false;
+        var _iteratorError12 = undefined;
 
         try {
-          for (var _iterator13 = this._orderedGroups[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
-            var group = _step13.value;
+          for (var _iterator12 = this._orderedGroups[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+            var group = _step12.value;
             group.unloadData();
           }
         } catch (err) {
-          _didIteratorError13 = true;
-          _iteratorError13 = err;
+          _didIteratorError12 = true;
+          _iteratorError12 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
-              _iterator13.return();
+            if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+              _iterator12.return();
             }
           } finally {
-            if (_didIteratorError13) {
-              throw _iteratorError13;
+            if (_didIteratorError12) {
+              throw _iteratorError12;
             }
           }
         }
@@ -1108,24 +1176,21 @@ function (_RecordQueryResult) {
     }
     /**
      * If groupings change then some groups will need to be created, and some removed
-     * This (TODO: will) handle the diffing necessary to unload, and reload only the changed groups.
-     * Also triggers the WatchableKeys.group, as by necessity this will have changed.
+     * Triggers the WatchableKeys.group, as by necessity this will have changed.
+     * TODO: This _should_ handle the diffing necessary to unload, and reload only the changed groups.
      *
      * @internal
      */
     // TODO: (SeanKeenan) Properly diff and only unload groups that need to be unloaded
     // In the meantime it's not too expensive to just unload everything, and GroupedRecordQueryResults
     // don't yet properly watch changes relevant to updating, so this isn't too bad.
-    // (They do invalidate their recordId caches, which is some very cheap work that we could remove)
 
   }, {
-    key: "_unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches",
-    value: function _unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches() {
+    key: "_unloadGroups",
+    value: function _unloadGroups() {
       this._unloadOrderedGroupsIfNeeded();
 
-      this._orderedGroups = this._generateAndLoadOrderedGroups();
-
-      this._onChange(_record_query_result.default.WatchableKeys.groups);
+      this._orderedGroups = null;
     }
     /** @internal */
 
@@ -1133,15 +1198,14 @@ function (_RecordQueryResult) {
     key: "_replaceVisList",
     value: function _replaceVisList() {
       var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
 
-      var recordDatas = this._sourceModelRecords.map(record => record._data);
+      var recordIds = this._sourceModelRecords.map(record => record.id);
 
       var fieldDatas = this._table.fields.map(field => field._data);
 
       var filteredSorts = this._getSortsWithDeletedFieldsFiltered();
 
-      this._visList = airtableInterface.createVisList(appInterface, recordDatas, fieldDatas, filteredSorts);
+      this._visList = airtableInterface.createVisListWithRecordIds(recordIds, fieldDatas, filteredSorts, this._table.id);
     }
     /** @internal */
 
@@ -1167,6 +1231,31 @@ function (_RecordQueryResult) {
       var sourceModelName = this._sourceModel instanceof _table.default ? 'table' : 'view';
       return (0, _error_utils.spawnError)("RecordQueryResult's underlying %s has been deleted", sourceModelName);
     }
+    /** @internal */
+
+  }, {
+    key: "__constructQuerySpecForBlockFieldSelectionSpec",
+    value: function __constructQuerySpecForBlockFieldSelectionSpec(fieldSelection) {
+      if (this._sourceModel instanceof _view.default) {
+        return {
+          sourceType: _block_query_spec.BlockQuerySourceType.VIEW,
+          sourceTableId: this._table.id,
+          sourceViewId: this._sourceModel.id,
+          recordSelection: {
+            fieldSelection
+          },
+          viewMetadataSelection: {}
+        };
+      } else {
+        return {
+          sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
+          sourceTableId: this._table.id,
+          recordSelection: {
+            fieldSelection
+          }
+        };
+      }
+    }
   }, {
     key: "_dataOrNullIfDeleted",
     get: function get() {
@@ -1175,9 +1264,7 @@ function (_RecordQueryResult) {
       }
 
       return {
-        recordIds: this._orderedRecordIds,
-        groups: this._orderedGroups,
-        groupLevels: this._loadedGroupLevels
+        recordIds: this._orderedRecordIds
       };
     }
     /** @internal */
@@ -1231,8 +1318,10 @@ function (_RecordQueryResult) {
       var recordIds = this._data.recordIds; // Throws when the model has been deleted.
 
       (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
-      (0, _error_utils.invariant)(recordIds, 'No recordIds');
-      return recordIds;
+      (0, _error_utils.invariant)(recordIds, 'No recordIds'); // TODO: (#proj-blocks-sdk-record-limits) Change this to readonly upon the
+      // next breaking change.
+
+      return [...recordIds];
     }
     /**
      * The ordered GroupedRecordQueryResult's in this RecordQueryResult.
@@ -1245,12 +1334,19 @@ function (_RecordQueryResult) {
   }, {
     key: "groups",
     get: function get() {
+      var _this$_orderedGroups;
+
       // The following statements have been carefully sequenced to ensure
       // that when this method fails, it reports the most salient error.
-      var groups = this._data.groups; // Throws when the model has been deleted.
+      (0, _error_utils.invariant)(this._data, 'RecordQueryResult must not be deleted'); // Throws when the model has been deleted.
 
       (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
-      return groups !== null && groups !== void 0 ? groups : null;
+
+      if (!this._orderedGroups) {
+        this._orderedGroups = this._generateAndLoadOrderedGroups();
+      }
+
+      return (_this$_orderedGroups = this._orderedGroups) !== null && _this$_orderedGroups !== void 0 ? _this$_orderedGroups : null;
     }
     /**
      * The GroupLevels in this RecordQueryResult.
@@ -1263,10 +1359,15 @@ function (_RecordQueryResult) {
   }, {
     key: "groupLevels",
     get: function get() {
-      var groupLevels = this._data.groupLevels; // Throws when the model has been deleted.
+      (0, _error_utils.invariant)(this._data, 'RecordQueryResult must not be deleted'); // Throws when the model has been deleted.
 
       (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
-      return groupLevels ? groupLevels.map(singleLevel => _objectSpread({}, singleLevel, {
+
+      if (!this._loadedGroupLevels) {
+        this._loadedGroupLevels = this._sourceModelGroupLevels;
+      }
+
+      return this._loadedGroupLevels ? this._loadedGroupLevels.map(singleLevel => _objectSpread({}, singleLevel, {
         field: this.parentTable.getFieldById(singleLevel.fieldId)
       })) : null;
     }
@@ -1281,13 +1382,13 @@ function (_RecordQueryResult) {
         // using RecordQueryResult) if the user had to manually watch for deletion
         // on all the fields and recreate the RecordQueryResult.
 
-        var _iteratorNormalCompletion14 = true;
-        var _didIteratorError14 = false;
-        var _iteratorError14 = undefined;
+        var _iteratorNormalCompletion13 = true;
+        var _didIteratorError13 = false;
+        var _iteratorError13 = undefined;
 
         try {
-          for (var _iterator14 = fieldIdsOrNullIfAllFields[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
-            var fieldId = _step14.value;
+          for (var _iterator13 = fieldIdsOrNullIfAllFields[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
+            var fieldId = _step13.value;
 
             var field = this._table.getFieldByIdIfExists(fieldId);
 
@@ -1296,16 +1397,16 @@ function (_RecordQueryResult) {
             }
           }
         } catch (err) {
-          _didIteratorError14 = true;
-          _iteratorError14 = err;
+          _didIteratorError13 = true;
+          _iteratorError13 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
-              _iterator14.return();
+            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
+              _iterator13.return();
             }
           } finally {
-            if (_didIteratorError14) {
-              throw _iteratorError14;
+            if (_didIteratorError13) {
+              throw _iteratorError13;
             }
           }
         }
@@ -1359,6 +1460,12 @@ function (_RecordQueryResult) {
     get: function get() {
       return this._sourceModel instanceof _table.default ? this._recordStore.records : this._recordStore.getViewDataStore(this._sourceModel.id).visibleRecords;
     }
+    /**
+     * This is just a helper structure to better colocate watch and unwatch logic
+     *
+     * @internal
+     */
+
   }]);
   return TableOrViewQueryResult;
 }(_record_query_result.default);