@airtable/blocks 1.7.0 → 1.9.0-experimental

package/dist/cjs/models/record_store.js

@@ -6,18 +6,26 @@ require("core-js/modules/es.symbol");
 
 require("core-js/modules/es.symbol.description");
 
+require("core-js/modules/es.array.concat");
+
 require("core-js/modules/es.array.filter");
 
 require("core-js/modules/es.array.iterator");
 
 require("core-js/modules/es.array.map");
 
+require("core-js/modules/es.object.get-own-property-descriptors");
+
 require("core-js/modules/es.object.to-string");
 
 require("core-js/modules/es.promise");
 
+require("core-js/modules/es.set");
+
 require("core-js/modules/es.string.starts-with");
 
+require("core-js/modules/web.dom-collections.for-each");
+
 require("core-js/modules/web.dom-collections.iterator");
 
 Object.defineProperty(exports, "__esModule", {
@@ -25,8 +33,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.WatchableRecordStoreKeys = void 0;
 
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 require("regenerator-runtime/runtime");
@@ -35,11 +41,9 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
@@ -51,12 +55,20 @@ var _private_utils = require("../private_utils");
 
 var _error_utils = require("../error_utils");
 
+var _warning = _interopRequireDefault(require("../warning"));
+
+var _block_query_spec = require("../types/block_query_spec");
+
 var _abstract_model_with_async_data = _interopRequireDefault(require("./abstract_model_with_async_data"));
 
 var _record = _interopRequireDefault(require("./record"));
 
 var _view_data_store = _interopRequireDefault(require("./view_data_store"));
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 var WatchableRecordStoreKeys = Object.freeze({
   records: 'records',
   recordIds: 'recordIds',
@@ -71,8 +83,9 @@ var WatchableCellValuesInFieldKeyPrefix = 'cellValuesInField:';
  */
 
 /**
- * One RecordStore exists per table, and contains all the record data associated with that table.
- * Table itself is for schema information only, so isn't the appropriate place for this data.
+ * One RecordStore exists per table, and can access *some* of the record data associated with that
+ * table, depending on which records are actually required for the slices of data that are subscribed.
+ * Table itself is for schema information only, so isn't the appropriate place for record data.
  *
  * @internal
  */
@@ -85,16 +98,6 @@ function (_AbstractModelWithAsy) {
     value: function _isWatchableKey(key) {
       return (0, _private_utils.isEnumValue)(WatchableRecordStoreKeys, key) || key.startsWith(WatchableCellValuesInFieldKeyPrefix);
     }
-  }, {
-    key: "_shouldLoadDataForKey",
-    value: function _shouldLoadDataForKey(key) {
-      // "Data" means *all* cell values in the table. If only watching records/recordIds,
-      // we'll just load record metadata (id, createdTime, commentCount).
-      // If only watching specific fields, we'll just load cell values in those
-      // fields. Both of those scenarios are handled manually by this class,
-      // instead of relying on AbstractModelWithAsyncData.
-      return key === WatchableRecordStoreKeys.cellValues;
-    }
   }]);
 
   function RecordStore(sdk, tableId) {
@@ -106,11 +109,15 @@ function (_AbstractModelWithAsy) {
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_recordModelsById", {});
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_primaryFieldId", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_airtableInterface", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryManager", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_viewDataStoresByViewId", {});
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_areCellValuesLoadedByFieldId", {});
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_pendingCellValuesLoadPromiseByFieldId", {});
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_cellValuesRetainCountByFieldId", {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_airtableRecordStoreForTable", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_numQueriesSubscribedToAllRecords", 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryIdFromReferenceCountedLoadData", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_loadedQuerySpecIds", new Set());
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_forceUnloadCallbacks", []);
     _this._airtableInterface = sdk.__airtableInterface;
+    _this._queryManager = sdk._queryManager;
     _this.tableId = tableId; // A bit of a hack, but we use the primary field ID to load record
     // metadata (see _getFieldIdForCausingRecordMetadataToLoad). We copy the
     // ID here instead of calling this.primaryField.id since that would crash
@@ -121,96 +128,320 @@ function (_AbstractModelWithAsy) {
   }
 
   (0, _createClass2.default)(RecordStore, [{
+    key: "_getRecordStoreForTable",
+    value: function _getRecordStoreForTable() {
+      if (!this._airtableRecordStoreForTable) {
+        var airtableRecordStoreForTable = this._airtableInterface.getTableRecordStoreIfExists(this.tableId);
+
+        (0, _error_utils.invariant)(airtableRecordStoreForTable, 'no RecordStoreForTable found for tableId %s', this.tableId);
+        this._airtableRecordStoreForTable = airtableRecordStoreForTable;
+      }
+
+      return this._airtableRecordStoreForTable;
+    }
+  }, {
     key: "getViewDataStore",
     value: function getViewDataStore(viewId) {
       if (this._viewDataStoresByViewId[viewId]) {
         return this._viewDataStoresByViewId[viewId];
       }
 
-      (0, _error_utils.invariant)(this._data.viewsById[viewId], 'view must exist');
+      (0, _error_utils.invariant)(this._data.viewsById[viewId], 'view must exist'); // TODO: (#proj-blocks-sdk-record-limits) Rename ViewDataStore so that it does not
+      // conflict with hyperbase ViewDataStore. Here we are using the SDK ViewDataStore
+      // which is a thin wrapper around the hyperbase one.
+
       var viewDataStore = new _view_data_store.default(this._sdk, this, viewId);
       this._viewDataStoresByViewId[viewId] = viewDataStore;
       return viewDataStore;
     }
   }, {
-    key: "watch",
-    value: function watch(keys, callback, context) {
-      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStore.prototype), "watch", this).call(this, keys, callback, context);
+    key: "sendViewDataDeletionIfViewIsDeleted",
+    value: function sendViewDataDeletionIfViewIsDeleted(viewId) {
+      var viewDataStoreIfExists = this._viewDataStoresByViewId[viewId];
+
+      if (viewDataStoreIfExists && viewDataStoreIfExists.isDeleted) {
+        viewDataStoreIfExists.__onDataDeletion();
+      }
+    }
+  }, {
+    key: "_findMatchingBlockSubscriptionChanges",
+    value: function _findMatchingBlockSubscriptionChanges(changes, changeTypeToMatch) {
+      return changes.filter(change => change.type === changeTypeToMatch && change.tableId === this.tableId);
+    }
+  }, {
+    key: "_constructBlockQuerySpecAndCallbackForWatchableKeyWithRecordQueryResult",
+    value: function _constructBlockQuerySpecAndCallbackForWatchableKeyWithRecordQueryResult(recordQueryResult, key, callbackForRegistration, context) {
+      var fieldSelectionDefinition;
+      var originThis = recordQueryResult;
+      var onChangeCallback;
+
+      switch (key) {
+        case WatchableRecordStoreKeys.records:
+        case WatchableRecordStoreKeys.recordIds:
+          fieldSelectionDefinition = {
+            type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+            fieldIds: []
+          };
+
+          onChangeCallback = changes => {
+            var addedRecordsChanges = this._findMatchingBlockSubscriptionChanges(changes, _block_query_spec.BlockQuerySubscriptionChangeType.ADDED_RECORD_IDS);
+
+            var removedRecordsChanges = this._findMatchingBlockSubscriptionChanges(changes, _block_query_spec.BlockQuerySubscriptionChangeType.REMOVED_RECORD_IDS);
+
+            var addedRecordIds = [];
+            var removedRecordIds = [];
+            var _iteratorNormalCompletion = true;
+            var _didIteratorError = false;
+            var _iteratorError = undefined;
+
+            try {
+              for (var _iterator = addedRecordsChanges[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var addedRecordsChange = _step.value;
+                (0, _error_utils.invariant)(addedRecordsChange.type === _block_query_spec.BlockQuerySubscriptionChangeType.ADDED_RECORD_IDS, 'Added Records change is not a supported type');
+                addedRecordIds = addedRecordIds.concat(addedRecordsChange.recordIds);
+              }
+            } catch (err) {
+              _didIteratorError = true;
+              _iteratorError = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+
+            var _iteratorNormalCompletion2 = true;
+            var _didIteratorError2 = false;
+            var _iteratorError2 = undefined;
+
+            try {
+              for (var _iterator2 = removedRecordsChanges[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                var removedRecordsChange = _step2.value;
+                (0, _error_utils.invariant)(removedRecordsChange.type === _block_query_spec.BlockQuerySubscriptionChangeType.REMOVED_RECORD_IDS, 'Removed Records change is not a supported type');
+                removedRecordIds = removedRecordIds.concat(removedRecordsChange.recordIds);
+              }
+            } catch (err) {
+              _didIteratorError2 = true;
+              _iteratorError2 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                  _iterator2.return();
+                }
+              } finally {
+                if (_didIteratorError2) {
+                  throw _iteratorError2;
+                }
+              }
+            }
+
+            var recordIdsChanged = {
+              addedRecordIds,
+              removedRecordIds
+            };
+            callbackForRegistration.call(context, originThis, key, recordIdsChanged);
+          };
+
+          break;
+
+        case WatchableRecordStoreKeys.cellValues:
+          fieldSelectionDefinition = {
+            type: _block_query_spec.BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE
+          };
+
+          onChangeCallback = changes => {
+            var modifiedCellValuesChanges = this._findMatchingBlockSubscriptionChanges(changes, _block_query_spec.BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE);
+
+            if (modifiedCellValuesChanges.length === 0) {
+              callbackForRegistration.call(context, originThis, key);
+              return;
+            }
+
+            var recordsAndFieldsChanged = {
+              recordIds: [],
+              fieldIds: []
+            };
+            var _iteratorNormalCompletion3 = true;
+            var _didIteratorError3 = false;
+            var _iteratorError3 = undefined;
+
+            try {
+              for (var _iterator3 = modifiedCellValuesChanges[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                var modifiedCellValuesChange = _step3.value;
+                (0, _error_utils.invariant)(modifiedCellValuesChange.type === _block_query_spec.BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE, 'Modified cell value change is not a supported type');
+                var fieldIdsByRecordId = modifiedCellValuesChange.fieldIdsByRecordId,
+                    fieldIds = modifiedCellValuesChange.fieldIds;
+                recordsAndFieldsChanged.recordIds = recordsAndFieldsChanged.recordIds.concat(Object.keys(fieldIdsByRecordId));
+                recordsAndFieldsChanged.fieldIds = recordsAndFieldsChanged.fieldIds.concat(fieldIds);
+              }
+            } catch (err) {
+              _didIteratorError3 = true;
+              _iteratorError3 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                  _iterator3.return();
+                }
+              } finally {
+                if (_didIteratorError3) {
+                  throw _iteratorError3;
+                }
+              }
+            }
+
+            callbackForRegistration.call(context, originThis, key, recordsAndFieldsChanged);
+          };
+
+          break;
+
+        default:
+          {
+            // Since this watch class is only called internally from within the SDK
+            // an error here is an internal SDK error.
+            (0, _error_utils.invariant)(key.startsWith(WatchableCellValuesInFieldKeyPrefix), 'Internal error - Unrecognized watch key on record_store: %s', key);
+            var fieldId = key.substring(WatchableCellValuesInFieldKeyPrefix.length); // Assert that fieldId is validly formatted, not that it is a valid fieldId in this table
+
+            (0, _error_utils.invariant)((0, _private_utils.isFieldId)(fieldId), 'fieldId passed as watchable fieldId is not a valid format' + fieldId);
+            fieldSelectionDefinition = {
+              type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+              fieldIds: [fieldId]
+            };
+
+            onChangeCallback = changes => {
+              var modifiedCellValuesChanges = this._findMatchingBlockSubscriptionChanges(changes, _block_query_spec.BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE);
+
+              if (modifiedCellValuesChanges.length === 0) {
+                callbackForRegistration.call(context, originThis, key);
+                return;
+              }
+
+              var recordsChanged = [];
+              var _iteratorNormalCompletion4 = true;
+              var _didIteratorError4 = false;
+              var _iteratorError4 = undefined;
 
-      var fieldIdsToLoad = this._getFieldIdsToLoadFromWatchableKeys(validKeys);
+              try {
+                for (var _iterator4 = modifiedCellValuesChanges[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+                  var modifiedCellValuesChange = _step4.value;
+                  (0, _error_utils.invariant)(modifiedCellValuesChange.type === _block_query_spec.BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE, 'Modified cell value change is not a supported type');
+                  recordsChanged = recordsChanged.concat(Object.keys(modifiedCellValuesChange.fieldIdsByRecordId));
+                } // Why is this callback format different than when watching just cellValues?
+                // It's because in the past this was the format we used: https://github.com/Hyperbase/blocks-sdk/blob/32b6c59944f0d89d2c0b3b61b7db615145a8856b/packages/sdk/src/models/record_store.ts#L547-L554
+
+              } catch (err) {
+                _didIteratorError4 = true;
+                _iteratorError4 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                    _iterator4.return();
+                  }
+                } finally {
+                  if (_didIteratorError4) {
+                    throw _iteratorError4;
+                  }
+                }
+              }
+
+              callbackForRegistration.call(context, originThis, key, recordsChanged, fieldId);
+            };
 
-      if (fieldIdsToLoad.length > 0) {
-        (0, _private_utils.fireAndForgetPromise)(this.loadCellValuesInFieldIdsAsync.bind(this, fieldIdsToLoad));
+            break;
+          }
       }
 
+      return {
+        querySpecToSubscribeWith: recordQueryResult.__constructQuerySpecForBlockFieldSelectionSpec(fieldSelectionDefinition),
+        onChangeCallback
+      };
+    }
+  }, {
+    key: "watch",
+    value: function watch(keys, callbackForRegistration, context) {
+      throw (0, _error_utils.spawnError)('Must not call watch on record_store directly');
+    }
+  }, {
+    key: "watchWithRecordQueryResult",
+    value: function watchWithRecordQueryResult(_ref) {
+      var recordQueryResult = _ref.recordQueryResult,
+          keys = _ref.keys,
+          callbackForRegistration = _ref.callbackForRegistration,
+          context = _ref.context;
+
+      // Note that we do not call super.watch(), we use the
+      // alternative this._queryManager.watchWithQuerySpec
+      this._assertNotForceUnloaded();
+
+      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'table watch');
+
+      validKeys.forEach(validKey => {
+        var _this$_constructBlock = this._constructBlockQuerySpecAndCallbackForWatchableKeyWithRecordQueryResult(recordQueryResult, validKey, callbackForRegistration, context),
+            querySpecToSubscribeWith = _this$_constructBlock.querySpecToSubscribeWith,
+            onChangeCallback = _this$_constructBlock.onChangeCallback;
+
+        var onChangeCallbackThatIncrementsWatchChangeCount = args => {
+          // Normally calling __incrementOnChangeCount is handled by queryManager.watchWithQuerySpec
+          // however it will only increment the change count on the recordStore. In this case we ALSO
+          // need to increment the change count on the recordQueryResult.
+          recordQueryResult.__incrementOnChangeCount();
+
+          onChangeCallback(args);
+        };
+
+        this._queryManager.watchWithQuerySpec(querySpecToSubscribeWith, this, validKey, onChangeCallbackThatIncrementsWatchChangeCount, callbackForRegistration, context);
+      });
       return validKeys;
     }
   }, {
     key: "unwatch",
-    value: function unwatch(keys, callback, context) {
-      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStore.prototype), "unwatch", this).call(this, keys, callback, context);
+    value: function unwatch(keys, callbackForRegistration, context) {
+      // We have already unsubscribed from all watches (because query-based watches force data to be loaded)
+      // so no watches are subscribed
+      if (this._isForceUnloaded) {
+        return [];
+      } // We warn instead of throw here because we used to warn instead of throw and don't
+      // want to make a breaking change.
 
-      var fieldIdsToUnload = this._getFieldIdsToLoadFromWatchableKeys(validKeys);
 
-      if (fieldIdsToUnload.length > 0) {
-        this.unloadCellValuesInFieldIds(fieldIdsToUnload);
-      }
+      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'table unwatch', true);
 
+      validKeys.forEach(key => this._queryManager.unwatchFromQueryKey(key, callbackForRegistration, context));
       return validKeys;
     }
   }, {
-    key: "_getFieldIdsToLoadFromWatchableKeys",
-    value: function _getFieldIdsToLoadFromWatchableKeys(keys) {
-      var fieldIdsToLoad = [];
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var key = _step.value;
-
-          if (key.startsWith(WatchableCellValuesInFieldKeyPrefix)) {
-            var fieldId = key.substring(WatchableCellValuesInFieldKeyPrefix.length);
-            fieldIdsToLoad.push(fieldId);
-          } else if (key === WatchableRecordStoreKeys.records || key === WatchableRecordStoreKeys.recordIds) {
-            fieldIdsToLoad.push(this._getFieldIdForCausingRecordMetadataToLoad());
-          }
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
+    key: "isRecordDeleted",
+    value: function isRecordDeleted(recordId) {
+      return this._getRecordStoreForTable().isRecordDeleted(recordId);
+    } // Maybe add a comment "pending removal of inheriting from parent class AbstractModelWithAsyncData"
+    // istanbul ignore next
 
-      return fieldIdsToLoad;
-    }
   }, {
     key: "_onChangeIsDataLoaded",
-    value: function _onChangeIsDataLoaded() {} // noop
-
+    value: function _onChangeIsDataLoaded() {
+      throw (0, _error_utils.spawnError)('internal error - onChangeIsDataLoaded illegal to call on record_store');
+    }
     /**
      * The records in this table. The order is arbitrary since records are
      * only ordered in the context of a specific view.
      */
 
+  }, {
+    key: "isRecordLoaded",
+    value: function isRecordLoaded(recordId) {
+      return this._getRecordStoreForTable().isRecordPartiallyLoaded(recordId);
+    }
   }, {
     key: "getRecordByIdIfExists",
     value: function getRecordByIdIfExists(recordId) {
-      var recordsById = this._data.recordsById;
-      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
+      (0, _error_utils.invariant)(this._loadedQuerySpecIds.size > 0, 'Record metadata is not loaded');
       (0, _error_utils.invariant)(typeof recordId === 'string', 'getRecordById expects a string');
 
-      if (!recordsById[recordId]) {
+      if (!this._getRecordStoreForTable().isRecordPartiallyLoaded(recordId)) {
         return null;
       } else {
         if (this._recordModelsById[recordId]) {
@@ -225,76 +456,64 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "__onDataDeletion",
     value: function __onDataDeletion() {
-      // also need to call unloadCellValuesInFieldIds because otherwise
-      // on the hyperbase side, the old record store would still be subscribed
-      // to the cell values and it will refuse a request for new subscription
-      for (var _i = 0, _Object$keys = Object.keys(this._cellValuesRetainCountByFieldId); _i < _Object$keys.length; _i++) {
-        var fieldId = _Object$keys[_i];
-
-        while (this._cellValuesRetainCountByFieldId[fieldId] && this._cellValuesRetainCountByFieldId[fieldId] > 0) {
-          this.unloadCellValuesInFieldIds([fieldId]);
-        }
-      }
-
-      this._forceUnload(); // similarly unsubscribe from the view data.
-      // this comes after _forceUnload to avoid over releasing the table data.
+      this._forceUnload();
 
+      this._queryManager.forceUnloadWatchesOnWatchableModel(this);
 
-      var _iteratorNormalCompletion2 = true;
-      var _didIteratorError2 = false;
-      var _iteratorError2 = undefined;
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
 
       try {
-        for (var _iterator2 = (0, _private_utils.values)(this._viewDataStoresByViewId)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-          var viewDataStore = _step2.value;
+        for (var _iterator5 = this._forceUnloadCallbacks[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var forceUnloadCallback = _step5.value;
+          forceUnloadCallback();
+        } // similarly unsubscribe from the view data.
+        // this comes after _forceUnload to avoid over releasing the table data.
 
-          viewDataStore.__onDataDeletion();
-        }
       } catch (err) {
-        _didIteratorError2 = true;
-        _iteratorError2 = err;
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-            _iterator2.return();
+          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+            _iterator5.return();
           }
         } finally {
-          if (_didIteratorError2) {
-            throw _iteratorError2;
+          if (_didIteratorError5) {
+            throw _iteratorError5;
           }
         }
       }
-    }
-    /**
-     * Record metadata means record IDs, createdTime, and commentCount are loaded.
-     * Record metadata must be loaded before creating, deleting, or updating records.
-     */
 
-  }, {
-    key: "loadRecordMetadataAsync",
-    value: function loadRecordMetadataAsync() {
-      return _regenerator.default.async(function loadRecordMetadataAsync$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              _context.next = 2;
-              return _regenerator.default.awrap(this.loadCellValuesInFieldIdsAsync([this._getFieldIdForCausingRecordMetadataToLoad()]));
+      var _iteratorNormalCompletion6 = true;
+      var _didIteratorError6 = false;
+      var _iteratorError6 = undefined;
 
-            case 2:
-              return _context.abrupt("return", _context.sent);
+      try {
+        for (var _iterator6 = (0, _private_utils.values)(this._viewDataStoresByViewId)[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+          var viewDataStore = _step6.value;
 
-            case 3:
-            case "end":
-              return _context.stop();
+          viewDataStore.__onDataDeletion();
+        }
+      } catch (err) {
+        _didIteratorError6 = true;
+        _iteratorError6 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+            _iterator6.return();
+          }
+        } finally {
+          if (_didIteratorError6) {
+            throw _iteratorError6;
           }
         }
-      }, null, this);
-    }
-  }, {
-    key: "unloadRecordMetadata",
-    value: function unloadRecordMetadata() {
-      this.unloadCellValuesInFieldIds([this._getFieldIdForCausingRecordMetadataToLoad()]);
-    }
+      }
+    } // TODO: (#proj-blocks-sdk-record-limits) Determine if we need this function,
+    // we shouldn't need to load the primary field in order to load metadata.
+    // (but may want to require it for the first version of the sdk we release)
+
   }, {
     key: "_getFieldIdForCausingRecordMetadataToLoad",
     value: function _getFieldIdForCausingRecordMetadataToLoad() {
@@ -305,707 +524,276 @@ function (_AbstractModelWithAsy) {
       return this._primaryFieldId;
     }
   }, {
-    key: "areCellValuesLoadedForFieldId",
-    value: function areCellValuesLoadedForFieldId(fieldId) {
-      return this.isDataLoaded || this._areCellValuesLoadedByFieldId[fieldId] || false;
+    key: "isRecordCellValueLoadedForFieldId",
+    value: function isRecordCellValueLoadedForFieldId(recordId, fieldId) {
+      return this._getRecordStoreForTable().isRecordCellValueLoadedForFieldId(recordId, fieldId);
     }
   }, {
-    key: "loadCellValuesInFieldIdsAsync",
-    value: function loadCellValuesInFieldIdsAsync(fieldIds) {
-      var fieldIdsWhichAreNotAlreadyLoadedOrLoading, pendingLoadPromises, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, _fieldId, pendingLoadPromise, loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise, _iteratorNormalCompletion4, _didIteratorError4, _iteratorError4, _iterator4, _step4, fieldId;
-
-      return _regenerator.default.async(function loadCellValuesInFieldIdsAsync$(_context2) {
-        while (1) {
-          switch (_context2.prev = _context2.next) {
-            case 0:
-              this._assertNotForceUnloaded();
-
-              fieldIdsWhichAreNotAlreadyLoadedOrLoading = [];
-              pendingLoadPromises = [];
-              _iteratorNormalCompletion3 = true;
-              _didIteratorError3 = false;
-              _iteratorError3 = undefined;
-              _context2.prev = 6;
-
-              for (_iterator3 = fieldIds[Symbol.iterator](); !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-                _fieldId = _step3.value;
-
-                if (this._cellValuesRetainCountByFieldId[_fieldId] !== undefined) {
-                  this._cellValuesRetainCountByFieldId[_fieldId]++;
-                } else {
-                  this._cellValuesRetainCountByFieldId[_fieldId] = 1;
-                } // NOTE: we don't use this.areCellValuesLoadedForFieldId() here because
-                // that will return true if the cell values are loaded as a result
-                // of the entire table being loaded. In that scenario, we still
-                // want to separately load the cell values for the field so there
-                // is a separate subscription. Otherwise, when the table data unloads,
-                // the field data would unload as well. This can be improved by just
-                // subscribing to the field data without fetching it, since the cell
-                // values are already in the block frame.
-
-
-                if (!this._areCellValuesLoadedByFieldId[_fieldId]) {
-                  pendingLoadPromise = this._pendingCellValuesLoadPromiseByFieldId[_fieldId];
-
-                  if (pendingLoadPromise) {
-                    pendingLoadPromises.push(pendingLoadPromise);
-                  } else {
-                    fieldIdsWhichAreNotAlreadyLoadedOrLoading.push(_fieldId);
-                  }
-                }
-              }
-
-              _context2.next = 14;
-              break;
-
-            case 10:
-              _context2.prev = 10;
-              _context2.t0 = _context2["catch"](6);
-              _didIteratorError3 = true;
-              _iteratorError3 = _context2.t0;
-
-            case 14:
-              _context2.prev = 14;
-              _context2.prev = 15;
-
-              if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                _iterator3.return();
-              }
-
-            case 17:
-              _context2.prev = 17;
-
-              if (!_didIteratorError3) {
-                _context2.next = 20;
-                break;
-              }
-
-              throw _iteratorError3;
-
-            case 20:
-              return _context2.finish(17);
-
-            case 21:
-              return _context2.finish(14);
-
-            case 22:
-              if (!(fieldIdsWhichAreNotAlreadyLoadedOrLoading.length > 0)) {
-                _context2.next = 45;
-                break;
-              }
-
-              // Could inline _loadCellValuesInFieldIdsAsync, but following the
-              // pattern from AbstractModelWithAsyncData where the public method
-              // is responsible for updating retain counts and the private method
-              // actually fetches data.
-              loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise = this._loadCellValuesInFieldIdsAsync(fieldIdsWhichAreNotAlreadyLoadedOrLoading);
-              pendingLoadPromises.push(loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise);
-              _iteratorNormalCompletion4 = true;
-              _didIteratorError4 = false;
-              _iteratorError4 = undefined;
-              _context2.prev = 28;
-
-              for (_iterator4 = fieldIdsWhichAreNotAlreadyLoadedOrLoading[Symbol.iterator](); !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-                fieldId = _step4.value;
-                this._pendingCellValuesLoadPromiseByFieldId[fieldId] = loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise;
-              } // Doing `.then` instead of performing these actions directly in
-              // _loadCellValuesInFieldIdsAsync so this is similar to
-              // AbstractModelWithAsyncData. The idea is to refactor to avoid code
-              // duplication, so keeping them similar for now hopefully will make the
-              // refactor simpler.
-
-
-              _context2.next = 36;
-              break;
-
-            case 32:
-              _context2.prev = 32;
-              _context2.t1 = _context2["catch"](28);
-              _didIteratorError4 = true;
-              _iteratorError4 = _context2.t1;
-
-            case 36:
-              _context2.prev = 36;
-              _context2.prev = 37;
-
-              if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                _iterator4.return();
-              }
-
-            case 39:
-              _context2.prev = 39;
-
-              if (!_didIteratorError4) {
-                _context2.next = 42;
-                break;
-              }
-
-              throw _iteratorError4;
-
-            case 42:
-              return _context2.finish(39);
-
-            case 43:
-              return _context2.finish(36);
-
-            case 44:
-              loadFieldsWhichAreNotAlreadyLoadedOrLoadingPromise.then(changedKeys => {
-                var _iteratorNormalCompletion5 = true;
-                var _didIteratorError5 = false;
-                var _iteratorError5 = undefined;
-
-                try {
-                  for (var _iterator5 = fieldIdsWhichAreNotAlreadyLoadedOrLoading[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-                    var fieldId = _step5.value;
-                    this._areCellValuesLoadedByFieldId[fieldId] = true;
-                    this._pendingCellValuesLoadPromiseByFieldId[fieldId] = undefined;
-                  }
-                } catch (err) {
-                  _didIteratorError5 = true;
-                  _iteratorError5 = err;
-                } finally {
-                  try {
-                    if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-                      _iterator5.return();
-                    }
-                  } finally {
-                    if (_didIteratorError5) {
-                      throw _iteratorError5;
-                    }
-                  }
-                }
-
-                var _iteratorNormalCompletion6 = true;
-                var _didIteratorError6 = false;
-                var _iteratorError6 = undefined;
-
-                try {
-                  for (var _iterator6 = changedKeys[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
-                    var key = _step6.value;
-
-                    this._onChange(key);
-                  }
-                } catch (err) {
-                  _didIteratorError6 = true;
-                  _iteratorError6 = err;
-                } finally {
-                  try {
-                    if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-                      _iterator6.return();
-                    }
-                  } finally {
-                    if (_didIteratorError6) {
-                      throw _iteratorError6;
-                    }
-                  }
-                }
-              });
-
-            case 45:
-              _context2.next = 47;
-              return _regenerator.default.awrap(Promise.all(pendingLoadPromises));
-
-            case 47:
-            case "end":
-              return _context2.stop();
-          }
-        }
-      }, null, this, [[6, 10, 14, 22], [15,, 17, 21], [28, 32, 36, 44], [37,, 39, 43]]);
+    key: "getRecordCellValueByFieldId",
+    value: function getRecordCellValueByFieldId(recordId, fieldId) {
+      return this._getRecordStoreForTable().getRecordCellValueByFieldId(recordId, fieldId);
     }
   }, {
-    key: "_loadCellValuesInFieldIdsAsync",
-    value: function _loadCellValuesInFieldIdsAsync(fieldIds) {
-      var _ref, newRecordsById, existingRecordsById, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, _step7$value, recordId, newRecordObj, existingRecordObj, existingCellValuesByFieldId, i, fieldId, changedKeys;
-
-      return _regenerator.default.async(function _loadCellValuesInFieldIdsAsync$(_context3) {
+    key: "getRecordCommentCount",
+    value: function getRecordCommentCount(recordId) {
+      return this._getRecordStoreForTable().getRecordCommentCount(recordId);
+    }
+  }, {
+    key: "getRecordCreatedTime",
+    value: function getRecordCreatedTime(recordId) {
+      return this._getRecordStoreForTable().getRecordCreatedTime(recordId);
+    }
+  }, {
+    key: "_loadCellValuesForQueryAsync",
+    value: function _loadCellValuesForQueryAsync(query) {
+      var querySpecIdPromise, onForceUnload, querySpecId;
+      return _regenerator.default.async(function _loadCellValuesForQueryAsync$(_context2) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
-              _context3.next = 2;
-              return _regenerator.default.awrap(this._airtableInterface.fetchAndSubscribeToCellValuesInFieldsAsync(this.tableId, fieldIds));
-
-            case 2:
-              _ref = _context3.sent;
-              newRecordsById = _ref.recordsById;
-
-              // Merge with existing data.
-              if (!this._data.recordsById) {
-                this._data.recordsById = {};
-              }
-
-              existingRecordsById = this._data.recordsById;
-              _iteratorNormalCompletion7 = true;
-              _didIteratorError7 = false;
-              _iteratorError7 = undefined;
-              _context3.prev = 9;
-
-              for (_iterator7 = (0, _private_utils.entries)((0, _private_utils.cast)(newRecordsById))[Symbol.iterator](); !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-                _step7$value = (0, _slicedToArray2.default)(_step7.value, 2), recordId = _step7$value[0], newRecordObj = _step7$value[1];
-
-                if (!(0, _private_utils.has)(existingRecordsById, recordId)) {
-                  existingRecordsById[recordId] = newRecordObj;
-                } else {
-                  existingRecordObj = existingRecordsById[recordId]; // Metadata (createdTime, commentCount) should already be up to date,
-                  // but just verify for sanity. If this doesn't catch anything, can
-                  // remove it for perf.
-
-                  (0, _error_utils.invariant)(existingRecordObj.commentCount === newRecordObj.commentCount, 'comment count out of sync');
-                  (0, _error_utils.invariant)(existingRecordObj.createdTime === newRecordObj.createdTime, 'created time out of sync');
-
-                  if (!existingRecordObj.cellValuesByFieldId) {
-                    existingRecordObj.cellValuesByFieldId = {};
-                  }
-
-                  existingCellValuesByFieldId = existingRecordObj.cellValuesByFieldId;
-
-                  for (i = 0; i < fieldIds.length; i++) {
-                    fieldId = fieldIds[i];
-                    existingCellValuesByFieldId[fieldId] = newRecordObj.cellValuesByFieldId ? newRecordObj.cellValuesByFieldId[fieldId] : undefined;
+              this._assertNotForceUnloaded(); // We send all queries through query manager. PublicAirtableInterface does
+              // all reference counting for queries, and doesn't send cell data over the bridge
+              // if it's already being tracked in the PublicRecordStore.
+
+
+              querySpecIdPromise = this._sdk._queryManager.fetchAndSubscribeToQueryAsync(_objectSpread({}, query, {
+                sourceTableId: this.tableId
+              }));
+
+              onForceUnload = () => {
+                var querySpecId;
+                return _regenerator.default.async(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        _context.next = 2;
+                        return _regenerator.default.awrap(querySpecIdPromise);
+
+                      case 2:
+                        querySpecId = _context.sent;
+
+                        if (this._loadedQuerySpecIds.has(querySpecId)) {
+                          this._unloadCellValuesForQueryIdsIgnoringForceUnloadedness([querySpecId]);
+                        }
+
+                      case 4:
+                      case "end":
+                        return _context.stop();
+                    }
                   }
-                }
-              }
-
-              _context3.next = 17;
-              break;
-
-            case 13:
-              _context3.prev = 13;
-              _context3.t0 = _context3["catch"](9);
-              _didIteratorError7 = true;
-              _iteratorError7 = _context3.t0;
-
-            case 17:
-              _context3.prev = 17;
-              _context3.prev = 18;
-
-              if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-                _iterator7.return();
-              }
-
-            case 20:
-              _context3.prev = 20;
-
-              if (!_didIteratorError7) {
-                _context3.next = 23;
-                break;
-              }
-
-              throw _iteratorError7;
+                }, null, this);
+              };
 
-            case 23:
-              return _context3.finish(20);
+              this._forceUnloadCallbacks.push(onForceUnload);
 
-            case 24:
-              return _context3.finish(17);
+              _context2.next = 6;
+              return _regenerator.default.awrap(querySpecIdPromise);
 
-            case 25:
-              changedKeys = fieldIds.map(fieldId => WatchableCellValuesInFieldKeyPrefix + fieldId); // Need to trigger onChange for records and recordIds since watching either
-              // of those causes record metadata to be loaded (via _getFieldIdForCausingRecordMetadataToLoad)
-              // and by convention we trigger a change event when data loads.
+            case 6:
+              querySpecId = _context2.sent;
 
-              changedKeys.push(WatchableRecordStoreKeys.records);
-              changedKeys.push(WatchableRecordStoreKeys.recordIds); // Also trigger cellValues changes since the cell values in the fields
-              // are now loaded.
+              this._loadedQuerySpecIds.add(querySpecId);
 
-              changedKeys.push(WatchableRecordStoreKeys.cellValues);
-              return _context3.abrupt("return", changedKeys);
+              return _context2.abrupt("return", querySpecId);
 
-            case 30:
+            case 9:
             case "end":
-              return _context3.stop();
+              return _context2.stop();
           }
         }
-      }, null, this, [[9, 13, 17, 25], [18,, 20, 24]]);
+      }, null, this);
     }
   }, {
-    key: "unloadCellValuesInFieldIds",
-    value: function unloadCellValuesInFieldIds(fieldIds) {
+    key: "_unloadCellValuesForQueryIds",
+    value: function _unloadCellValuesForQueryIds(queryIds) {
       if (this._isForceUnloaded) {
         return;
       }
 
-      var fieldIdsWithZeroRetainCount = [];
-      var _iteratorNormalCompletion8 = true;
-      var _didIteratorError8 = false;
-      var _iteratorError8 = undefined;
-
-      try {
-        for (var _iterator8 = fieldIds[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
-          var fieldId = _step8.value;
-          var fieldRetainCount = this._cellValuesRetainCountByFieldId[fieldId] || 0;
-          fieldRetainCount--;
+      this._unloadCellValuesForQueryIdsIgnoringForceUnloadedness(queryIds);
+    }
+  }, {
+    key: "_unloadCellValuesForQueryIdsIgnoringForceUnloadedness",
+    value: function _unloadCellValuesForQueryIdsIgnoringForceUnloadedness(queryIds) {
+      this._queryManager.unsubscribeFromQueryIds(queryIds);
 
-          if (fieldRetainCount < 0) {
-            console.log('Field data over-released'); // eslint-disable-line no-console
+      var _iteratorNormalCompletion7 = true;
+      var _didIteratorError7 = false;
+      var _iteratorError7 = undefined;
 
-            fieldRetainCount = 0;
-          }
+      try {
+        for (var _iterator7 = queryIds[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+          var queryId = _step7.value;
 
-          this._cellValuesRetainCountByFieldId[fieldId] = fieldRetainCount;
+          var queryIdWasLoaded = this._loadedQuerySpecIds.delete(queryId);
 
-          if (fieldRetainCount === 0) {
-            fieldIdsWithZeroRetainCount.push(fieldId);
+          if (!queryIdWasLoaded) {
+            (0, _warning.default)('Over unsubscribed from record store');
           }
         }
       } catch (err) {
-        _didIteratorError8 = true;
-        _iteratorError8 = err;
+        _didIteratorError7 = true;
+        _iteratorError7 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
-            _iterator8.return();
+          if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+            _iterator7.return();
           }
         } finally {
-          if (_didIteratorError8) {
-            throw _iteratorError8;
+          if (_didIteratorError7) {
+            throw _iteratorError7;
           }
         }
       }
-
-      if (fieldIdsWithZeroRetainCount.length > 0) {
-        // Don't unload immediately. Wait a while in case something else
-        // requests the data, so we can avoid going back to liveapp or
-        // the network.
-        setTimeout(() => {
-          // Make sure the retain count is still zero, since it may
-          // have been incremented before the timeout fired.
-          var fieldIdsToUnload = fieldIdsWithZeroRetainCount.filter(fieldId => {
-            return this._cellValuesRetainCountByFieldId[fieldId] === 0;
-          });
-
-          if (fieldIdsToUnload.length > 0) {
-            // Set _areCellValuesLoadedByFieldId to false before calling _unloadCellValuesInFieldIds
-            // since _unloadCellValuesInFieldIds will check if *any* fields are still loaded.
-            var _iteratorNormalCompletion9 = true;
-            var _didIteratorError9 = false;
-            var _iteratorError9 = undefined;
-
-            try {
-              for (var _iterator9 = fieldIdsToUnload[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
-                var fieldId = _step9.value;
-                this._areCellValuesLoadedByFieldId[fieldId] = false;
-              }
-            } catch (err) {
-              _didIteratorError9 = true;
-              _iteratorError9 = err;
-            } finally {
-              try {
-                if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
-                  _iterator9.return();
-                }
-              } finally {
-                if (_didIteratorError9) {
-                  throw _iteratorError9;
+    }
+  }, {
+    key: "loadViewDataStoreAndCellValuesForFieldIdsAsync",
+    value: function loadViewDataStoreAndCellValuesForFieldIdsAsync(viewId, fieldIdsToLoadOrNullIfAllFields) {
+      var fieldSelection;
+      return _regenerator.default.async(function loadViewDataStoreAndCellValuesForFieldIdsAsync$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              // We do not need to initialize a ViewDataStore, as it's a thin wrapper around the
+              // hyperbase viewMetadataStore which can be initialized after a query inflates the data.
+              // A complicating factor is what happens if (this) recordStore or viewDataStore are
+              // forceUnload'ed. It is fine to track the query in only record store because:
+              //  - If either is force unloaded without the other the query must be kept active
+              //  - If a recordStore is force unloaded the children viewDataStores are also unloaded
+              //    because the table has been deleted. Therefore we can track it in only record_store.
+              fieldSelection = fieldIdsToLoadOrNullIfAllFields ? {
+                type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+                fieldIds: fieldIdsToLoadOrNullIfAllFields
+              } : {
+                type: _block_query_spec.BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE
+              }; // By issuing this query we both populate cell values requested AND view metadata
+              // Cell values requested will be accessible inside record_store
+
+              _context3.next = 3;
+              return _regenerator.default.awrap(this._loadCellValuesForQueryAsync({
+                sourceType: _block_query_spec.BlockQuerySourceType.VIEW,
+                sourceViewId: viewId,
+                recordSelection: {
+                  fieldSelection
+                },
+                viewMetadataSelection: {
+                  shouldIncludeVisibleRecordIds: true,
+                  shouldIncludeFieldOrder: true,
+                  shouldIncludeGroups: true,
+                  shouldIncludeGroupingLevels: true,
+                  shouldIncludeColorsForRecordId: true
                 }
-              }
-            }
+              }));
 
-            this._unloadCellValuesInFieldIds(fieldIdsToUnload);
+            case 3:
+              return _context3.abrupt("return", _context3.sent);
+
+            case 4:
+            case "end":
+              return _context3.stop();
           }
-        }, _abstract_model_with_async_data.default.__DATA_UNLOAD_DELAY_MS);
-      }
+        }
+      }, null, this);
     }
   }, {
-    key: "_unloadCellValuesInFieldIds",
-    value: function _unloadCellValuesInFieldIds(fieldIds) {
-      this._airtableInterface.unsubscribeFromCellValuesInFields(this.tableId, fieldIds);
-
-      this._afterUnloadDataOrUnloadCellValuesInFieldIds(fieldIds);
+    key: "unloadViewDataStoreAndCellValuesWithQueryIds",
+    value: function unloadViewDataStoreAndCellValuesWithQueryIds(queryIds) {
+      // Note that we do not update _numQueriesSubscribedToAllRecords since this query
+      // does not subscribe to all cells in a table.
+      this._unloadCellValuesForQueryIds(queryIds);
     }
   }, {
-    key: "_loadDataAsync",
-    value: function _loadDataAsync() {
-      var tableData, changedKeys, _iteratorNormalCompletion10, _didIteratorError10, _iteratorError10, _iterator10, _step10, fieldId;
-
-      return _regenerator.default.async(function _loadDataAsync$(_context4) {
+    key: "loadAllCellValuesInFieldIdsAsync",
+    value: function loadAllCellValuesInFieldIdsAsync(fieldIds) {
+      var queryId;
+      return _regenerator.default.async(function loadAllCellValuesInFieldIdsAsync$(_context4) {
         while (1) {
           switch (_context4.prev = _context4.next) {
             case 0:
               _context4.next = 2;
-              return _regenerator.default.awrap(this._airtableInterface.fetchAndSubscribeToTableDataAsync(this.tableId));
+              return _regenerator.default.awrap(this._loadCellValuesForQueryAsync({
+                sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
+                recordSelection: {
+                  fieldSelection: {
+                    type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+                    fieldIds
+                  }
+                }
+              }));
 
             case 2:
-              tableData = _context4.sent;
-              this._data.recordsById = tableData.recordsById;
-              changedKeys = [WatchableRecordStoreKeys.records, WatchableRecordStoreKeys.recordIds, WatchableRecordStoreKeys.cellValues];
-              _iteratorNormalCompletion10 = true;
-              _didIteratorError10 = false;
-              _iteratorError10 = undefined;
-              _context4.prev = 8;
-
-              for (_iterator10 = (0, _private_utils.keys)(this._data.fieldsById)[Symbol.iterator](); !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
-                fieldId = _step10.value;
-                changedKeys.push(WatchableCellValuesInFieldKeyPrefix + fieldId);
-              }
+              queryId = _context4.sent;
+              this._numQueriesSubscribedToAllRecords += 1;
+              return _context4.abrupt("return", queryId);
 
-              _context4.next = 16;
-              break;
-
-            case 12:
-              _context4.prev = 12;
-              _context4.t0 = _context4["catch"](8);
-              _didIteratorError10 = true;
-              _iteratorError10 = _context4.t0;
-
-            case 16:
-              _context4.prev = 16;
-              _context4.prev = 17;
-
-              if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
-                _iterator10.return();
-              }
-
-            case 19:
-              _context4.prev = 19;
-
-              if (!_didIteratorError10) {
-                _context4.next = 22;
-                break;
-              }
-
-              throw _iteratorError10;
-
-            case 22:
-              return _context4.finish(19);
-
-            case 23:
-              return _context4.finish(16);
-
-            case 24:
-              return _context4.abrupt("return", changedKeys);
-
-            case 25:
+            case 5:
             case "end":
               return _context4.stop();
           }
         }
-      }, null, this, [[8, 12, 16, 24], [17,, 19, 23]]);
-    }
-  }, {
-    key: "_unloadData",
-    value: function _unloadData() {
-      this._airtableInterface.unsubscribeFromTableData(this.tableId);
-
-      this._afterUnloadDataOrUnloadCellValuesInFieldIds();
+      }, null, this);
     }
   }, {
-    key: "_afterUnloadDataOrUnloadCellValuesInFieldIds",
-    value: function _afterUnloadDataOrUnloadCellValuesInFieldIds(unloadedFieldIds) {
-      var areAnyFieldsLoaded = this.isDataLoaded || (0, _private_utils.values)(this._areCellValuesLoadedByFieldId).some(isLoaded => isLoaded);
-
-      if (!this.isDeleted) {
-        if (!areAnyFieldsLoaded) {
-          this._data.recordsById = undefined;
-        } else if (!this.isDataLoaded) {
-          var fieldIdsToClear;
-
-          if (unloadedFieldIds) {
-            // Specific fields were unloaded, so clear out the cell values for those fields.
-            fieldIdsToClear = unloadedFieldIds;
-          } else {
-            // The entire table was unloaded, but some individual fields are still loaded.
-            // We need to clear out the cell values of every field that was unloaded.
-            // This is kind of slow, but hopefully uncommon.
-            var fieldIds = Object.keys(this._data.fieldsById);
-            fieldIdsToClear = fieldIds.filter(fieldId => !this._areCellValuesLoadedByFieldId[fieldId]);
-          }
-
-          var recordsById = this._data.recordsById;
-          var _iteratorNormalCompletion11 = true;
-          var _didIteratorError11 = false;
-          var _iteratorError11 = undefined;
-
-          try {
-            for (var _iterator11 = (0, _private_utils.values)(recordsById || {})[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
-              var recordObj = _step11.value;
+    key: "loadAllCellValuesAsync",
+    value: function loadAllCellValuesAsync() {
+      var queryId;
+      return _regenerator.default.async(function loadAllCellValuesAsync$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return _regenerator.default.awrap(this._loadCellValuesForQueryAsync({
+                sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
+                recordSelection: {
+                  fieldSelection: {
+                    type: _block_query_spec.BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE
+                  }
+                }
+              }));
 
-              for (var i = 0; i < fieldIdsToClear.length; i++) {
-                var fieldId = fieldIdsToClear[i];
+            case 2:
+              queryId = _context5.sent;
+              this._numQueriesSubscribedToAllRecords += 1;
+              return _context5.abrupt("return", queryId);
 
-                if (recordObj.cellValuesByFieldId) {
-                  recordObj.cellValuesByFieldId[fieldId] = undefined;
-                }
-              }
-            }
-          } catch (err) {
-            _didIteratorError11 = true;
-            _iteratorError11 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
-                _iterator11.return();
-              }
-            } finally {
-              if (_didIteratorError11) {
-                throw _iteratorError11;
-              }
-            }
+            case 5:
+            case "end":
+              return _context5.stop();
           }
         }
-      }
-
-      if (!areAnyFieldsLoaded) {
-        this._recordModelsById = {};
-      }
+      }, null, this);
     }
   }, {
-    key: "triggerOnChangeForDirtyPaths",
-    value: function triggerOnChangeForDirtyPaths(dirtyPaths) {
-      if (this.isRecordMetadataLoaded && dirtyPaths.recordsById) {
-        // Since tables don't have a record order, need to detect if a record
-        // was created or deleted and trigger onChange for records.
-        var dirtyFieldIdsSet = {};
-        var addedRecordIds = [];
-        var removedRecordIds = [];
-        var _iteratorNormalCompletion12 = true;
-        var _didIteratorError12 = false;
-        var _iteratorError12 = undefined;
-
-        try {
-          for (var _iterator12 = (0, _private_utils.entries)(dirtyPaths.recordsById)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
-            var _step12$value = (0, _slicedToArray2.default)(_step12.value, 2),
-                recordId = _step12$value[0],
-                dirtyRecordPaths = _step12$value[1];
-
-            if (dirtyRecordPaths && dirtyRecordPaths._isDirty) {
-              // If the entire record is dirty, it was either created or deleted.
-              (0, _error_utils.invariant)(this._data.recordsById, 'No recordsById');
-
-              if ((0, _private_utils.has)(this._data.recordsById, recordId)) {
-                addedRecordIds.push(recordId);
-              } else {
-                removedRecordIds.push(recordId);
-                var recordModel = this._recordModelsById[recordId];
-
-                if (recordModel) {
-                  // Remove the Record model if it was deleted.
-                  delete this._recordModelsById[recordId];
-                }
-              }
-            } else {
-              var _recordModel = this._recordModelsById[recordId];
-
-              if (_recordModel) {
-                _recordModel.__triggerOnChangeForDirtyPaths(dirtyRecordPaths);
-              }
-            }
-
-            var cellValuesByFieldId = dirtyRecordPaths.cellValuesByFieldId;
-
-            if (cellValuesByFieldId) {
-              for (var _i2 = 0, _Object$keys2 = Object.keys(cellValuesByFieldId); _i2 < _Object$keys2.length; _i2++) {
-                var fieldId = _Object$keys2[_i2];
-                dirtyFieldIdsSet[fieldId] = true;
-              }
-            }
-          } // Now that we've composed our created/deleted record ids arrays, let's fire
-          // the records onChange event if any records were created or deleted.
-
-        } catch (err) {
-          _didIteratorError12 = true;
-          _iteratorError12 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
-              _iterator12.return();
-            }
-          } finally {
-            if (_didIteratorError12) {
-              throw _iteratorError12;
-            }
-          }
-        }
-
-        if (addedRecordIds.length > 0 || removedRecordIds.length > 0) {
-          this._onChange(WatchableRecordStoreKeys.records, {
-            addedRecordIds,
-            removedRecordIds
-          });
-
-          this._onChange(WatchableRecordStoreKeys.recordIds, {
-            addedRecordIds,
-            removedRecordIds
-          });
-        } // NOTE: this is an experimental (and somewhat messy) way to watch
-        // for changes to cells in a table, as an alternative to implementing
-        // full event bubbling. For now, it unblocks the things we want to
-        // build, but we may replace it.
-        // If we keep it, could be more efficient by not calling _onChange
-        // if there are no subscribers.
-        // TODO: don't trigger changes for fields that aren't supposed to be loaded
-        // (in some cases, e.g. record created, liveapp will send cell values
-        // that we're not subscribed to).
-
-
-        var fieldIds = Object.freeze(Object.keys(dirtyFieldIdsSet));
-        var recordIds = Object.freeze(Object.keys(dirtyPaths.recordsById));
-
-        if (fieldIds.length > 0 && recordIds.length > 0) {
-          this._onChange(WatchableRecordStoreKeys.cellValues, {
-            recordIds,
-            fieldIds
-          });
-        }
+    key: "unloadCellValuesForQueryIdsThatAreSubscribedToAllCells",
+    value: function unloadCellValuesForQueryIdsThatAreSubscribedToAllCells(queryIds) {
+      this._unloadCellValuesForQueryIds(queryIds);
 
-        var _iteratorNormalCompletion13 = true;
-        var _didIteratorError13 = false;
-        var _iteratorError13 = undefined;
+      this._numQueriesSubscribedToAllRecords -= queryIds.length;
+    } // Maybe add a comment "pending removal of inheriting from parent class AbstractModelWithAsyncData"
+    // istanbul ignore next
 
-        try {
-          for (var _iterator13 = fieldIds[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
-            var _fieldId2 = _step13.value;
+  }, {
+    key: "_loadDataAsync",
+    value: function _loadDataAsync() {
+      return _regenerator.default.async(function _loadDataAsync$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              throw (0, _error_utils.spawnError)('Internal error - SDK called loadData on record_store');
 
-            this._onChange(WatchableCellValuesInFieldKeyPrefix + _fieldId2, recordIds, _fieldId2);
-          }
-        } catch (err) {
-          _didIteratorError13 = true;
-          _iteratorError13 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
-              _iterator13.return();
-            }
-          } finally {
-            if (_didIteratorError13) {
-              throw _iteratorError13;
-            }
+            case 1:
+            case "end":
+              return _context6.stop();
           }
         }
-      }
-
-      if (dirtyPaths.viewOrder) {
-        // clean up deleted views
-        var _iteratorNormalCompletion14 = true;
-        var _didIteratorError14 = false;
-        var _iteratorError14 = undefined;
-
-        try {
-          for (var _iterator14 = (0, _private_utils.entries)(this._viewDataStoresByViewId)[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
-            var _step14$value = (0, _slicedToArray2.default)(_step14.value, 2),
-                viewId = _step14$value[0],
-                viewDataStore = _step14$value[1];
-
-            if (viewDataStore.isDeleted) {
-              viewDataStore.__onDataDeletion();
+      });
+    } // Maybe add a comment "pending removal of inheriting from parent class AbstractModelWithAsyncData"
+    // istanbul ignore next
 
-              delete this._viewDataStoresByViewId[viewId];
-            }
-          }
-        } catch (err) {
-          _didIteratorError14 = true;
-          _iteratorError14 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
-              _iterator14.return();
-            }
-          } finally {
-            if (_didIteratorError14) {
-              throw _iteratorError14;
-            }
-          }
-        }
-      }
+  }, {
+    key: "_unloadData",
+    value: function _unloadData() {
+      throw (0, _error_utils.spawnError)('Internal error - SDK called unloadData on record_store');
     }
   }, {
     key: "_dataOrNullIfDeleted",
@@ -1017,9 +805,7 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "records",
     get: function get() {
-      var recordsById = this._data.recordsById;
-      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
-      var records = Object.keys(recordsById).map(recordId => {
+      var records = this.recordIds.map(recordId => {
         var record = this.getRecordByIdIfExists(recordId);
         (0, _error_utils.invariant)(record, 'record');
         return record;
@@ -1034,14 +820,17 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "recordIds",
     get: function get() {
-      var recordsById = this._data.recordsById;
-      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
-      return Object.keys(recordsById);
+      (0, _error_utils.invariant)(this.isSubscribedToAllRecordsInTable, 'Record metadata is not loaded for all records in table');
+
+      var recordIds = this._getRecordStoreForTable().getPartiallyLoadedRecordIds();
+
+      (0, _error_utils.invariant)(recordIds, 'Record metadata is not loaded');
+      return recordIds;
     }
   }, {
-    key: "isRecordMetadataLoaded",
+    key: "isSubscribedToAllRecordsInTable",
     get: function get() {
-      return !!this._data.recordsById;
+      return this._numQueriesSubscribedToAllRecords > 0;
     }
   }]);
   return RecordStore;