@airtable/blocks 1.8.0 → 1.9.0-experimental

package/CHANGELOG.md

@@ -9,9 +9,23 @@ Not every commit needs to result in a change to this file (e.g. docs and chore c
 commit that affects the code in a way that consumers might care about should include edits to the
 'Unreleased' section though. Breaking changes should be prefixed with `**BREAKING:**`.
 
-## [Unreleased](https://github.com/airtable/blocks/compare/@airtable/blocks@1.8.0...HEAD)
+## [Unreleased](https://github.com/airtable/blocks/compare/@airtable/blocks@1.9.0...HEAD)
 
-No changes.
+<<<<<<< seankeenan-at-fixTypoAndFormattingFromOpenPR
+
+-   # Fix typo in cursor.ts documentation - thanks @m2creates!
+-   Add new `calendarDay` icon (and micro variant)
+    > > > > > > > main
+
+## [1.9.0](https://github.com/airtable/blocks/compare/@airtable/blocks@1.8.0...@airtable/blocks@1.9.0) - 2021-09-15
+
+-   Update documentation for `FieldType.CHECKBOX` cell read & write types to be more accurate.
+-   Fetching field types & configs is now cached, making it more performant.
+-   Field descriptions can now be edited and specified when creating a new field:
+    -   Added `field.updateDescriptionAsync`.
+    -   Added optional `description` argument to `table.createFieldAsync`.
+    -   Added optional `description` property to `field` objects accepted by
+        `base.createTableAsync`.
 
 ## [1.8.0](https://github.com/airtable/blocks/compare/@airtable/blocks@1.7.2...@airtable/blocks@1.8.0) - 2021-07-12
 

package/dist/cjs/error_utils.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.spawnError = spawnError;
 exports.invariant = invariant;
 exports.spawnUnknownSwitchCaseError = spawnUnknownSwitchCaseError;
+exports.spawnExhaustiveSwitchError = spawnExhaustiveSwitchError;
 exports.spawnAbstractMethodError = spawnAbstractMethodError;
 
 // If errorOriginFn is specified, all frames above and including the call to errorOriginFn
@@ -79,6 +80,22 @@ function spawnUnknownSwitchCaseError(valueDescription, providedValue, key) {
   var providedValueKeyString = providedValueKey !== null && providedValueKey !== undefined ? providedValueKey : 'null';
   return spawnErrorWithOriginOmittedFromStackTrace('Unknown value %s for %s', [providedValueKeyString, valueDescription], spawnUnknownSwitchCaseError);
 }
+/**
+ * Forces TypeScript to prove that calling this function is impossible at a
+ * type level by accepting `never`. In the unlikely case this function is
+ * called we infer a useful error message.
+ *
+ * @internal
+ */
+
+
+function spawnExhaustiveSwitchError(impossibleValue) {
+  if (impossibleValue === null) {
+    return spawnErrorWithOriginOmittedFromStackTrace('Unexpected null in exhaustive switch', undefined, spawnExhaustiveSwitchError);
+  } else {
+    return spawnErrorWithOriginOmittedFromStackTrace("Unexpected %s in exhaustive switch", [typeof impossibleValue], spawnExhaustiveSwitchError);
+  }
+}
 /**
  * @internal
  */

package/dist/cjs/models/base.js

@@ -471,7 +471,8 @@ function (_AbstractModel) {
               type: field.type
             }, field.options ? {
               options: field.options
-            } : null) : undefined
+            } : null) : undefined,
+            description: field.description
           };
         })
       });
