@airtable/blocks 1.9.0-experimental-5565d56-20211029 → 1.10.1

package/dist/cjs/models/table_or_view_query_result.js

@@ -12,8 +12,6 @@ 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");
@@ -26,8 +24,6 @@ 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");
@@ -63,13 +59,9 @@ var _private_utils = require("../private_utils");
 
 var _error_utils = require("../error_utils");
 
-var _block_query_spec = require("../types/block_query_spec");
-
 var _table = _interopRequireWildcard(require("./table"));
 
-var _view = _interopRequireDefault(require("./view"));
-
-var _record_query_result = _interopRequireWildcard(require("./record_query_result"));
+var _record_query_result = _interopRequireDefault(require("./record_query_result"));
 
 var _record_coloring = require("./record_coloring");
 
@@ -105,17 +97,6 @@ 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 */
@@ -143,6 +124,17 @@ 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 */
@@ -154,8 +146,7 @@ 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), "_mostRecentSourceModelLoadedPromise", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_loadedSourceModelQueryIds", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_mostRecentSourceModelLoadPromise", 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);
@@ -165,145 +156,10 @@ 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, functionToCallWithKey) => {
-        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);
-        }
-
-        functionToCallWithKey(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
-      },
-      [_record_query_result.default.WatchableKeys.cellValues]: (key, functionToCallWithKey) => {
-        if (_this._fieldIdsSetToLoadOrNullIfAllFields) {
-          for (var _i = 0, _Object$keys = Object.keys(_this._fieldIdsSetToLoadOrNullIfAllFields); _i < _Object$keys.length; _i++) {
-            var fieldId = _Object$keys[_i];
-            functionToCallWithKey(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
-          }
-        } else {
-          functionToCallWithKey(_record_query_result.default.WatchableKeys.cellValues);
-        }
-      }
-    });
-    (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._mostRecentSourceModelLoadedPromise = null;
-    _this._loadedSourceModelQueryIds = [];
+    _this._mostRecentSourceModelLoadPromise = null;
     _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
@@ -313,57 +169,58 @@ function (_RecordQueryResult) {
     _this._orderedRecordIds = null;
     _this._orderedGroups = null;
     _this._loadedGroupLevels = null;
+    _this._cellValueKeyWatchCounts = {};
     var fieldIdsSetToLoadOrNullIfAllFields = null;
 
     if (_this._normalizedOpts.fieldIdsOrNullIfAllFields) {
       fieldIdsSetToLoadOrNullIfAllFields = {};
-      var _iteratorNormalCompletion2 = true;
-      var _didIteratorError2 = false;
-      var _iteratorError2 = undefined;
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
 
       try {
-        for (var _iterator2 = _this._normalizedOpts.fieldIdsOrNullIfAllFields[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-          var fieldId = _step2.value;
+        for (var _iterator = _this._normalizedOpts.fieldIdsOrNullIfAllFields[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var fieldId = _step.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) {
-        _didIteratorError2 = true;
-        _iteratorError2 = err;
+        _didIteratorError = true;
+        _iteratorError = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-            _iterator2.return();
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
           }
         } finally {
-          if (_didIteratorError2) {
-            throw _iteratorError2;
+          if (_didIteratorError) {
+            throw _iteratorError;
           }
         }
       }
 
       if (_this._sorts !== null) {
-        var _iteratorNormalCompletion3 = true;
-        var _didIteratorError3 = false;
-        var _iteratorError3 = undefined;
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
 
         try {
-          for (var _iterator3 = _this._sorts[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-            var sort = _step3.value;
+          for (var _iterator2 = _this._sorts[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var sort = _step2.value;
             fieldIdsSetToLoadOrNullIfAllFields[sort.fieldId] = true;
           }
         } catch (err) {
-          _didIteratorError3 = true;
-          _iteratorError3 = err;
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-              _iterator3.return();
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
             }
           } finally {
-            if (_didIteratorError3) {
-              throw _iteratorError3;
+            if (_didIteratorError2) {
+              throw _iteratorError2;
             }
           }
         }
@@ -403,26 +260,26 @@ function (_RecordQueryResult) {
     value: function _getOrGenerateRecordIdsSet() {
       if (!this._recordIdsSet) {
         var recordIdsSet = {};
-        var _iteratorNormalCompletion4 = true;
-        var _didIteratorError4 = false;
-        var _iteratorError4 = undefined;
+        var _iteratorNormalCompletion3 = true;
+        var _didIteratorError3 = false;
+        var _iteratorError3 = undefined;
 
         try {
-          for (var _iterator4 = this.recordIds[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-            var recordId = _step4.value;
+          for (var _iterator3 = this.recordIds[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            var recordId = _step3.value;
             recordIdsSet[recordId] = true;
           }
         } catch (err) {
-          _didIteratorError4 = true;
-          _iteratorError4 = err;
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-              _iterator4.return();
+            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+              _iterator3.return();
             }
           } finally {
-            if (_didIteratorError4) {
-              throw _iteratorError4;
+            if (_didIteratorError3) {
+              throw _iteratorError3;
             }
           }
         }
@@ -439,59 +296,85 @@ function (_RecordQueryResult) {
      */
 
   }, {
-    key: "watch",
+    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);
+
+        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 callWatchOnRecordStoreWithKeys = keysToWatch => {
-        this._recordStore.watchWithRecordQueryResult({
-          recordQueryResult: this,
-          keys: keysToWatch,
-          callbackForRegistration: callback,
-          context
-        });
-      };
-
-      var _iteratorNormalCompletion5 = true;
-      var _didIteratorError5 = false;
-      var _iteratorError5 = undefined;
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
 
       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.
+        for (var _iterator4 = validKeys[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var _key2 = _step4.value;
+
           if (_key2.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
-            this._watchConfigByWatchableKey[_record_query_result.default.WatchableCellValuesInFieldKeyPrefix](_key2, callWatchOnRecordStoreWithKeys);
-          } else {
-            var _functionToCallWithKey = this._watchConfigByWatchableKey[_key2];
+            var fieldId = _key2.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 field because it wasn't included in RecordQueryResult fields: %s", fieldId);
+            }
+
+            this._incrementCellValueKeyWatchCountAndWatchIfNecessary(_key2, this._onCellValuesInFieldChanged);
+          }
 
-            if (_functionToCallWithKey) {
-              _functionToCallWithKey(_key2, callWatchOnRecordStoreWithKeys);
+          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];
+
+                this._incrementCellValueKeyWatchCountAndWatchIfNecessary(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + _fieldId, this._onCellValuesChanged);
+              }
+            } else {
+              this._incrementCellValueKeyWatchCountAndWatchIfNecessary(_key2, this._onCellValuesChanged);
             }
           }
         }
       } catch (err) {
-        _didIteratorError5 = true;
-        _iteratorError5 = err;
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-            _iterator5.return();
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
           }
         } finally {
-          if (_didIteratorError5) {
-            throw _iteratorError5;
+          if (_didIteratorError4) {
+            throw _iteratorError4;
           }
         }
       }
@@ -504,41 +387,41 @@ 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 callUnwatchOnRecordStoreWithKeys = keysToUnwatch => {
-        this._recordStore.unwatch(keysToUnwatch, callback, context);
-      };
-
-      var _iteratorNormalCompletion6 = true;
-      var _didIteratorError6 = false;
-      var _iteratorError6 = undefined;
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
 
       try {
-        for (var _iterator6 = validKeys[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
-          var _key3 = _step6.value;
+        for (var _iterator5 = validKeys[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var _key3 = _step5.value;
 
-          // This is the inverse of the watch logic
           if (_key3.startsWith(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix)) {
-            this._watchConfigByWatchableKey[_record_query_result.default.WatchableCellValuesInFieldKeyPrefix](_key3, callUnwatchOnRecordStoreWithKeys);
-          } else {
-            var _functionToCallWithKey2 = this._watchConfigByWatchableKey[_key3];
+            this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(_key3, this._onCellValuesInFieldChanged);
+          }
 
-            if (_functionToCallWithKey2) {
-              _functionToCallWithKey2(_key3, callUnwatchOnRecordStoreWithKeys);
+          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._decrementCellValueKeyWatchCountAndUnwatchIfPossible(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, this._onCellValuesChanged);
+              }
+            } else {
+              this._decrementCellValueKeyWatchCountAndUnwatchIfPossible(_key3, this._onCellValuesChanged);
             }
           }
         }
       } catch (err) {
-        _didIteratorError6 = true;
-        _iteratorError6 = err;
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-            _iterator6.return();
+          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+            _iterator5.return();
           }
         } finally {
-          if (_didIteratorError6) {
-            throw _iteratorError6;
+          if (_didIteratorError5) {
+            throw _iteratorError5;
           }
         }
       }
@@ -550,54 +433,45 @@ function (_RecordQueryResult) {
   }, {
     key: "loadDataAsync",
     value: function loadDataAsync() {
-      var sourceModelLoadPromise, fieldIdsToLoadOrNullIfAllFields, allFieldsToQuery, metadataFieldId, sourceModelLoadedPromise;
-      return _regenerator.default.async(function loadDataAsync$(_context2) {
+      var sourceModelLoadPromise, cellValuesInFieldsLoadPromise;
+      return _regenerator.default.async(function loadDataAsync$(_context) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context.prev = _context.next) {
             case 0:
               if (!this._sourceModel.isDeleted) {
-                _context2.next = 2;
+                _context.next = 2;
                 break;
               }
 
               throw this._spawnErrorForDeletion();
 
             case 2:
-              fieldIdsToLoadOrNullIfAllFields = this._fieldIdsSetToLoadOrNullIfAllFields ? Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields) : null;
+              if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+                cellValuesInFieldsLoadPromise = this._recordStore.loadCellValuesInFieldIdsAsync(Object.keys(this._fieldIdsSetToLoadOrNullIfAllFields));
+              } else {
+                // Load all fields.
+                cellValuesInFieldsLoadPromise = this._recordStore.loadDataAsync();
+              }
 
               if (this._sourceModel instanceof _table.default) {
-                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);
+                if (this._fieldIdsSetToLoadOrNullIfAllFields) {
+                  sourceModelLoadPromise = this._recordStore.loadRecordMetadataAsync();
                 } else {
-                  // Load all fields.
-                  sourceModelLoadPromise = this._recordStore.loadAllCellValuesAsync();
+                  // table.loadDataAsync is a superset of loadRecordMetadataAsync,
+                  // so no need to load record metadata again.
+                  sourceModelLoadPromise = null;
                 }
               } else {
-                sourceModelLoadPromise = this._recordStore.loadViewDataStoreAndCellValuesForFieldIdsAsync(this._sourceModel.id, fieldIdsToLoadOrNullIfAllFields);
-              } // See comment on _loadedSourceModelQueryIds declaration for details
-
+                sourceModelLoadPromise = this._recordStore.getViewDataStore(this._sourceModel.id).loadDataAsync();
+              }
 
-              sourceModelLoadedPromise = sourceModelLoadPromise.then(sourceModelQueryId => {
-                this._loadedSourceModelQueryIds.push(sourceModelQueryId);
-              });
-              this._mostRecentSourceModelLoadedPromise = Promise.all([sourceModelLoadedPromise, this._loadRecordColorsAsync()]);
-              _context2.next = 8;
+              this._mostRecentSourceModelLoadPromise = Promise.all([sourceModelLoadPromise, cellValuesInFieldsLoadPromise, this._loadRecordColorsAsync()]);
+              _context.next = 7;
               return _regenerator.default.awrap((0, _get2.default)((0, _getPrototypeOf2.default)(TableOrViewQueryResult.prototype), "loadDataAsync", this).call(this));
 
-            case 8:
+            case 7:
             case "end":
-              return _context2.stop();
+              return _context.stop();
           }
         }
       }, null, this);
@@ -613,26 +487,26 @@ function (_RecordQueryResult) {
 
       var fieldIds = this._normalizedOpts.fieldIdsOrNullIfAllFields || this._table.fields.map(field => field.id);
 
-      var _iteratorNormalCompletion7 = true;
-      var _didIteratorError7 = false;
-      var _iteratorError7 = undefined;
+      var _iteratorNormalCompletion6 = true;
+      var _didIteratorError6 = false;
+      var _iteratorError6 = undefined;
 
       try {
-        for (var _iterator7 = fieldIds[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-          var fieldId = _step7.value;
+        for (var _iterator6 = fieldIds[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+          var fieldId = _step6.value;
           changedKeys.push(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
         }
       } catch (err) {
-        _didIteratorError7 = true;
-        _iteratorError7 = err;
+        _didIteratorError6 = true;
+        _iteratorError6 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-            _iterator7.return();
+          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+            _iterator6.return();
           }
         } finally {
-          if (_didIteratorError7) {
-            throw _iteratorError7;
+          if (_didIteratorError6) {
+            throw _iteratorError6;
           }
         }
       }
@@ -644,72 +518,55 @@ function (_RecordQueryResult) {
   }, {
     key: "_loadDataAsync",
     value: function _loadDataAsync() {
-      var viewDataStore, _iteratorNormalCompletion8, _didIteratorError8, _iteratorError8, _iterator8, _step8, sort, field;
+      var viewDataStore, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, sort, field;
 
-      return _regenerator.default.async(function _loadDataAsync$(_context3) {
+      return _regenerator.default.async(function _loadDataAsync$(_context2) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
               this._table.__tableOrViewQueryResultPool.registerObjectForReuseStrong(this);
 
-              (0, _error_utils.invariant)(this._mostRecentSourceModelLoadedPromise, 'No source model load promises');
-              _context3.next = 4;
-              return _regenerator.default.awrap(this._mostRecentSourceModelLoadedPromise);
+              (0, _error_utils.invariant)(this._mostRecentSourceModelLoadPromise, 'No source model load promises');
+              _context2.next = 4;
+              return _regenerator.default.awrap(this._mostRecentSourceModelLoadPromise);
 
             case 4:
               if (this._sorts) {
                 this._replaceVisList();
               }
 
-              this._orderedRecordIds = this._generateOrderedRecordIds(); // Ensure that groups are not loaded
+              this._orderedRecordIds = this._generateOrderedRecordIds();
+              this._orderedGroups = this._generateAndLoadOrderedGroups(); // The server provided value and developer supplied value are the same, no conversion needed
 
-              this._orderedGroups = null; // The server provided value and developer supplied value are the same, no conversion needed
-
-              this._loadedGroupLevels = null;
+              this._loadedGroupLevels = this._sourceModelGroupLevels;
 
               if (this._sourceModel instanceof _table.default) {
-                this._recordStore.watchWithRecordQueryResult({
-                  recordQueryResult: this,
-                  keys: _record_store.WatchableRecordStoreKeys.records,
-                  callbackForRegistration: this._onRecordsChanged,
-                  context: this
-                });
+                this._recordStore.watch(_record_store.WatchableRecordStoreKeys.records, this._onRecordsChanged, 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);
-              } // This only watches cell values if a sort is specified
-
+              }
 
-              this._recordStore.watchWithRecordQueryResult({
-                recordQueryResult: this,
-                keys: this._cellValuesForSortWatchKeys,
-                callbackForRegistration: this._onCellValuesForSortChanged,
-                context: this
-              });
+              this._recordStore.watch(this._cellValuesForSortWatchKeys, this._onCellValuesForSortChanged, this);
 
-              this._recordStore.watchWithRecordQueryResult({
-                recordQueryResult: this,
-                keys: this._cellValuesForGroupWatchKeys,
-                callbackForRegistration: this._onCellValuesForGroupChanged,
-                context: this
-              });
+              this._recordStore.watch(this._cellValuesForGroupWatchKeys, this._onCellValuesForGroupChanged, this);
 
               this._table.watch(_table.WatchableTableKeys.fields, this._onTableFieldsChanged, this);
 
               if (!this._sorts) {
-                _context3.next = 32;
+                _context2.next = 32;
                 break;
               }
 
-              _iteratorNormalCompletion8 = true;
-              _didIteratorError8 = false;
-              _iteratorError8 = undefined;
-              _context3.prev = 16;
+              _iteratorNormalCompletion7 = true;
+              _didIteratorError7 = false;
+              _iteratorError7 = undefined;
+              _context2.prev = 16;
 
-              for (_iterator8 = this._sorts[Symbol.iterator](); !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
-                sort = _step8.value;
+              for (_iterator7 = this._sorts[Symbol.iterator](); !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+                sort = _step7.value;
                 field = this._table.getFieldByIdIfExists(sort.fieldId);
 
                 if (field) {
@@ -718,45 +575,45 @@ function (_RecordQueryResult) {
                 }
               }
 
-              _context3.next = 24;
+              _context2.next = 24;
               break;
 
             case 20:
-              _context3.prev = 20;
-              _context3.t0 = _context3["catch"](16);
-              _didIteratorError8 = true;
-              _iteratorError8 = _context3.t0;
+              _context2.prev = 20;
+              _context2.t0 = _context2["catch"](16);
+              _didIteratorError7 = true;
+              _iteratorError7 = _context2.t0;
 
             case 24:
-              _context3.prev = 24;
-              _context3.prev = 25;
+              _context2.prev = 24;
+              _context2.prev = 25;
 
-              if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
-                _iterator8.return();
+              if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+                _iterator7.return();
               }
 
             case 27:
-              _context3.prev = 27;
+              _context2.prev = 27;
 
-              if (!_didIteratorError8) {
-                _context3.next = 30;
+              if (!_didIteratorError7) {
+                _context2.next = 30;
                 break;
               }
 
-              throw _iteratorError8;
+              throw _iteratorError7;
 
             case 30:
-              return _context3.finish(27);
+              return _context2.finish(27);
 
             case 31:
-              return _context3.finish(24);
+              return _context2.finish(24);
 
             case 32:
-              return _context3.abrupt("return", this._getChangedKeysOnLoad());
+              return _context2.abrupt("return", this._getChangedKeysOnLoad());
 
             case 33:
             case "end":
-              return _context3.stop();
+              return _context2.stop();
           }
         }
       }, null, this, [[16, 20, 24, 32], [25,, 27, 31]]);
@@ -768,9 +625,21 @@ function (_RecordQueryResult) {
     value: function unloadData() {
       (0, _get2.default)((0, _getPrototypeOf2.default)(TableOrViewQueryResult.prototype), "unloadData", this).call(this);
 
-      if (this._loadedSourceModelQueryIds.length === 0) {
-        // Source model must have loaded a queryId to unload
-        return;
+      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));
       }
 
       this._unloadRecordColors();
@@ -780,34 +649,119 @@ function (_RecordQueryResult) {
   }, {
     key: "_unloadData",
     value: function _unloadData() {
-      (0, _private_utils.fireAndForgetPromise)(this._unloadDataAsync);
+      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);
     }
+    /** @internal */
+
   }, {
     key: "_addRecordIdsToVisList",
-
-    /** @internal */
     value: function _addRecordIdsToVisList(recordIds) {
       var visList = this._visList;
       (0, _error_utils.invariant)(visList, 'No vis list');
-      visList.addRecordIds(recordIds);
+      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;
+          }
+        }
+      }
     }
     /** @internal */
 
   }, {
     key: "_onGroupLevelsChanged",
     value: function _onGroupLevelsChanged(model, key, updates) {
-      this._loadedGroupLevels = null;
+      this._loadedGroupLevels = this._sourceModelGroupLevels;
 
-      this._unloadGroupsAndTriggerWatches();
+      this._unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches();
 
-      this._onChange(_record_query_result.WatchableRecordQueryResultKeys.groupLevels);
+      this._onChange(_record_query_result.default.WatchableKeys.groupLevels);
     }
     /** @internal */
 
   }, {
     key: "_onGroupsChanged",
     value: function _onGroupsChanged(model, key, updates) {
-      this._unloadGroupsAndTriggerWatches();
+      this._unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches();
     }
     /** @internal */
 
@@ -830,11 +784,7 @@ 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
@@ -861,50 +811,50 @@ function (_RecordQueryResult) {
       }
 
       if (this._recordIdsSet) {
-        var _iteratorNormalCompletion9 = true;
-        var _didIteratorError9 = false;
-        var _iteratorError9 = undefined;
+        var _iteratorNormalCompletion10 = true;
+        var _didIteratorError10 = false;
+        var _iteratorError10 = undefined;
 
         try {
-          for (var _iterator9 = addedRecordIds[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
-            var recordId = _step9.value;
+          for (var _iterator10 = addedRecordIds[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+            var recordId = _step10.value;
             this._recordIdsSet[recordId] = true;
           }
         } catch (err) {
-          _didIteratorError9 = true;
-          _iteratorError9 = err;
+          _didIteratorError10 = true;
+          _iteratorError10 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
-              _iterator9.return();
+            if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+              _iterator10.return();
             }
           } finally {
-            if (_didIteratorError9) {
-              throw _iteratorError9;
+            if (_didIteratorError10) {
+              throw _iteratorError10;
             }
           }
         }
 
-        var _iteratorNormalCompletion10 = true;
-        var _didIteratorError10 = false;
-        var _iteratorError10 = undefined;
+        var _iteratorNormalCompletion11 = true;
+        var _didIteratorError11 = false;
+        var _iteratorError11 = undefined;
 
         try {
-          for (var _iterator10 = removedRecordIds[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
-            var _recordId = _step10.value;
+          for (var _iterator11 = removedRecordIds[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
+            var _recordId = _step11.value;
             this._recordIdsSet[_recordId] = undefined;
           }
         } catch (err) {
-          _didIteratorError10 = true;
-          _iteratorError10 = err;
+          _didIteratorError11 = true;
+          _iteratorError11 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
-              _iterator10.return();
+            if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
+              _iterator11.return();
             }
           } finally {
-            if (_didIteratorError10) {
-              throw _iteratorError10;
+            if (_didIteratorError11) {
+              throw _iteratorError11;
             }
           }
         }
@@ -933,10 +883,6 @@ 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
@@ -1002,13 +948,13 @@ function (_RecordQueryResult) {
       // deleted and then undeleted.
 
       var wereAnyFieldsCreatedOrDeleted = false;
-      var _iteratorNormalCompletion11 = true;
-      var _didIteratorError11 = false;
-      var _iteratorError11 = undefined;
+      var _iteratorNormalCompletion12 = true;
+      var _didIteratorError12 = false;
+      var _iteratorError12 = undefined;
 
       try {
-        for (var _iterator11 = addedFieldIds[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
-          var fieldId = _step11.value;
+        for (var _iterator12 = addedFieldIds[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+          var fieldId = _step12.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.
@@ -1025,16 +971,16 @@ function (_RecordQueryResult) {
         // istanbul ignore else
 
       } catch (err) {
-        _didIteratorError11 = true;
-        _iteratorError11 = err;
+        _didIteratorError12 = true;
+        _iteratorError12 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
-            _iterator11.return();
+          if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+            _iterator12.return();
           }
         } finally {
-          if (_didIteratorError11) {
-            throw _iteratorError11;
+          if (_didIteratorError12) {
+            throw _iteratorError12;
           }
         }
       }
@@ -1064,6 +1010,34 @@ 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() {
@@ -1081,6 +1055,7 @@ 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
@@ -1106,26 +1081,26 @@ function (_RecordQueryResult) {
     key: "_unloadOrderedGroupsIfNeeded",
     value: function _unloadOrderedGroupsIfNeeded() {
       if (this._orderedGroups) {
-        var _iteratorNormalCompletion12 = true;
-        var _didIteratorError12 = false;
-        var _iteratorError12 = undefined;
+        var _iteratorNormalCompletion13 = true;
+        var _didIteratorError13 = false;
+        var _iteratorError13 = undefined;
 
         try {
-          for (var _iterator12 = this._orderedGroups[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
-            var group = _step12.value;
+          for (var _iterator13 = this._orderedGroups[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
+            var group = _step13.value;
             group.unloadData();
           }
         } catch (err) {
-          _didIteratorError12 = true;
-          _iteratorError12 = err;
+          _didIteratorError13 = true;
+          _iteratorError13 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
-              _iterator12.return();
+            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
+              _iterator13.return();
             }
           } finally {
-            if (_didIteratorError12) {
-              throw _iteratorError12;
+            if (_didIteratorError13) {
+              throw _iteratorError13;
             }
           }
         }
@@ -1133,21 +1108,22 @@ function (_RecordQueryResult) {
     }
     /**
      * If groupings change then some groups will need to be created, and some removed
-     * 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.
+     * 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.
      *
      * @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: "_unloadGroupsAndTriggerWatches",
-    value: function _unloadGroupsAndTriggerWatches() {
+    key: "_unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches",
+    value: function _unloadRemovedGroupsAndLoadNewGroupsAndTriggerWatches() {
       this._unloadOrderedGroupsIfNeeded();
 
-      this._orderedGroups = null;
+      this._orderedGroups = this._generateAndLoadOrderedGroups();
 
       this._onChange(_record_query_result.default.WatchableKeys.groups);
     }
@@ -1157,14 +1133,15 @@ function (_RecordQueryResult) {
     key: "_replaceVisList",
     value: function _replaceVisList() {
       var airtableInterface = this._sdk.__airtableInterface;
+      var appInterface = this._sdk.__appInterface;
 
-      var recordIds = this._sourceModelRecords.map(record => record.id);
+      var recordDatas = this._sourceModelRecords.map(record => record._data);
 
       var fieldDatas = this._table.fields.map(field => field._data);
 
       var filteredSorts = this._getSortsWithDeletedFieldsFiltered();
 
-      this._visList = airtableInterface.createVisListWithRecordIds(recordIds, fieldDatas, filteredSorts, this._table.id);
+      this._visList = airtableInterface.createVisList(appInterface, recordDatas, fieldDatas, filteredSorts);
     }
     /** @internal */
 
@@ -1190,31 +1167,6 @@ 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() {
@@ -1223,7 +1175,9 @@ function (_RecordQueryResult) {
       }
 
       return {
-        recordIds: this._orderedRecordIds
+        recordIds: this._orderedRecordIds,
+        groups: this._orderedGroups,
+        groupLevels: this._loadedGroupLevels
       };
     }
     /** @internal */
@@ -1277,10 +1231,8 @@ 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'); // TODO: (#proj-blocks-sdk-record-limits) Change this to readonly upon the
-      // next breaking change.
-
-      return [...recordIds];
+      (0, _error_utils.invariant)(recordIds, 'No recordIds');
+      return recordIds;
     }
     /**
      * The ordered GroupedRecordQueryResult's in this RecordQueryResult.
@@ -1293,19 +1245,12 @@ 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.
-      (0, _error_utils.invariant)(this._data, 'RecordQueryResult must not be deleted'); // Throws when the model has been deleted.
+      var groups = this._data.groups; // Throws when the model has been deleted.
 
       (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
-
-      if (!this._orderedGroups) {
-        this._orderedGroups = this._generateAndLoadOrderedGroups();
-      }
-
-      return (_this$_orderedGroups = this._orderedGroups) !== null && _this$_orderedGroups !== void 0 ? _this$_orderedGroups : null;
+      return groups !== null && groups !== void 0 ? groups : null;
     }
     /**
      * The GroupLevels in this RecordQueryResult.
@@ -1318,15 +1263,10 @@ function (_RecordQueryResult) {
   }, {
     key: "groupLevels",
     get: function get() {
-      (0, _error_utils.invariant)(this._data, 'RecordQueryResult must not be deleted'); // Throws when the model has been deleted.
+      var groupLevels = this._data.groupLevels; // Throws when the model has been deleted.
 
       (0, _error_utils.invariant)(this.isDataLoaded, 'RecordQueryResult data is not loaded');
-
-      if (!this._loadedGroupLevels) {
-        this._loadedGroupLevels = this._sourceModelGroupLevels;
-      }
-
-      return this._loadedGroupLevels ? this._loadedGroupLevels.map(singleLevel => _objectSpread({}, singleLevel, {
+      return groupLevels ? groupLevels.map(singleLevel => _objectSpread({}, singleLevel, {
         field: this.parentTable.getFieldById(singleLevel.fieldId)
       })) : null;
     }
@@ -1341,13 +1281,13 @@ function (_RecordQueryResult) {
         // using RecordQueryResult) if the user had to manually watch for deletion
         // on all the fields and recreate the RecordQueryResult.
 
-        var _iteratorNormalCompletion13 = true;
-        var _didIteratorError13 = false;
-        var _iteratorError13 = undefined;
+        var _iteratorNormalCompletion14 = true;
+        var _didIteratorError14 = false;
+        var _iteratorError14 = undefined;
 
         try {
-          for (var _iterator13 = fieldIdsOrNullIfAllFields[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
-            var fieldId = _step13.value;
+          for (var _iterator14 = fieldIdsOrNullIfAllFields[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
+            var fieldId = _step14.value;
 
             var field = this._table.getFieldByIdIfExists(fieldId);
 
@@ -1356,16 +1296,16 @@ function (_RecordQueryResult) {
             }
           }
         } catch (err) {
-          _didIteratorError13 = true;
-          _iteratorError13 = err;
+          _didIteratorError14 = true;
+          _iteratorError14 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
-              _iterator13.return();
+            if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
+              _iterator14.return();
             }
           } finally {
-            if (_didIteratorError13) {
-              throw _iteratorError13;
+            if (_didIteratorError14) {
+              throw _iteratorError14;
             }
           }
         }
@@ -1419,12 +1359,6 @@ 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);