@airtable/blocks 1.11.1-experimental-68738f2-20220526 → 1.13.0

package/dist/cjs/models/record_store.js

@@ -6,26 +6,20 @@ 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.entries");
 
 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", {
@@ -33,6 +27,8 @@ 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");
@@ -41,9 +37,11 @@ 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 _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
@@ -55,20 +53,12 @@ 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',
@@ -83,9 +73,8 @@ var WatchableCellValuesInFieldKeyPrefix = 'cellValuesInField:';
  */
 
 /**
- * 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.
+ * 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.
  *
  * @internal
  */
@@ -98,6 +87,16 @@ 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) {
@@ -109,15 +108,12 @@ 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), "_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", []);
+    (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), "_timeoutForRemovingFieldIds", null);
     _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
@@ -128,323 +124,96 @@ 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'); // 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.
-
+      (0, _error_utils.invariant)(this._data.viewsById[viewId], 'view must exist');
       var viewDataStore = new _view_data_store.default(this._sdk, this, viewId);
       this._viewDataStoresByViewId[viewId] = viewDataStore;
       return viewDataStore;
     }
   }, {
-    key: "sendViewDataDeletionIfViewIsDeleted",
-    value: function sendViewDataDeletionIfViewIsDeleted(viewId) {
-      var viewDataStoreIfExists = this._viewDataStoresByViewId[viewId];
-
-      if (viewDataStoreIfExists && viewDataStoreIfExists.isDeleted) {
-        viewDataStoreIfExists.__onDataDeletion();
-
-        delete this._viewDataStoresByViewId[viewId];
-      }
-    }
-  }, {
-    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;
-
-              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;
-                  }
-                }
-              }
+    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);
 
-              callbackForRegistration.call(context, originThis, key, recordsChanged, fieldId);
-            };
+      var fieldIdsToLoad = this._getFieldIdsToLoadFromWatchableKeys(validKeys);
 
-            break;
-          }
+      if (fieldIdsToLoad.length > 0) {
+        (0, _private_utils.fireAndForgetPromise)(this.loadCellValuesInFieldIdsAsync.bind(this, fieldIdsToLoad));
       }
 
-      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 priority = _ref.priority,
-          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(priority, querySpecToSubscribeWith, this, validKey, onChangeCallbackThatIncrementsWatchChangeCount, callbackForRegistration, context);
-      });
       return validKeys;
     }
   }, {
     key: "unwatch",
-    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.
+    value: function unwatch(keys, callback, context) {
+      var validKeys = (0, _get2.default)((0, _getPrototypeOf2.default)(RecordStore.prototype), "unwatch", this).call(this, keys, callback, context);
 
+      var fieldIdsToUnload = this._getFieldIdsToLoadFromWatchableKeys(validKeys);
 
-      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'table unwatch', true);
+      if (fieldIdsToUnload.length > 0) {
+        this.unloadCellValuesInFieldIds(fieldIdsToUnload);
+      }
 
-      validKeys.forEach(key => this._queryManager.unwatchFromQueryKey(key, callbackForRegistration, context));
       return validKeys;
     }
   }, {
-    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
+    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;
+          }
+        }
+      }
+
+      return fieldIdsToLoad;
+    }
   }, {
     key: "_onChangeIsDataLoaded",
-    value: function _onChangeIsDataLoaded() {
-      throw (0, _error_utils.spawnError)('internal error - onChangeIsDataLoaded illegal to call on record_store');
-    }
+    value: function _onChangeIsDataLoaded() {} // noop
+
     /**
      * 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) {
-      (0, _error_utils.invariant)(this._loadedQuerySpecIds.size > 0, 'Record metadata is not loaded');
+      var recordsById = this._data.recordsById;
+      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
       (0, _error_utils.invariant)(typeof recordId === 'string', 'getRecordById expects a string');
 
-      if (!this._getRecordStoreForTable().isRecordPartiallyLoaded(recordId)) {
+      if (!recordsById[recordId]) {
         return null;
       } else {
         if (this._recordModelsById[recordId]) {
@@ -459,64 +228,76 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "__onDataDeletion",
     value: function __onDataDeletion() {
-      this._forceUnload();
+      // 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._queryManager.forceUnloadWatchesOnWatchableModel(this);
 
-      var _iteratorNormalCompletion5 = true;
-      var _didIteratorError5 = false;
-      var _iteratorError5 = undefined;
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
 
       try {
-        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.
+        for (var _iterator2 = (0, _private_utils.values)(this._viewDataStoresByViewId)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var viewDataStore = _step2.value;
 
+          viewDataStore.__onDataDeletion();
+        }
       } catch (err) {
-        _didIteratorError5 = true;
-        _iteratorError5 = err;
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-            _iterator5.return();
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
           }
         } finally {
-          if (_didIteratorError5) {
-            throw _iteratorError5;
+          if (_didIteratorError2) {
+            throw _iteratorError2;
           }
         }
       }
+    }
+    /**
+     * Record metadata means record IDs, createdTime, and commentCount are loaded.
+     * Record metadata must be loaded before creating, deleting, or updating records.
+     */
 
-      var _iteratorNormalCompletion6 = true;
-      var _didIteratorError6 = false;
-      var _iteratorError6 = undefined;
+  }, {
+    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()]));
 
