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

package/dist/cjs/models/record.js

@@ -6,12 +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.includes");
+
 require("core-js/modules/es.array.iterator");
 
 require("core-js/modules/es.object.to-string");
 
 require("core-js/modules/es.promise");
 
+require("core-js/modules/es.string.includes");
+
 require("core-js/modules/es.string.starts-with");
 
 require("core-js/modules/web.dom-collections.iterator");
@@ -29,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"));
 
@@ -47,6 +57,10 @@ var _error_utils = require("../error_utils");
 
 var _color_utils = _interopRequireDefault(require("../color_utils"));
 
+var _block_query_spec = require("../types/block_query_spec");
+
+var _airtable_interface = require("../types/airtable_interface");
+
 var _abstract_model = _interopRequireDefault(require("./abstract_model"));
 
 var _object_pool = _interopRequireDefault(require("./object_pool"));
@@ -80,6 +94,23 @@ var WatchableColorInViewKeyPrefix = 'colorInView:';
  * - `'colorInView:' + someViewId`
  */
 
+function _isKeySubscribeableViaRecordQuery(key) {
+  switch (key) {
+    case WatchableRecordKeys.name:
+    case WatchableRecordKeys.commentCount:
+    case WatchableRecordKeys.cellValues:
+      return true;
+
+    default:
+      if (key.startsWith(WatchableCellValueInFieldKeyPrefix)) {
+        return true;
+      }
+
+      break;
+  }
+
+  return false;
+}
 /**
  * Model class representing a record in a table.
  *
@@ -88,6 +119,8 @@ var WatchableColorInViewKeyPrefix = 'colorInView:';
  *
  * @docsPath models/Record
  */
+
+
 var Record =
 /*#__PURE__*/
 function (_AbstractModel) {
@@ -115,9 +148,16 @@ function (_AbstractModel) {
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Record).call(this, sdk, recordId));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentRecordStore", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentTable", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_queryManager", void 0);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "__linkedRecordsQueryResultPool", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_onRecordColorChange", (viewDataStore, key, recordIds) => {
+      if (recordIds.includes(_this.id)) {
+        _this._onChange(WatchableColorInViewKeyPrefix + viewDataStore.viewId);
+      }
+    });
     _this._parentRecordStore = parentRecordStore;
     _this._parentTable = parentTable;
+    _this._queryManager = sdk._queryManager;
     _this.__linkedRecordsQueryResultPool = new _object_pool.default(_linked_records_query_result.default);
     return _this;
   }