@@ -505,7 +506,8 @@ function (_AbstractModel) {
      * Creates a new table.
      *
      * Throws an error if the user does not have permission to create a table, if an invalid
-     * table name is provided, or if invalid fields are provided (invalid name, type or options).
+     * table name is provided, or if invalid fields are provided (invalid name, type, options or
+     * description).
      *
      * Refer to {@link FieldType} for supported field types, the write format for field options, and
      * other specifics for certain field types.
@@ -522,7 +524,10 @@ function (_AbstractModel) {
      * table in your app.
      *
      * @param name name for the table. must be case-insensitive unique
-     * @param fields array of fields to create in the table: see below for details.
+     * @param fields array of fields to create in the table: see below for an example. `name` and
+     * `type` must be specified for all fields, while `options` is only required for fields that
+     * have field options. `description` is optional and will be `''` if not specified or if
+     * specified as `null`.
      *
      * @example
      * ```js
@@ -530,7 +535,7 @@ function (_AbstractModel) {
      *     const name = 'My new table';
      *     const fields = [
      *         // Name will be the primary field of the table.
-     *         {name: 'Name', type: FieldType.SINGLE_LINE_TEXT},
+     *         {name: 'Name', type: FieldType.SINGLE_LINE_TEXT, description: 'This is the primary field'},
      *         {name: 'Notes', type: FieldType.RICH_TEXT},
      *         {name: 'Attachments', type: FieldType.MULTIPLE_ATTACHMENTS},
      *         {name: 'Number', type: FieldType.NUMBER, options: {
@@ -566,13 +571,19 @@ function (_AbstractModel) {
                 type: _mutations.MutationTypes.CREATE_SINGLE_TABLE,
                 name,
                 fields: fields.map(field => {
+                  var _field$description;
+
                   return {
                     name: field.name,
                     config: _objectSpread({
                       type: field.type
                     }, field.options ? {
                       options: field.options
-                    } : null)
+                    } : null),
+                    // Coerce undefined to null so that only old SDKs pass "undefined" for description
+                    // '' is permitted, as we already set empty descriptions to '' when editing descriptions
+                    // from the UI
+                    description: (_field$description = field.description) !== null && _field$description !== void 0 ? _field$description : null
                   };
                 })
               }));

package/dist/cjs/models/cursor.js

@@ -89,6 +89,7 @@ var WatchableCursorKeys = Object.freeze({
  *      return (
  *          <div>
  *              Active table: {cursor.activeTableId}
+ *              <br />
  *              Active view: {cursor.activeViewId}
  *          </div>
  *      );
@@ -109,6 +110,7 @@ var WatchableCursorKeys = Object.freeze({
  *      return (
  *          <div>
  *              Selected records: {cursor.selectedRecordIds.join(', ')}
+ *              <br />
  *              Selected fields: {cursor.selectedFieldIds.join(', ')}
  *          </div>
  *      );

package/dist/cjs/models/field.js

@@ -109,7 +109,9 @@ function (_AbstractModel) {
     (0, _classCallCheck2.default)(this, Field);
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Field).call(this, sdk, fieldId));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentTable", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_cachedFieldTypeConfigOrNull", void 0);
     _this._parentTable = parentTable;
+    _this._cachedFieldTypeConfigOrNull = null;
     return _this;
   }
   /**
@@ -118,6 +120,42 @@ function (_AbstractModel) {
 
 
   (0, _createClass2.default)(Field, [{
+    key: "_getCachedConfigFromFieldTypeProvider",
+    // We use a cached response from FieldTypeProvider because getting the config can
+    // be an expensive operation. In particular when fieldConfigs are extremely large
+    // (eg: Select fields with lots of select options)
+    value: function _getCachedConfigFromFieldTypeProvider() {
+      if (this._cachedFieldTypeConfigOrNull !== null) {
+        return this._cachedFieldTypeConfigOrNull;
+      }
+
+      var airtableInterface = this._sdk.__airtableInterface;
+      var appInterface = this._sdk.__appInterface;
+      this._cachedFieldTypeConfigOrNull = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById());
+      return this._cachedFieldTypeConfigOrNull;
+    }
+  }, {
+    key: "_clearCachedConfig",
+    value: function _clearCachedConfig() {
+      this._cachedFieldTypeConfigOrNull = null;
+    }
+    /**
+     * The type and options of the field to make type narrowing `FieldOptions` easier.
+     *
+     * @see {@link FieldConfig}
+     * @example
+     * const fieldConfig = field.config;
+     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
+     *     return fieldConfig.options.choices;
+     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
+     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
+     *         return fieldConfig.options.result.options.choices;
+     *     }
+     * }
+     * return DEFAULT_CHOICES;
+     */
+
+  }, {
     key: "checkPermissionsForUpdateOptions",
 
     /**
@@ -125,7 +163,7 @@ function (_AbstractModel) {
      *
      * Accepts partial input, in the same format as {@link updateOptionsAsync}.
      *
-     * Returns `{hasPermission: true}` if the current user can update the specified record,
+     * Returns `{hasPermission: true}` if the current user can update the specified field,
      * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
      * used to display an error message to the user.
      *
@@ -241,6 +279,104 @@ function (_AbstractModel) {
         }
       }, null, this);
     }
+    /**
+     * Checks whether the current user has permission to perform the given description update.
+     *
+     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.
+     *
+     * Returns `{hasPermission: true}` if the current user can update the specified field,
+     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+     * used to display an error message to the user.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * const updateFieldCheckResult = field.checkPermissionsForUpdateDescription();
+     *
+     * if (!updateFieldCheckResult.hasPermission) {
+     *     alert(updateFieldCheckResult.reasonDisplayString);
+     * }
+     * ```
+     */
+
+  }, {
+    key: "checkPermissionsForUpdateDescription",
+    value: function checkPermissionsForUpdateDescription(description) {
+      return this._sdk.__mutations.checkPermissionsForMutation({
+        type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,
+        tableId: this.parentTable.id,
+        id: this.id,
+        description
+      });
+    }
+    /**
+     * An alias for `checkPermissionsForUpdateDescription(options).hasPermission`.
+     *
+     * Checks whether the current user has permission to perform the description update.
+     *
+     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * const canUpdateField = field.hasPermissionToUpdateDescription();
+     *
+     * if (!canUpdateField) {
+     *     alert('not allowed!');
+     * }
+     * ```
+     */
+
+  }, {
+    key: "hasPermissionToUpdateDescription",
+    value: function hasPermissionToUpdateDescription(description) {
+      return this.checkPermissionsForUpdateDescription(description).hasPermission;
+    }
+    /**
+     * Updates the description for this field.
+     *
+     * To remove an existing description, pass `''` as the new description.
+     * `null` is also accepted and will be coerced to `''` for consistency with field creation.
+     *
+     * Throws an error if the user does not have permission to update the field, or if an invalid
+     * description is provided.
+     *
+     * This action is asynchronous. Unlike updates to cell values, updates to field descriptions are
+     * **not** applied optimistically locally. You must `await` the returned promise before
+     * relying on the change in your app.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * await myTextField.updateDescriptionAsync('This is a text field');
+     * ```
+     */
+
+  }, {
+    key: "updateDescriptionAsync",
+    value: function updateDescriptionAsync(description) {
+      return _regenerator.default.async(function updateDescriptionAsync$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return _regenerator.default.awrap(this._sdk.__mutations.applyMutationAsync({
+                type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,
+                tableId: this.parentTable.id,
+                id: this.id,
+                description
+              }));
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this);
+    }
     /**
      * `true` if this field is computed, `false` otherwise. A field is
      * "computed" if it's value is not set by user input (e.g. autoNumber, formula,
@@ -329,6 +465,9 @@ function (_AbstractModel) {
   }, {
     key: "__triggerOnChangeForDirtyPaths",
     value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
+      // Always clear the cached config when anything on the field data model changes
+      this._clearCachedConfig();
+
       if (dirtyPaths.name) {
         this._onChange(WatchableFieldKeys.name);
       }
@@ -402,11 +541,8 @@ function (_AbstractModel) {
   }, {
     key: "type",
     get: function get() {
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-
-      var _airtableInterface$fi = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById()),
-          type = _airtableInterface$fi.type; // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
+      var _this$_getCachedConfi = this._getCachedConfigFromFieldTypeProvider(),
+          type = _this$_getCachedConfi.type; // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
       // until the transition is complete. See <https://airtable.quip.com/VxaMAmAfUscs> for more.
       // @ts-ignore
 
@@ -437,31 +573,14 @@ function (_AbstractModel) {
   }, {
     key: "options",
     get: function get() {
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-
-      var _airtableInterface$fi2 = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById()),
-          options = _airtableInterface$fi2.options; // TODO(emma): can we remove this cloneDeep?
+      var _this$_getCachedConfi2 = this._getCachedConfigFromFieldTypeProvider(),
+          options = _this$_getCachedConfi2.options; // TODO: In the next breaking release freeze (inside of the cache) and replace
+      // FieldOptions with readonly<FieldOptions>.
+      // Today this is required because we re-use the fieldTypeProvider.getConfig response.
 
 
       return options ? (0, _private_utils.cloneDeep)(options) : null;
     }
-    /**
-     * The type and options of the field to make type narrowing `FieldOptions` easier.
-     *
-     * @see {@link FieldConfig}
-     * @example
-     * const fieldConfig = field.config;
-     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
-     *     return fieldConfig.options.choices;
-     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
-     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
-     *         return fieldConfig.options.result.options.choices;
-     *     }
-     * }
-     * return DEFAULT_CHOICES;
-     */
-
   }, {
     key: "config",
     get: function get() {

package/dist/cjs/models/grouped_record_query_result.js

@@ -245,19 +245,13 @@ function (_RecordQueryResult) {
         while (1) {
           switch (_context2.prev = _context2.next) {
             case 0:
-              this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this); // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
-              // TODO: (SeanKeenan) At the moment this should never be relevant, because groups are recreated
-              // anytime the groups change - but this is how it should work once groups persist AND
-              // watching recordIds only changes if records in this group change.
-              // In the meantime this does ensure that a deleted GroupedRecordQuery with stale recordIds
-              // doesn't return the cached array.
+              // TODO: This entire class assumes it is torn down and re-created by the parent whenever
+              // a change to the group is made.
+              this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this);
 
-
-              this.watch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
-              this.watch(['recordIds'], this._invalidateRecordIdsSet, this);
               return _context2.abrupt("return", this._getChangedKeysOnLoad());
 
-            case 4:
+            case 2:
             case "end":
               return _context2.stop();
           }
@@ -269,10 +263,7 @@ function (_RecordQueryResult) {
   }, {
     key: "_unloadData",
     value: function _unloadData() {
-      // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
-      this.unwatch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
-      this.unwatch(['recordIds'], this._invalidateRecordIdsSet, this); // Invalidate both of the caches, as this object can no longer be accessed
-
+      // Invalidate both of the caches, as this object can no longer be accessed
       this._invalidateComputedRecordIds();
 
       this._invalidateRecordIdsSet();

package/dist/cjs/models/linked_records_query_result.js

@@ -29,6 +29,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.getLinkedTableId = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 require("regenerator-runtime/runtime");
@@ -53,8 +55,12 @@ var _field = require("../types/field");
 
 var _error_utils = require("../error_utils");
 
+var _block_query_spec = require("../types/block_query_spec");
+
 var _record_query_result = _interopRequireDefault(require("./record_query_result"));
 
+var _record_store = require("./record_store");
+
 /** @module @airtable/blocks/models: RecordQueryResult */
 
 /** */
@@ -118,6 +124,8 @@ function (_RecordQueryResult) {
 
   /** @internal */
 
+  /** @internal */
+
   /** @internal */
   function LinkedRecordsQueryResult(record, field, normalizedOpts, sdk) {
     var _this;
@@ -134,6 +142,7 @@ function (_RecordQueryResult) {
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_computedRecordIdsSet", null);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_computedFilteredSortedRecordIds", null);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_cellValueChangeHandlerByFieldId", {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_recordStoreQueryId", null);
     (0, _error_utils.invariant)(record.parentTable === field.parentTable, 'record and field must belong to the same table');
     _this._record = record;
     _this._field = field;
@@ -279,7 +288,7 @@ function (_RecordQueryResult) {
   }, {
     key: "_loadDataAsync",
     value: function _loadDataAsync() {
-      var initiallyLoaded, changedKeys, fieldIds, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, fieldId;
+      var initiallyLoaded, _ref, _ref2, recordStoreQueryId, changedKeys, fieldIds, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, fieldId;
 
       return _regenerator.default.async(function _loadDataAsync$(_context2) {
         while (1) {
@@ -291,11 +300,21 @@ function (_RecordQueryResult) {
 
               this._watchLinkedQueryResult();
 
-              initiallyLoaded = this._linkedQueryResult.isDataLoaded;
+              initiallyLoaded = this._linkedQueryResult.isDataLoaded; // https://airtable.com/appahuJQw7qfQTBBU/tblSbpimM8Spp9txp/viweAFIus3MhU9Gxa/recNjFYJpeV23LPhH?blocks=hide
+              // TODO: (#proj-blocks-sdk-record-limits) Currently queries all cell values in a table
+              // when loading linked record data. Must add a LinkedRecord query type in the future.
+              // Since _loadDataAsync can only be called once, this recordStoreQueryId is only set once,
+              // although it is guaranteed to be stable if needed (so long as this._field.id is stable)
+
               _context2.next = 6;
-              return _regenerator.default.awrap(Promise.all([this._sdk.base.__getRecordStore(this._record.parentTable.id).loadCellValuesInFieldIdsAsync([this._field.id]), this._linkedQueryResult.loadDataAsync(), this._loadRecordColorsAsync()]));
+              return _regenerator.default.awrap(Promise.all([this._sdk.base.__getRecordStore(this._record.parentTable.id).loadAllCellValuesInFieldIdsAsync([this._field.id]), this._linkedQueryResult.loadDataAsync(), this._loadRecordColorsAsync()]));
 
             case 6:
+              _ref = _context2.sent;
+              _ref2 = (0, _slicedToArray2.default)(_ref, 1);
+              recordStoreQueryId = _ref2[0];
+              this._recordStoreQueryId = recordStoreQueryId;
+
               this._invalidateComputedData();
 
               changedKeys = ['records', 'recordIds', 'recordColors']; // If the linked query result was not initially loaded, then the
@@ -311,55 +330,55 @@ function (_RecordQueryResult) {
               _iteratorNormalCompletion3 = true;
               _didIteratorError3 = false;
               _iteratorError3 = undefined;
-              _context2.prev = 13;
+              _context2.prev = 17;
 
               for (_iterator3 = fieldIds[Symbol.iterator](); !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                 fieldId = _step3.value;
                 changedKeys.push(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
               }
 
-              _context2.next = 21;
+              _context2.next = 25;
               break;
 
-            case 17:
-              _context2.prev = 17;
-              _context2.t0 = _context2["catch"](13);
+            case 21:
+              _context2.prev = 21;
+              _context2.t0 = _context2["catch"](17);
               _didIteratorError3 = true;
               _iteratorError3 = _context2.t0;
 
-            case 21:
-              _context2.prev = 21;
-              _context2.prev = 22;
+            case 25:
+              _context2.prev = 25;
+              _context2.prev = 26;
 
               if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
                 _iterator3.return();
               }
 
-            case 24:
-              _context2.prev = 24;
+            case 28:
+              _context2.prev = 28;
 
               if (!_didIteratorError3) {
-                _context2.next = 27;
+                _context2.next = 31;
                 break;
               }
 
               throw _iteratorError3;
 
-            case 27:
-              return _context2.finish(24);
+            case 31:
+              return _context2.finish(28);
 
-            case 28:
-              return _context2.finish(21);
+            case 32:
+              return _context2.finish(25);
 
-            case 29:
+            case 33:
               return _context2.abrupt("return", changedKeys);
 
-            case 30:
+            case 34:
             case "end":
               return _context2.stop();
           }
         }
-      }, null, this, [[13, 17, 21, 29], [22,, 24, 28]]);
+      }, null, this, [[17, 21, 25, 33], [26,, 28, 32]]);
     }
     /** @internal */
 
@@ -376,7 +395,9 @@ function (_RecordQueryResult) {
 
         this._unwatchLinkedQueryResult();
 
-        this._sdk.base.__getRecordStore(this._record.parentTable.id).unloadCellValuesInFieldIds([this._field.id]);
+        (0, _error_utils.invariant)(this._recordStoreQueryId, 'Unsubscribing from linked record record store without queryId');
+
+        this._sdk.base.__getRecordStore(this._record.parentTable.id).unloadCellValuesForQueryIdsThatAreSubscribedToAllCells([this._recordStoreQueryId]);
 
         this._linkedQueryResult.unloadData();
 
@@ -448,7 +469,12 @@ function (_RecordQueryResult) {
       // result
 
 
-      this._originRecordStore.watch('recordIds', this._onOriginRecordsChange, this); // if the linked field in the origin table is deleted, we need to
+      this._originRecordStore.watchWithRecordQueryResult({
+        recordQueryResult: this,
+        keys: _record_store.WatchableRecordStoreKeys.recordIds,
+        callbackForRegistration: this._onOriginRecordsChange,
+        context: this
+      }); // if the linked field in the origin table is deleted, we need to
       // invalidate this result
 
 
@@ -592,11 +618,12 @@ function (_RecordQueryResult) {
           if (Array.isArray(recordIds)) {
             var recordIdsSet = this._getOrGenerateRecordIdsSet();
 
-            var filteredRecordIds = recordIds.filter(id => typeof id === 'string' && recordIdsSet[id] === true);
+            var filteredRecordIds = recordIds.filter(id => typeof id === 'string' && recordIdsSet[id] === true); // There should always be a filteredRecordIds found for this query
+            // type - not finding any is a fundamental mistake in our query engine
 
-            if (filteredRecordIds.length) {
-              this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, filteredRecordIds);
-            }
+            (0, _error_utils.invariant)(filteredRecordIds.length, 'Filtered record change on incorrect record, query engine issue');
+
+            this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, filteredRecordIds);
           } else {
             this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
           }
@@ -776,6 +803,27 @@ function (_RecordQueryResult) {
       (0, _error_utils.invariant)(recordIdsSet, 'recordIdsSet must exist');
       return recordIdsSet;
     }
+    /**
+     * This allows a record query result to specify the source of the query
+     * eg: View, Table, Linked record when watching fields.
+     * This scopes the watch to those fields + rows in the query.
+     *
+     * @internal
+     */
+
+  }, {
+    key: "__constructQuerySpecForBlockFieldSelectionSpec",
+    value: function __constructQuerySpecForBlockFieldSelectionSpec(fieldSelection) {
+      // The origin tableId is always the one referred to here as we must watch the origin record for deletion
+      var originTableId = this._record.parentTable.id;
+      return {
+        sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
+        sourceTableId: originTableId,
+        recordSelection: {
+          fieldSelection
+        }
+      };
+    }
   }, {
     key: "isValid",
     get: function get() {

package/dist/cjs/models/mutation_constants.js

@@ -3,10 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MAX_NUM_FIELDS_PER_TABLE = exports.MAX_TABLE_NAME_LENGTH = exports.MAX_FIELD_NAME_LENGTH = void 0;
+exports.MAX_NUM_FIELDS_PER_TABLE = exports.MAX_TABLE_NAME_LENGTH = exports.MAX_FIELD_DESCRIPTION_LENGTH = exports.MAX_FIELD_NAME_LENGTH = void 0;
 // Mirrored from clientServerSharedConfigSettings
 var MAX_FIELD_NAME_LENGTH = 255;
 exports.MAX_FIELD_NAME_LENGTH = MAX_FIELD_NAME_LENGTH;
+var MAX_FIELD_DESCRIPTION_LENGTH = 20000;
+exports.MAX_FIELD_DESCRIPTION_LENGTH = MAX_FIELD_DESCRIPTION_LENGTH;
 var MAX_TABLE_NAME_LENGTH = 255;
 exports.MAX_TABLE_NAME_LENGTH = MAX_TABLE_NAME_LENGTH;
 var MAX_NUM_FIELDS_PER_TABLE = 500;