-      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 2:
+              return _context.abrupt("return", _context.sent);
 
-          viewDataStore.__onDataDeletion();
-        }
-      } catch (err) {
-        _didIteratorError6 = true;
-        _iteratorError6 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-            _iterator6.return();
-          }
-        } finally {
-          if (_didIteratorError6) {
-            throw _iteratorError6;
+            case 3:
+            case "end":
+              return _context.stop();
           }
         }
-      }
-    } // 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)
-
+      }, null, this);
+    }
+  }, {
+    key: "unloadRecordMetadata",
+    value: function unloadRecordMetadata() {
+      this.unloadCellValuesInFieldIds([this._getFieldIdForCausingRecordMetadataToLoad()]);
+    }
   }, {
     key: "_getFieldIdForCausingRecordMetadataToLoad",
     value: function _getFieldIdForCausingRecordMetadataToLoad() {
@@ -527,276 +308,770 @@ function (_AbstractModelWithAsy) {
       return this._primaryFieldId;
     }
   }, {
-    key: "isRecordCellValueLoadedForFieldId",
-    value: function isRecordCellValueLoadedForFieldId(recordId, fieldId) {
-      return this._getRecordStoreForTable().isRecordCellValueLoadedForFieldId(recordId, fieldId);
-    }
-  }, {
-    key: "getRecordCellValueByFieldId",
-    value: function getRecordCellValueByFieldId(recordId, fieldId) {
-      return this._getRecordStoreForTable().getRecordCellValueByFieldId(recordId, fieldId);
-    }
-  }, {
-    key: "getRecordCommentCount",
-    value: function getRecordCommentCount(recordId) {
-      return this._getRecordStoreForTable().getRecordCommentCount(recordId);
+    key: "areCellValuesLoadedForFieldId",
+    value: function areCellValuesLoadedForFieldId(fieldId) {
+      return this.isDataLoaded || this._areCellValuesLoadedByFieldId[fieldId] || false;
     }
   }, {
-    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) {
+    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(); // 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();
+              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;
                     }
                   }
-                }, null, this);
-              };
+                }
 
-              this._forceUnloadCallbacks.push(onForceUnload);
+                var _iteratorNormalCompletion6 = true;
+                var _didIteratorError6 = false;
+                var _iteratorError6 = undefined;
 
-              _context2.next = 6;
-              return _regenerator.default.awrap(querySpecIdPromise);
+                try {
+                  for (var _iterator6 = changedKeys[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+                    var key = _step6.value;
 
-            case 6:
-              querySpecId = _context2.sent;
+                    this._onChange(key);
+                  }
+                } catch (err) {
+                  _didIteratorError6 = true;
+                  _iteratorError6 = err;
+                } finally {
+                  try {
+                    if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+                      _iterator6.return();
+                    }
+                  } finally {
+                    if (_didIteratorError6) {
+                      throw _iteratorError6;
+                    }
+                  }
+                }
+              });
 
-              this._loadedQuerySpecIds.add(querySpecId);
+            case 45:
+              // Since we are incrementing fieldIds, it's necessary to restart any pending timeouts
+              // to unload data. This is because it's possible for a timeout to fire while a queryResult
+              // is actively unloading, and erroneously unload data. Data must be unloaded _after_ the queryResult.
+              this._restartTimeoutToUnloadFieldIdsIfTimeoutIsActive();
 
-              return _context2.abrupt("return", querySpecId);
+              _context2.next = 48;
+              return _regenerator.default.awrap(Promise.all(pendingLoadPromises));
 
-            case 9:
+            case 48:
             case "end":
               return _context2.stop();
           }
         }
