@airtable/blocks 1.7.0 → 1.9.0-experimental

package/dist/cjs/models/view_data_store.js

@@ -2,13 +2,7 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-require("core-js/modules/es.symbol");
-
-require("core-js/modules/es.symbol.description");
-
-require("core-js/modules/es.array.filter");
-
-require("core-js/modules/es.array.iterator");
+require("core-js/modules/es.array.find");
 
 require("core-js/modules/es.array.map");
 
@@ -16,17 +10,17 @@ require("core-js/modules/es.array.slice");
 
 require("core-js/modules/es.object.to-string");
 
+require("core-js/modules/es.object.values");
+
 require("core-js/modules/es.promise");
 
-require("core-js/modules/web.dom-collections.iterator");
+require("core-js/modules/web.dom-collections.for-each");
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.WatchableViewDataStoreKeys = void 0;
 
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 require("regenerator-runtime/runtime");
@@ -35,11 +29,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,11 +43,12 @@ var _private_utils = require("../private_utils");
 
 var _error_utils = require("../error_utils");
 
+var _block_query_spec = require("../types/block_query_spec");
+
 var _abstract_model_with_async_data = _interopRequireDefault(require("./abstract_model_with_async_data"));
 
 var WatchableViewDataStoreKeys = Object.freeze({
   visibleRecords: 'visibleRecords',
-  visibleRecordIds: 'visibleRecordIds',
   groups: 'groups',
   groupLevels: 'groupLevels',
   recordColors: 'recordColors',
@@ -66,9 +59,11 @@ var WatchableViewDataStoreKeys = Object.freeze({
 
 exports.WatchableViewDataStoreKeys = WatchableViewDataStoreKeys;
 
-// ViewDataStore contains loadable data for a specific view. That means the set of visible records,
+// ViewDataStore manages loadable data for a specific view. That means the set of visible records,
 // and field order/visibility information. View itself only contains core schema information. The
-// data here doesn't belong in View as it's record data or conditionally loaded.
+// data here doesn't belong in View as it's record data or conditionally loaded and therefore
+// loaded via queries (and therefore managed by publicAirtableInterface)
+// TODO: (#proj-blocks-sdk-record-limits) Remove AbstractModelWithAsyncData
 
 /** @internal */
 var ViewDataStore =
@@ -80,11 +75,6 @@ function (_AbstractModelWithAsy) {
     value: function _isWatchableKey(key) {
       return (0, _private_utils.isEnumValue)(WatchableViewDataStoreKeys, key);
     }
-  }, {
-    key: "_shouldLoadDataForKey",
-    value: function _shouldLoadDataForKey(key) {
-      return true;
-    }
   }]);
 
   function ViewDataStore(sdk, parentRecordStore, viewId) {
@@ -94,16 +84,38 @@ function (_AbstractModelWithAsy) {
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ViewDataStore).call(this, sdk, "".concat(viewId, "-ViewDataStore")));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "viewId", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "parentRecordStore", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_mostRecentTableLoadPromise", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_airtableInterface", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_publicViewStore", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryManager", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryIdFromReferenceCountedLoadData", null);
     _this.parentRecordStore = parentRecordStore;
-    _this._airtableInterface = sdk.__airtableInterface;
-    _this._mostRecentTableLoadPromise = null;
+    _this._queryManager = sdk._queryManager;
     _this.viewId = viewId;
+
+    var publicViewStore = _this.parentRecordStore._airtableInterface.getViewMetadataStoreIfExists(_this.parentRecordStore.tableId, viewId);
+
+    (0, _error_utils.invariant)(publicViewStore, 'PublicViewStore must exist for all valid viewIds');
+    _this._publicViewStore = publicViewStore;
     return _this;
   }
 
   (0, _createClass2.default)(ViewDataStore, [{
+    key: "_assertExistsAndLoaded",
+
+    /**
+     * @internal
+     */
+    value: function _assertExistsAndLoaded() {
+      // Access data in order to throw if the data has been deleted / isn't loaded
+      var data = this._dataOrNullIfDeleted; // Currently it is not possible for the ViewDataStore to spawn an error on deletion
+      // because the parent TableOrViewQueryResult or ViewMetadataQueryResult throw their own
+      // errors when the view is deleted.
+      // istanbul ignore if
+
+      if (data === null) {
+        throw this._spawnErrorForDeletion();
+      }
+    }
+  }, {
     key: "_onChangeIsDataLoaded",
     value: function _onChangeIsDataLoaded() {// noop
     }
@@ -111,186 +123,58 @@ function (_AbstractModelWithAsy) {
     key: "__onDataDeletion",
     value: function __onDataDeletion() {
       this._forceUnload();
-    }
-  }, {
-    key: "loadDataAsync",
-    value: function loadDataAsync() {
-      var tableLoadPromise;
-      return _regenerator.default.async(function loadDataAsync$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              // Override this method to also load table data.
-              // NOTE: it's important that we call loadDataAsync on the table here and not in
-              // _loadDataAsync since we want the retain counts for the view and table to increase/decrease
-              // in lock-step. If we load table data in _loadDataAsync, the table's retain
-              // count only increments some of the time, which leads to unexpected behavior.
-              tableLoadPromise = this.parentRecordStore.loadRecordMetadataAsync();
-              this._mostRecentTableLoadPromise = tableLoadPromise;
-              _context.next = 4;
-              return _regenerator.default.awrap((0, _get2.default)((0, _getPrototypeOf2.default)(ViewDataStore.prototype), "loadDataAsync", this).call(this));
-
-            case 4:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, null, this);
+
+      this._queryManager.forceUnloadWatchesOnWatchableModel(this);
     }
   }, {
     key: "_loadDataAsync",
     value: function _loadDataAsync() {
-      var tableLoadPromise, _ref, _ref2, viewData, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, record;
-
-      return _regenerator.default.async(function _loadDataAsync$(_context2) {
+      var changedKeysOnLoad;
+      return _regenerator.default.async(function _loadDataAsync$(_context) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context.prev = _context.next) {
             case 0:
-              // We need to be sure that the table data is loaded *before* we return
-              // from this method.
-              (0, _error_utils.invariant)(this._mostRecentTableLoadPromise, 'No table load promise');
-              tableLoadPromise = this._mostRecentTableLoadPromise;
-              _context2.next = 4;
-              return _regenerator.default.awrap(Promise.all([this._airtableInterface.fetchAndSubscribeToViewDataAsync(this.parentRecordStore.tableId, this.viewId), tableLoadPromise]));
-
-            case 4:
-              _ref = _context2.sent;
-              _ref2 = (0, _slicedToArray2.default)(_ref, 1);
-              viewData = _ref2[0];
-              this._data.visibleRecordIds = viewData.visibleRecordIds;
-              this._data.fieldOrder = viewData.fieldOrder;
-              this._data.groups = viewData.groups;
-              this._data.groupLevels = viewData.groupLevels;
-              this._data.colorsByRecordId = viewData.colorsByRecordId;
-
-              if (!this._data.colorsByRecordId) {
-                _context2.next = 32;
-                break;
-              }
-
-              _iteratorNormalCompletion = true;
-              _didIteratorError = false;
-              _iteratorError = undefined;
-              _context2.prev = 16;
-
-              for (_iterator = this.visibleRecords[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                record = _step.value;
-
-                if ((0, _private_utils.has)(this._data.colorsByRecordId, record.id)) {
-                  record.__triggerOnChangeForRecordColorInViewId(this.viewId);
+              // TODO: (#proj-blocks-sdk-record-limits) Do we want to remove this reference counting semantic?
+              // We can assume that each query is identical, but it might be helpful to have all queries be
+              // registered across the bridge so that we can track utilization.
+              (0, _error_utils.invariant)(this._queryIdFromReferenceCountedLoadData === null, 'Can not reissue an identical view data store query');
+              _context.next = 3;
+              return _regenerator.default.awrap(this._queryManager.fetchAndSubscribeToQueryAsync({
+                sourceType: _block_query_spec.BlockQuerySourceType.VIEW,
+                sourceTableId: this.parentRecordStore.tableId,
+                sourceViewId: this.viewId,
+                viewMetadataSelection: {
+                  shouldIncludeVisibleRecordIds: true,
+                  shouldIncludeFieldOrder: true,
+                  shouldIncludeGroups: true,
+                  shouldIncludeGroupingLevels: true,
+                  shouldIncludeColorsForRecordId: true
                 }
-              }
-
-              _context2.next = 24;
-              break;
-
-            case 20:
-              _context2.prev = 20;
-              _context2.t0 = _context2["catch"](16);
-              _didIteratorError = true;
-              _iteratorError = _context2.t0;
-
-            case 24:
-              _context2.prev = 24;
-              _context2.prev = 25;
-
-              if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-              }
-
-            case 27:
-              _context2.prev = 27;
+              }));
 
-              if (!_didIteratorError) {
-                _context2.next = 30;
-                break;
-              }
+            case 3:
+              this._queryIdFromReferenceCountedLoadData = _context.sent;
+              changedKeysOnLoad = Object.values(WatchableViewDataStoreKeys);
 
-              throw _iteratorError;
+              this._queryManager.onLoadKeys(this, changedKeysOnLoad);
 
-            case 30:
-              return _context2.finish(27);
+              return _context.abrupt("return", []);
 
-            case 31:
-              return _context2.finish(24);
-
-            case 32:
-              return _context2.abrupt("return", [WatchableViewDataStoreKeys.visibleRecords, WatchableViewDataStoreKeys.visibleRecordIds, WatchableViewDataStoreKeys.allFieldIds, WatchableViewDataStoreKeys.groups, WatchableViewDataStoreKeys.groupLevels, WatchableViewDataStoreKeys.visibleFieldIds, WatchableViewDataStoreKeys.recordColors]);
-
-            case 33:
+            case 7:
             case "end":
-              return _context2.stop();
+              return _context.stop();
           }
         }
-      }, null, this, [[16, 20, 24, 32], [25,, 27, 31]]);
-    }
-  }, {
-    key: "unloadData",
-    value: function unloadData() {
-      // Override this method to also unload the table's data.
-      // NOTE: it's important that we do this here, since we want the view and table's
-      // retain counts to increment/decrement in lock-step. If we unload the table's
-      // data in _unloadData, it leads to unexpected behavior.
-      (0, _get2.default)((0, _getPrototypeOf2.default)(ViewDataStore.prototype), "unloadData", this).call(this);
-      this.parentRecordStore.unloadRecordMetadata();
+      }, null, this);
     }
   }, {
     key: "_unloadData",
     value: function _unloadData() {
-      this._mostRecentTableLoadPromise = null;
+      (0, _error_utils.invariant)(this._queryIdFromReferenceCountedLoadData, 'Can not unsubscribe from a view store that is not subscribed');
 
-      this._airtableInterface.unsubscribeFromViewData(this.parentRecordStore.tableId, this.viewId);
+      this._queryManager.unsubscribeFromQueryId(this._queryIdFromReferenceCountedLoadData);
 
-      if (!this.isDeleted) {
-        this._data.visibleRecordIds = undefined;
-        this._data.groups = undefined;
-        this._data.colorsByRecordId = undefined;
-      }
-    }
-  }, {
-    key: "__generateChangesForParentTableAddMultipleRecords",
-    value: function __generateChangesForParentTableAddMultipleRecords(recordIds) {
-      var newVisibleRecordIds = [...this.visibleRecordIds, ...recordIds];
-      return [{
-        path: ['tablesById', this.parentRecordStore.tableId, 'viewsById', this.viewId, 'visibleRecordIds'],
-        value: newVisibleRecordIds
-      }];
-    }
-  }, {
-    key: "__generateChangesForParentTableDeleteMultipleRecords",
-    value: function __generateChangesForParentTableDeleteMultipleRecords(recordIds) {
-      var recordIdsToDeleteSet = {};
-      var _iteratorNormalCompletion2 = true;
-      var _didIteratorError2 = false;
-      var _iteratorError2 = undefined;
-
-      try {
-        for (var _iterator2 = recordIds[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-          var recordId = _step2.value;
-          recordIdsToDeleteSet[recordId] = true;
-        }
-      } catch (err) {
-        _didIteratorError2 = true;
-        _iteratorError2 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-            _iterator2.return();
-          }
-        } finally {
-          if (_didIteratorError2) {
-            throw _iteratorError2;
-          }
-        }
-      }
-
-      var newVisibleRecordIds = this.visibleRecordIds.filter(recordId => {
-        return !recordIdsToDeleteSet[recordId];
-      });
-      return [{
-        path: ['tablesById', this.parentRecordStore.tableId, 'viewsById', this.viewId, 'visibleRecordIds'],
-        value: newVisibleRecordIds
-      }];
+      this._queryIdFromReferenceCountedLoadData = null;
     }
     /**
      * The record IDs that are not filtered out of this view.
@@ -308,107 +192,187 @@ function (_AbstractModelWithAsy) {
      * @param recordOrRecordId the record/record id to get the color for
      */
     value: function getRecordColor(record) {
-      var _ref3, _this$_data$colorsByR;
-
       (0, _error_utils.invariant)(this.isDataLoaded, 'View data is not loaded');
-      return (_ref3 = (_this$_data$colorsByR = this._data.colorsByRecordId) === null || _this$_data$colorsByR === void 0 ? void 0 : _this$_data$colorsByR[record.id]) !== null && _ref3 !== void 0 ? _ref3 : null;
+
+      this._assertExistsAndLoaded();
+
+      return this._publicViewStore.getColorForRecordId(record.id);
     }
   }, {
-    key: "triggerOnChangeForDirtyPaths",
-    value: function triggerOnChangeForDirtyPaths(dirtyPaths) {
-      if (dirtyPaths.visibleRecordIds) {
-        this._onChange(WatchableViewDataStoreKeys.visibleRecords);
+    key: "_findBlockSubscriptionChangedMatchingSubscriptionChangeTypeForViewIfExists",
+    value: function _findBlockSubscriptionChangedMatchingSubscriptionChangeTypeForViewIfExists(changes, changeTypeToMatch) {
+      var _changes$find;
 
-        this._onChange(WatchableViewDataStoreKeys.visibleRecordIds);
-      }
+      return (_changes$find = changes.find(change => change.type === changeTypeToMatch && change.tableId === this.parentRecordStore.tableId && change.viewId === this.viewId)) !== null && _changes$find !== void 0 ? _changes$find : null;
+    }
+  }, {
+    key: "_constructBlockQuerySpecForWatchableKey",
+    value: function _constructBlockQuerySpecForWatchableKey(key, callbackForRegistration, context) {
+      var querySpecOptions = {};
+
+      var wrappedCallbackForQueryChange = () => {
+        callbackForRegistration.call(context, this, key);
+      };
+
+      switch (key) {
+        case WatchableViewDataStoreKeys.visibleRecords:
+          querySpecOptions.shouldIncludeVisibleRecordIds = true;
+          break;
+
+        case WatchableViewDataStoreKeys.groups:
+          {
+            querySpecOptions.shouldIncludeGroups = true;
+            break;
+          }
 
-      if (dirtyPaths.fieldOrder) {
-        this._onChange(WatchableViewDataStoreKeys.allFieldIds); // TODO(kasra): only trigger visibleFields if the *visible* field ids changed.
+        case WatchableViewDataStoreKeys.groupLevels:
+          {
+            querySpecOptions.shouldIncludeGroupingLevels = true;
+            break;
+          }
 
+        case WatchableViewDataStoreKeys.recordColors:
+          {
+            querySpecOptions.shouldIncludeColorsForRecordId = true;
 
-        this._onChange(WatchableViewDataStoreKeys.visibleFieldIds);
-      } // Technically it's possible for groupLevels changing to cause a groups
-      // change since we derive group information from the groupLevels (fieldId)
+            wrappedCallbackForQueryChange = changes => {
+              var recordColorsChange = this._findBlockSubscriptionChangedMatchingSubscriptionChangeTypeForViewIfExists(changes, _block_query_spec.BlockQuerySubscriptionChangeType.CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW);
 
+              var recordIdsOrNull = null;
 
-      if (dirtyPaths.groups || dirtyPaths.groupLevels) {
-        this._onChange(WatchableViewDataStoreKeys.groups);
-      }
+              if (recordColorsChange) {
+                (0, _error_utils.invariant)(recordColorsChange.type === _block_query_spec.BlockQuerySubscriptionChangeType.CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW, 'Invalid record colors change event');
+                recordIdsOrNull = recordColorsChange.recordIds;
+              } // We also always call this, even if no recordColors changed to closely mirror
+              // the old version of the SDK (https://github.com/Hyperbase/blocks-sdk/blob/8e3ac1a37be9c9850e64085975b102a483116080/packages/sdk/src/models/view_data_store.ts#L319-L361)
+              // In the future, this should not be the case (don't call callback if nothing changed)
 
-      if (dirtyPaths.groupLevels) {
-        this._onChange(WatchableViewDataStoreKeys.groupLevels);
-      }
 
-      if (dirtyPaths.colorsByRecordId) {
-        var changedRecordIds = dirtyPaths.colorsByRecordId._isDirty ? null : Object.keys(dirtyPaths.colorsByRecordId);
-
-        if (changedRecordIds) {
-          // Checking isRecordMetadataLoaded fixes a timing issue:
-          // When a new table loads in liveapp, we'll receive the record
-          // colors before getting the response to our loadData call.
-          // This is a temporary fix: we need a more general solution to
-          // avoid processing events associated with subscriptions whose
-          // data we haven't received yet.
-          if (this.parentRecordStore.isRecordMetadataLoaded) {
-            var _iteratorNormalCompletion3 = true;
-            var _didIteratorError3 = false;
-            var _iteratorError3 = undefined;
-
-            try {
-              for (var _iterator3 = changedRecordIds[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-                var recordId = _step3.value;
-                var record = this.parentRecordStore.getRecordByIdIfExists(recordId); // Similar to above, we could be receiving the change notification
-                // for a record color before receiving the new record itself.
-
-                if (record) {
-                  record.__triggerOnChangeForRecordColorInViewId(this.viewId);
-                }
-              }
-            } catch (err) {
-              _didIteratorError3 = true;
-              _iteratorError3 = err;
-            } finally {
-              try {
-                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                  _iterator3.return();
-                }
-              } finally {
-                if (_didIteratorError3) {
-                  throw _iteratorError3;
-                }
-              }
-            }
+              callbackForRegistration.call(context, this, key, recordIdsOrNull);
+            };
+
+            break;
+          }
+
+        case WatchableViewDataStoreKeys.allFieldIds:
+          {
+            querySpecOptions.shouldIncludeFieldOrder = true;
+            break;
           }
-        }
 
-        this._onChange(WatchableViewDataStoreKeys.recordColors, changedRecordIds);
+        case WatchableViewDataStoreKeys.visibleFieldIds:
+          {
+            // TODO: This will trigger even if fieldIds which aren't visible in the view change.
+            // This is NOT a regression, a fix would be to add an intermediate callback
+            // which swallows changes if the visible fieldOrder does not change.
+            querySpecOptions.shouldIncludeFieldOrder = true;
+            break;
+          }
+        // TypeScript ensures that key is of type never so we don't need to test this via istanbul
+        // istanbul ignore next
+
+        default:
+          throw (0, _error_utils.spawnExhaustiveSwitchError)(key);
       }
+
+      return {
+        querySpecToSubscribeWith: {
+          sourceType: _block_query_spec.BlockQuerySourceType.VIEW,
+          sourceTableId: this.parentRecordStore.tableId,
+          sourceViewId: this.viewId,
+          viewMetadataSelection: querySpecOptions
+        },
+        wrappedCallbackForQueryChange
+      };
+    }
+    /**
+     * Watching a key that needs to load data asynchronously will automatically
+     * cause the data to be fetched. Once the data is available, the callback
+     * will be called.
+     *
+     * @inheritdoc
+     */
+
+  }, {
+    key: "watch",
+    value: function watch(keys, callbackForWatchKey, context) {
+      this._assertNotForceUnloaded();
+
+      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'view watch');
+
+      validKeys.forEach(validKey => {
+        var _this$_constructBlock = this._constructBlockQuerySpecForWatchableKey(validKey, callbackForWatchKey, context),
+            querySpecToSubscribeWith = _this$_constructBlock.querySpecToSubscribeWith,
+            wrappedCallbackForQueryChange = _this$_constructBlock.wrappedCallbackForQueryChange;
+
+        this._queryManager.watchWithQuerySpec(querySpecToSubscribeWith, this, validKey, wrappedCallbackForQueryChange, callbackForWatchKey, context);
+      });
+      return validKeys;
+    }
+    /**
+     * Unwatching a key that needs to load data asynchronously will automatically
+     * cause the data to be released. Once the data is available, the callback
+     * will be called.
+     *
+     * @inheritdoc
+     */
+
+  }, {
+    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.
+
+
+      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'view unwatch', true);
+
+      validKeys.forEach(key => this._queryManager.unwatchFromQueryKey(key, callbackForRegistration, context));
+      return validKeys;
+    }
+  }, {
+    key: "triggerOnChangeForDirtyPaths",
+    value: function triggerOnChangeForDirtyPaths(dirtyPaths) {// This is only triggered for changes to values in the type ViewData, which is
+      // populated and kept up to date by watching base schema (aka the view's id, name, type).
+      // None of these are watchable, so we don't need to call this._onChange() for them.
+      // In the future we may want to make the view's name watchable, which is the only property
+      // here that we'd expect to change. In this case, it would be handled here.
     }
   }, {
     key: "_dataOrNullIfDeleted",
     get: function get() {
-      var _ref4;
+      var _ref;
 
       var tableData = this._baseData.tablesById[this.parentRecordStore.tableId];
-      return (_ref4 = tableData === null || tableData === void 0 ? void 0 : tableData.viewsById[this.viewId]) !== null && _ref4 !== void 0 ? _ref4 : null;
+      return (_ref = tableData === null || tableData === void 0 ? void 0 : tableData.viewsById[this.viewId]) !== null && _ref !== void 0 ? _ref : null;
     }
   }, {
     key: "isDataLoaded",
     get: function get() {
-      return this._isDataLoaded && this.parentRecordStore.isRecordMetadataLoaded;
+      return this._isDataLoaded;
+    }
+  }, {
+    key: "isRecordDataLoadedForView",
+    get: function get() {
+      // We _currently_ only issue queries that also load cell data in the view which
+      // is synchronously returned with all other view data, so we can collapse this
+      // to if the viewData has loaded.
+      // TODO: (#proj-blocks-sdk-record-limits) Actually track if all cell data is loaded
+      // based on issued queries from ViewDataStore
+      return this.isDataLoaded;
     }
   }, {
     key: "visibleRecordIds",
     get: function get() {
-      var visibleRecordIds = this._data.visibleRecordIds;
-      (0, _error_utils.invariant)(visibleRecordIds, 'View data is not loaded'); // Freeze visibleRecordIds so users can't mutate it.
-      // If it changes from liveapp, we get an entire new array which will
-      // replace this one, so it's okay to freeze it.
+      this._assertExistsAndLoaded(); // Freezing the visibleRecordIds happens on the other side of the bridge
 
-      if (!Object.isFrozen(visibleRecordIds)) {
-        Object.freeze(visibleRecordIds);
-      }
 
+      var visibleRecordIds = this._publicViewStore.getVisibleRecordIds();
+
+      (0, _error_utils.invariant)(visibleRecordIds, 'View data is not loaded');
       return visibleRecordIds;
     }
     /**
@@ -420,8 +384,12 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "visibleRecords",
     get: function get() {
-      (0, _error_utils.invariant)(this.parentRecordStore.isRecordMetadataLoaded, 'Table data is not loaded');
-      var visibleRecordIds = this._data.visibleRecordIds;
+      (0, _error_utils.invariant)(this.isRecordDataLoadedForView, 'Table data is not loaded for this view');
+
+      this._assertExistsAndLoaded();
+
+      var visibleRecordIds = this._publicViewStore.getVisibleRecordIds();
+
       (0, _error_utils.invariant)(visibleRecordIds, 'View data is not loaded');
       return visibleRecordIds.map(recordId => {
         var record = this.parentRecordStore.getRecordByIdIfExists(recordId);
@@ -440,9 +408,9 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "groups",
     get: function get() {
-      (0, _error_utils.invariant)(this.parentRecordStore.isRecordMetadataLoaded, 'Table data is not loaded');
-      var groups = this._data.groups;
-      return groups !== null && groups !== void 0 ? groups : null;
+      this._assertExistsAndLoaded();
+
+      return this._publicViewStore.getGroups();
     }
     /**
      * Gets the group config for this view, can be watched to know when groupLevels
@@ -452,23 +420,29 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "groupLevels",
     get: function get() {
-      (0, _error_utils.invariant)(this.parentRecordStore.isRecordMetadataLoaded, 'Table data is not loaded');
-      var groupLevels = this._data.groupLevels;
-      return groupLevels !== null && groupLevels !== void 0 ? groupLevels : null;
+      this._assertExistsAndLoaded();
+
+      return this._publicViewStore.getGroupLevels();
     }
   }, {
     key: "allFieldIds",
     get: function get() {
-      var fieldOrder = this._data.fieldOrder;
-      (0, _error_utils.invariant)(fieldOrder, 'View data is not loaded');
-      return fieldOrder.fieldIds;
+      this._assertExistsAndLoaded(); // TODO: (#proj-blocks-sdk-record-limits) Future sdk version shouldn't deep
+      // copy this, and it should be legal to return the frozen object directly
+
+
+      return (0, _private_utils.cloneDeep)(this._publicViewStore.getFieldOrder().fieldIds);
     }
   }, {
     key: "visibleFieldIds",
     get: function get() {
-      var fieldOrder = this._data.fieldOrder;
+      this._assertExistsAndLoaded();
+
+      var fieldOrder = this._publicViewStore.getFieldOrder();
+
       (0, _error_utils.invariant)(fieldOrder, 'View data is not loaded');
-      var fieldIds = fieldOrder.fieldIds;
+      var fieldIds = fieldOrder.fieldIds; // Slice returns a mutable copy even though visibleFieldCount is readonly
+
       return fieldIds.slice(0, fieldOrder.visibleFieldCount);
     }
   }]);