@@ -127,6 +167,33 @@ function (_AbstractModel) {
 
 
   (0, _createClass2.default)(Record, [{
+    key: "_assertExistsAndLoaded",
+
+    /**
+     * @internal
+     */
+    value: function _assertExistsAndLoaded() {
+      // Access data in order to throw if the Record has been deleted / isn't loaded
+      var data = this._dataOrNullIfDeleted;
+
+      if (data === null) {
+        throw this._spawnErrorForDeletion();
+      }
+    }
+    /**
+     * The table that this record belongs to. Should never change because records aren't moved between tables.
+     *
+     * @internal (since we may not be able to return parent model instances in the immutable models world)
+     * @example
+     * ```js
+     * import {useRecords} from '@airtable/blocks/ui';
+     * const records = useRecords(myTable);
+     * console.log(records[0].parentTable.id === myTable.id);
+     * // => true
+     * ```
+     */
+
+  }, {
     key: "_getFieldMatching",
 
     /**
@@ -156,18 +223,20 @@ function (_AbstractModel) {
   }, {
     key: "_getRawCellValue",
     value: function _getRawCellValue(field) {
-      (0, _error_utils.invariant)(this._parentRecordStore.areCellValuesLoadedForFieldId(field.id), 'Cell values for field %s are not loaded', field.id);
-      var cellValuesByFieldId = this._data.cellValuesByFieldId;
+      this._assertExistsAndLoaded(); // TODO: (#proj-blocks-sdk-record-limits) Consider a new API that allows determining
+      // if the cell value is loaded + getting the cellValue in one call?
 
-      if (!cellValuesByFieldId) {
-        return null;
-      }
 
-      var cellValue = cellValuesByFieldId[field.id] !== undefined ? cellValuesByFieldId[field.id] : null;
+      var isCellValueLoadedForField = this._parentRecordStore.isRecordCellValueLoadedForFieldId(this._id, field.id);
+
+      (0, _error_utils.invariant)(isCellValueLoadedForField, 'Cell value for field %s and record %s is not loaded', field.id, this._id);
+
+      var cellValue = this._parentRecordStore.getRecordCellValueByFieldId(this._id, field.id);
 
       if (typeof cellValue === 'object' && cellValue !== null) {
         // Copy non-primitives.
-        // TODO(kasra): maybe freezeDeep instead?
+        // TODO: (#proj-blocks-sdk-record-limits): getRecordCellValueByFieldId returns
+        // deeply frozen objects, in a later sdk version we can drop cloning deeply.
         return (0, _private_utils.cloneDeep)(cellValue);
       } else {
         return cellValue;
@@ -278,9 +347,8 @@ function (_AbstractModel) {
   }, {
     key: "getCellValueAsString",
     value: function getCellValueAsString(fieldOrFieldIdOrFieldName) {
-      var field = this._getFieldMatching(fieldOrFieldIdOrFieldName);
+      var field = this._getFieldMatching(fieldOrFieldIdOrFieldName); // getRawCellValue performs invariant check that cell value at the field is loaded
 
-      (0, _error_utils.invariant)(this._parentRecordStore.areCellValuesLoadedForFieldId(field.id), 'Cell values for field %s are not loaded', field.id);
 
       var cellValue = this._getRawCellValue(field);
 
@@ -443,73 +511,256 @@ function (_AbstractModel) {
      */
 
   }, {
-    key: "__triggerOnChangeForDirtyPaths",
+    key: "_constructBlockFieldSelectionSpec",
 
     /**
      * @internal
      */
-    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
-      var cellValuesByFieldId = dirtyPaths.cellValuesByFieldId,
-          commentCount = dirtyPaths.commentCount;
-
-      if (cellValuesByFieldId && !(0, _private_utils.isObjectEmpty)(cellValuesByFieldId)) {
-        // 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).
-        this._onChange(WatchableRecordKeys.cellValues, Object.keys(cellValuesByFieldId));
-
-        if (cellValuesByFieldId[this.parentTable.primaryField.id]) {
-          this._onChange(WatchableRecordKeys.name);
+    value: function _constructBlockFieldSelectionSpec(fieldSelection) {
+      return {
+        sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
+        sourceTableId: this.parentTable.id,
+        recordSelection: {
+          recordIds: [this.id],
+          fieldSelection
         }
+      };
+    }
+    /**
+     * @internal
+     */
 
-        for (var _i = 0, _Object$keys = Object.keys(cellValuesByFieldId); _i < _Object$keys.length; _i++) {
-          var fieldId = _Object$keys[_i];
+  }, {
+    key: "_findMatchingBlockSubscriptionChanges",
+    value: function _findMatchingBlockSubscriptionChanges(changes, changeTypeToMatch) {
+      return changes.filter(change => change.type === changeTypeToMatch && change.tableId === this.parentTable.id);
+    }
+    /**
+     * @internal
+     */
+
+  }, {
+    key: "_constructBlockQuerySpecAndCallbackForWatchableKey",
+    value: function _constructBlockQuerySpecAndCallbackForWatchableKey(key, callbackForRegistration, context) {
+      var fieldSelectionDefinition;
+
+      var onChangeCallback = () => {
+        callbackForRegistration.call(context, this, key);
+      };
+
+      switch (key) {
+        case WatchableRecordKeys.name:
+          fieldSelectionDefinition = {
+            type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+            fieldIds: [this.parentTable.primaryField.id]
+          };
+          break;
+
+        case WatchableRecordKeys.commentCount:
+          fieldSelectionDefinition = {
+            type: _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS,
+            fieldIds: [],
+            shouldIncludeCommentCount: true
+          };
+          break;
+
+        case WatchableRecordKeys.cellValues:
+          // TODO: (#proj-blocks-sdk-record-limits) In the future don't fetch all fields from table
+          // old code exhibit this behavior though: https://github.com/Hyperbase/blocks-sdk/blob/aba6fa7b7f8ccc1e364b409ca466d0281f8e9a69/packages/sdk/src/models/record.ts#L414-L416
+          // In the future a "subscribe to updates, but don't fetch more data" might be useful here.
+          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); // We do not currently simulate "on load" callback for registration
+            // but still handle it.
+
+
+            if (modifiedCellValuesChanges.length === 0) {
+              callbackForRegistration.call(context, this, key);
+              return;
+            }
+
+            var fieldIdsModified = [];
+            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 in record');
+                var fieldIdsByRecordId = modifiedCellValuesChange.fieldIdsByRecordId;
+                var fieldIdsForThisRecord = fieldIdsByRecordId[this.id];
+
+                if (fieldIdsForThisRecord) {
+                  fieldIdsModified = fieldIdsModified.concat(fieldIdsForThisRecord);
+                }
+              }
+            } 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, fieldIdsModified);
+          };
+
+          break;
+
+        default:
+          // The else cases should be impossible to reach - they indicate a SDK error.
+          // istanbul ignore else
+          if (key.startsWith(WatchableCellValueInFieldKeyPrefix)) {
+            var fieldId = key.substring(WatchableCellValueInFieldKeyPrefix.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 => {
+              // We could check if something else changed in the changes array,
+              // but our query subscription is targeting only the field in this record
+              callbackForRegistration.call(context, this, key, fieldId);
+            };
+          } else if (key.startsWith(WatchableColorInViewKeyPrefix)) {
+            throw (0, _error_utils.spawnError)('WatchableColorInViewKeyPrefix must be handled outside of query system');
+          } else {
+            throw (0, _error_utils.spawnError)('invalid record (un)watch key %s', key);
+          }
 
-          this._onChange(WatchableCellValueInFieldKeyPrefix + fieldId, fieldId);
-        }
       }
 
-      if (commentCount) {
-        this._onChange(WatchableRecordKeys.commentCount);
+      return {
+        querySpecToSubscribeWith: this._constructBlockFieldSelectionSpec(fieldSelectionDefinition),
+        onChangeCallback
+      };
+    }
+    /** @inheritdoc */
+
+  }, {
+    key: "watch",
+    value: function watch(keys, callbackForRegistration, context) {
+      var validKeys = this._getWatchableValidKeysOrThrow(keys, 'watch');
+
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
+
+      try {
+        for (var _iterator4 = validKeys[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var key = _step4.value;
+
+          if (_isKeySubscribeableViaRecordQuery(key)) {
+            var _this$_constructBlock = this._constructBlockQuerySpecAndCallbackForWatchableKey(key, callbackForRegistration, context),
+                querySpecToSubscribeWith = _this$_constructBlock.querySpecToSubscribeWith,
+                onChangeCallback = _this$_constructBlock.onChangeCallback;
+
+            this._queryManager.watchWithQuerySpec(_airtable_interface.BlockQueryCallbackPriority.BLOCK_CODE, querySpecToSubscribeWith, this, key, onChangeCallback, callbackForRegistration, context);
+          } else {
+            // fallback to regular watch logic
+            (0, _error_utils.invariant)(key.startsWith(WatchableColorInViewKeyPrefix), 'Unexpected key in watch: %s', key);
+            var viewId = key.substring(WatchableColorInViewKeyPrefix.length);
+
+            this._parentRecordStore.getViewDataStore(viewId).watch('recordColors', this._onRecordColorChange);
+
+            (0, _get2.default)((0, _getPrototypeOf2.default)(Record.prototype), "watch", this).call(this, key, callbackForRegistration, context);
+          }
+        }
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
       }
+
+      return validKeys;
     }
-    /**
-     * @internal
-     */
+    /** @inheritdoc */
 
   }, {
-    key: "__triggerOnChangeForRecordColorInViewId",
-    value: function __triggerOnChangeForRecordColorInViewId(viewId) {
-      this._onChange(WatchableColorInViewKeyPrefix + viewId);
+    key: "unwatch",
+    value: function unwatch(keys, callbackForRegistration, context) {
+      // 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, 'unwatch', true);
+
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
+
+      try {
+        for (var _iterator5 = validKeys[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var key = _step5.value;
+
+          if (_isKeySubscribeableViaRecordQuery(key)) {
+            this._queryManager.unwatchFromQueryKey(key, callbackForRegistration, context);
+          } else {
+            // fallback to regular watch logic
+            (0, _error_utils.invariant)(key.startsWith(WatchableColorInViewKeyPrefix), 'Unexpected key in unwatch: %s', key);
+            var viewId = key.substring(WatchableColorInViewKeyPrefix.length);
+
+            this._parentRecordStore.getViewDataStore(viewId).unwatch('recordColors', this._onRecordColorChange);
+
+            (0, _get2.default)((0, _getPrototypeOf2.default)(Record.prototype), "unwatch", this).call(this, key, callbackForRegistration, context);
+          }
+        }
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+            _iterator5.return();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
+        }
+      }
+
+      return validKeys;
     }
+    /** @internal */
+
   }, {
     key: "_dataOrNullIfDeleted",
     get: function get() {
-      var _recordsById$this$_id;
-
       var tableData = this._baseData.tablesById[this.parentTable.id];
 
       if (!tableData) {
         return null;
       }
 
-      var recordsById = tableData.recordsById;
-      (0, _error_utils.invariant)(recordsById, 'Record data is not loaded');
-      return (_recordsById$this$_id = recordsById[this._id]) !== null && _recordsById$this$_id !== void 0 ? _recordsById$this$_id : null;
-    }
-    /**
-     * The table that this record belongs to. Should never change because records aren't moved between tables.
-     *
-     * @internal (since we may not be able to return parent model instances in the immutable models world)
-     * @example
-     * ```js
-     * import {useRecords} from '@airtable/blocks/ui';
-     * const records = useRecords(myTable);
-     * console.log(records[0].parentTable.id === myTable.id);
-     * // => true
-     * ```
-     */
+      var isRecordLoaded = this._parentRecordStore.isRecordLoaded(this._id);
+
+      (0, _error_utils.invariant)(isRecordLoaded, 'Record data is not loaded');
+
+      var isRecordDeleted = this._parentRecordStore.isRecordDeleted(this._id);
 
+      return isRecordDeleted ? null : true;
+    }
   }, {
     key: "parentTable",
     get: function get() {
@@ -551,7 +802,9 @@ function (_AbstractModel) {
   }, {
     key: "commentCount",
     get: function get() {
-      return this._data.commentCount;
+      this._assertExistsAndLoaded();
+
+      return this._parentRecordStore.getRecordCommentCount(this._id);
     }
     /**
      * The created time of this record.
@@ -567,7 +820,9 @@ function (_AbstractModel) {
   }, {
     key: "createdTime",
     get: function get() {
-      return new Date(this._data.createdTime);
+      this._assertExistsAndLoaded();
+
+      return this._parentRecordStore.getRecordCreatedTime(this._id);
     }
   }]);
   return Record;

package/dist/cjs/models/record_query_result.js

@@ -22,7 +22,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.normalizeSortsOrGroups = normalizeSortsOrGroups;
-exports.default = void 0;
+exports.default = exports.WatchableRecordQueryResultKeys = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -61,6 +61,8 @@ var _record_coloring = require("./record_coloring");
 /** @module @airtable/blocks/models: RecordQueryResult */
 
 /** */
+
+/** @hidden */
 var WatchableRecordQueryResultKeys = Object.freeze({
   records: 'records',
   recordIds: 'recordIds',
@@ -70,6 +72,7 @@ var WatchableRecordQueryResultKeys = Object.freeze({
   groupLevels: 'groupLevels',
   isDataLoaded: 'isDataLoaded'
 });
+exports.WatchableRecordQueryResultKeys = WatchableRecordQueryResultKeys;
 var WatchableCellValuesInFieldKeyPrefix = 'cellValuesInField:'; // The string case is to accommodate cellValuesInField:$FieldId.
 
 /**