-      }, null, this);
+      }, null, this, [[6, 10, 14, 22], [15,, 17, 21], [28, 32, 36, 44], [37,, 39, 43]]);
     }
   }, {
-    key: "_unloadCellValuesForQueryIds",
-    value: function _unloadCellValuesForQueryIds(queryIds) {
-      if (this._isForceUnloaded) {
-        return;
-      }
+    key: "_loadCellValuesInFieldIdsAsync",
+    value: function _loadCellValuesInFieldIdsAsync(fieldIds) {
+      var _ref, newRecordsById, existingRecordsById, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, _step7$value, recordId, newRecordObj, existingRecordObj, isCommentCountTypesSame, isCreatedTimeTypesSame, existingCellValuesByFieldId, i, fieldId, changedKeys;
+
+      return _regenerator.default.async(function _loadCellValuesInFieldIdsAsync$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.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 generally be up to date,
+                  // but can be out of date in the rare scenario where realtime
+                  // data has not yet been delivered to the SDK, but is populated in hyperbase
+                  // at the time this new fetch is executed.
+                  // istanbul ignore next
+
+                  if (existingRecordObj.commentCount !== newRecordObj.commentCount) {
+                    isCommentCountTypesSame = typeof existingRecordObj.commentCount !== typeof newRecordObj.commentCount;
+                    (0, _error_utils.logErrorToSentry)('comment count out of sync - types are same: %s', {
+                      isCommentCountTypesSame
+                    });
+                  } // istanbul ignore next
+
+
+                  if (existingRecordObj.createdTime !== newRecordObj.createdTime) {
+                    isCreatedTimeTypesSame = typeof existingRecordObj.createdTime !== typeof newRecordObj.createdTime;
+                    (0, _error_utils.logErrorToSentry)('created time out of sync - types are same: %s', {
+                      isCreatedTimeTypesSame
+                    });
+                  }
+
+                  if (!existingRecordObj.cellValuesByFieldId) {
+                    existingRecordObj.cellValuesByFieldId = {};
+                  }
+
+                  existingCellValuesByFieldId = existingRecordObj.cellValuesByFieldId;
 
-      this._unloadCellValuesForQueryIdsIgnoringForceUnloadedness(queryIds);
+                  for (i = 0; i < fieldIds.length; i++) {
+                    fieldId = fieldIds[i];
+                    existingCellValuesByFieldId[fieldId] = newRecordObj.cellValuesByFieldId ? newRecordObj.cellValuesByFieldId[fieldId] : undefined;
+                  }
+                }
+              }
+
+              _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;
+
+            case 23:
+              return _context3.finish(20);
+
+            case 24:
+              return _context3.finish(17);
+
+            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.
+
+              changedKeys.push(WatchableRecordStoreKeys.records);
+              changedKeys.push(WatchableRecordStoreKeys.recordIds); // Also trigger cellValues changes since the cell values in the fields
+              // are now loaded.
+
+              changedKeys.push(WatchableRecordStoreKeys.cellValues);
+              return _context3.abrupt("return", changedKeys);
+
+            case 30:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, null, this, [[9, 13, 17, 25], [18,, 20, 24]]);
     }
   }, {
-    key: "_unloadCellValuesForQueryIdsIgnoringForceUnloadedness",
-    value: function _unloadCellValuesForQueryIdsIgnoringForceUnloadedness(queryIds) {
-      this._queryManager.unsubscribeFromQueryIds(queryIds);
+    key: "unloadCellValuesInFieldIds",
+    value: function unloadCellValuesInFieldIds(fieldIds) {
+      if (this._isForceUnloaded) {
+        return;
+      }
 
-      var _iteratorNormalCompletion7 = true;
-      var _didIteratorError7 = false;
-      var _iteratorError7 = undefined;
+      var _iteratorNormalCompletion8 = true;
+      var _didIteratorError8 = false;
+      var _iteratorError8 = undefined;
 
       try {
-        for (var _iterator7 = queryIds[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-          var queryId = _step7.value;
+        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--;
 
-          var queryIdWasLoaded = this._loadedQuerySpecIds.delete(queryId);
+          if (fieldRetainCount < 0) {
+            console.log('Field data over-released'); // eslint-disable-line no-console
 
-          if (!queryIdWasLoaded) {
-            (0, _warning.default)('Over unsubscribed from record store');
+            fieldRetainCount = 0;
           }
-        }
+
+          this._cellValuesRetainCountByFieldId[fieldId] = fieldRetainCount;
+        } // 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.
+
       } catch (err) {
-        _didIteratorError7 = true;
-        _iteratorError7 = err;
+        _didIteratorError8 = true;
+        _iteratorError8 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-            _iterator7.return();
+          if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+            _iterator8.return();
           }
         } finally {
-          if (_didIteratorError7) {
-            throw _iteratorError7;
+          if (_didIteratorError8) {
+            throw _iteratorError8;
           }
         }
       }
-    }
+
+      this._startTimeoutToUnloadForFieldIdsIfNeeded();
+    } // This unloads all fields where the retain count is at zero, and if any other
+    // request to unload fields is pending - cancels it and restarts it.
+    // This is important because fields must always be unloaded at least __DATA_UNLOAD_DELAY_MS
+    // after the unload is requested so that any QueryResults relying on them properly
+    // unload either first, or at the same time
+
   }, {
-    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
-                }
-              }));
+    key: "_startTimeoutToUnloadForFieldIdsIfNeeded",
+    value: function _startTimeoutToUnloadForFieldIdsIfNeeded() {
+      var fieldIdsWithZeroRetainCount = [];
 
-            case 3:
-              return _context3.abrupt("return", _context3.sent);
+      for (var _i2 = 0, _Object$entries = Object.entries(this._cellValuesRetainCountByFieldId); _i2 < _Object$entries.length; _i2++) {
+        var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i2], 2),
+            fieldId = _Object$entries$_i[0],
+            retainCount = _Object$entries$_i[1];
 
-            case 4:
-            case "end":
-              return _context3.stop();
-          }
+        if (retainCount === 0) {
+          fieldIdsWithZeroRetainCount.push(fieldId);
         }
-      }, null, this);
+      } // Cancel any pending timeouts before proceeding
+      // This should be canceled even if there aren't any fields to unload as that means
+      // that there has been loading that's occured that makes the pending request invalid
+
+
+      if (this._timeoutForRemovingFieldIds) {
+        clearTimeout(this._timeoutForRemovingFieldIds);
+        this._timeoutForRemovingFieldIds = null;
+      }
+
+      if (fieldIdsWithZeroRetainCount.length > 0) {
+        this._timeoutForRemovingFieldIds = setTimeout(() => {
+          // Make sure the retain count is still zero, since it may
+          // have been incremented before the timeout fired.
+          var fieldIdsToUnload = fieldIdsWithZeroRetainCount.filter(fieldId => {
+            // It's necessary to also check that the field is loaded, as it's possible
+            // for an unload to trigger with fields that have already been removed.
+            return this._cellValuesRetainCountByFieldId[fieldId] === 0 && this._areCellValuesLoadedByFieldId[fieldId];
+          }); // istanbul ignore else
+
+          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;
+                }
+              }
+            }
+
+            this._unloadCellValuesInFieldIds(fieldIdsToUnload);
+          } else {
+            // This shouldn't be possible because we always cancel the timer if fieldIds loadedness
+            // status ever changes
+            (0, _error_utils.logErrorToSentry)('fieldIdsToUnload is empty, this likely means the unload timer is not properly reset.');
+          }
+
+          this._timeoutForRemovingFieldIds = null;
+        }, _abstract_model_with_async_data.default.__DATA_UNLOAD_DELAY_MS);
+      }
     }
   }, {
-    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: "_restartTimeoutToUnloadFieldIdsIfTimeoutIsActive",
+    value: function _restartTimeoutToUnloadFieldIdsIfTimeoutIsActive() {
+      if (this._timeoutForRemovingFieldIds) {
+        this._startTimeoutToUnloadForFieldIdsIfNeeded();
+      }
     }
   }, {
-    key: "loadAllCellValuesInFieldIdsAsync",
-    value: function loadAllCellValuesInFieldIdsAsync(fieldIds) {
-      var queryId;
-      return _regenerator.default.async(function loadAllCellValuesInFieldIdsAsync$(_context4) {
+    key: "_unloadCellValuesInFieldIds",
+    value: function _unloadCellValuesInFieldIds(fieldIds) {
+      this._airtableInterface.unsubscribeFromCellValuesInFields(this.tableId, fieldIds);
+
+      this._afterUnloadDataOrUnloadCellValuesInFieldIds(fieldIds);
+    }
+  }, {
+    key: "_loadDataAsync",
+    value: function _loadDataAsync() {
+      var tableData, changedKeys, _iteratorNormalCompletion10, _didIteratorError10, _iteratorError10, _iterator10, _step10, fieldId;
+
+      return _regenerator.default.async(function _loadDataAsync$(_context4) {
         while (1) {
           switch (_context4.prev = _context4.next) {
             case 0:
               _context4.next = 2;
-              return _regenerator.default.awrap(this._loadCellValuesForQueryAsync({
-                sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
-                recordSelection: {
-                  fieldSelection: {
-                    type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
-                    fieldIds
-                  }
-                }
-              }));
+              return _regenerator.default.awrap(this._airtableInterface.fetchAndSubscribeToTableDataAsync(this.tableId));
 
             case 2:
-              queryId = _context4.sent;
-              this._numQueriesSubscribedToAllRecords += 1;
-              return _context4.abrupt("return", queryId);
+              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);
+              }
+
+              _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 5:
+            case 23:
+              return _context4.finish(16);
+
+            case 24:
+              return _context4.abrupt("return", changedKeys);
+
+            case 25:
             case "end":
               return _context4.stop();
           }
         }
-      }, null, this);
+      }, null, this, [[8, 12, 16, 24], [17,, 19, 23]]);
     }
   }, {
-    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
-                  }
-                }
-              }));
+    key: "_unloadData",
+    value: function _unloadData() {
+      this._airtableInterface.unsubscribeFromTableData(this.tableId);
 
-            case 2:
-              queryId = _context5.sent;
-              this._numQueriesSubscribedToAllRecords += 1;
-              return _context5.abrupt("return", queryId);
+      this._afterUnloadDataOrUnloadCellValuesInFieldIds();
+    }
+  }, {
+    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; // This should be impossible - for fields should always be loaded
+          // when attempting to unload specific fields. This codepath was previously possible
+          // due to a bug. It could be converted to an invariant, but that is higher risk.
+          // istanbul ignore if
+
+          if (unloadedFieldIds) {
+            // Specific fields were unloaded, so clear out the cell values for those fields.
+            fieldIdsToClear = unloadedFieldIds;
+            (0, _error_utils.logErrorToSentry)('Field Ids are being unloaded when record_store is unloaded');
+          } 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]);
+          }
 
-            case 5:
-            case "end":
-              return _context5.stop();
+          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;
+
+              for (var i = 0; i < fieldIdsToClear.length; i++) {
+                var fieldId = fieldIdsToClear[i];
+
+                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;
+              }
+            }
           }
         }
-      }, null, this);
+      }
+
+      if (!areAnyFieldsLoaded) {
+        this._recordModelsById = {};
+      }
     }
   }, {
-    key: "unloadCellValuesForQueryIdsThatAreSubscribedToAllCells",
-    value: function unloadCellValuesForQueryIdsThatAreSubscribedToAllCells(queryIds) {
-      this._unloadCellValuesForQueryIds(queryIds);
+    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;
 
-      this._numQueriesSubscribedToAllRecords -= queryIds.length;
-    } // Maybe add a comment "pending removal of inheriting from parent class AbstractModelWithAsyncData"
-    // istanbul ignore next
+        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];
 
-  }, {
-    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');
+              if (_recordModel) {
+                _recordModel.__triggerOnChangeForDirtyPaths(dirtyRecordPaths);
+              }
+            }
 
-            case 1:
-            case "end":
-              return _context6.stop();
+            var cellValuesByFieldId = dirtyRecordPaths.cellValuesByFieldId;
+
+            if (cellValuesByFieldId) {
+              for (var _i3 = 0, _Object$keys2 = Object.keys(cellValuesByFieldId); _i3 < _Object$keys2.length; _i3++) {
+                var fieldId = _Object$keys2[_i3];
+                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;
+            }
           }
         }
-      });
-    } // Maybe add a comment "pending removal of inheriting from parent class AbstractModelWithAsyncData"
-    // istanbul ignore next
 
-  }, {
-    key: "_unloadData",
-    value: function _unloadData() {
-      throw (0, _error_utils.spawnError)('Internal error - SDK called unloadData on record_store');
+        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
+          });
+        }
+
+        var _iteratorNormalCompletion13 = true;
+        var _didIteratorError13 = false;
+        var _iteratorError13 = undefined;
+
+        try {
+          for (var _iterator13 = fieldIds[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
+            var _fieldId2 = _step13.value;
+
+            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;
+            }
+          }
+        }
+      }
+
+      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();
+
+              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: "_dataOrNullIfDeleted",
@@ -808,7 +1083,9 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "records",
     get: function get() {
-      var records = this.recordIds.map(recordId => {
+      var recordsById = this._data.recordsById;
+      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
+      var records = Object.keys(recordsById).map(recordId => {
         var record = this.getRecordByIdIfExists(recordId);
         (0, _error_utils.invariant)(record, 'record');
         return record;
@@ -823,17 +1100,14 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "recordIds",
     get: function get() {
-      (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;
+      var recordsById = this._data.recordsById;
+      (0, _error_utils.invariant)(recordsById, 'Record metadata is not loaded');
+      return Object.keys(recordsById);
     }
   }, {
-    key: "isSubscribedToAllRecordsInTable",
+    key: "isRecordMetadataLoaded",
     get: function get() {
-      return this._numQueriesSubscribedToAllRecords > 0;
+      return !!this._data.recordsById;
     }
   }]);
   return RecordStore;