@airtable/blocks 1.10.2-experimental-640bd10-20220211 → 1.11.1-experimental-68738f2-20220526

package/dist/cjs/error_utils.js

@@ -1,16 +1,12 @@
 "use strict";
 
-require("core-js/modules/es.array.iterator");
-
 require("core-js/modules/es.string.replace");
 
-require("core-js/modules/web.dom-collections.iterator");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.spawnError = spawnError;
-exports.logErrorToRollbar = logErrorToRollbar;
+exports.logErrorToSentry = logErrorToSentry;
 exports.invariant = invariant;
 exports.spawnUnknownSwitchCaseError = spawnUnknownSwitchCaseError;
 exports.spawnExhaustiveSwitchError = spawnExhaustiveSwitchError;
@@ -61,22 +57,19 @@ function spawnError(errorMessageFormat) {
 } // istanbul ignore next
 
 /**
- * Logs an error to Rollbar
+ * Logs an error to Sentry. This is currently unused while the SDK is in the experimental status,
+ * but we leave the definition here for future usage needs.
  *
  * @hidden
  */
 
 
-function logErrorToRollbar(errorMessageFormat) {
-  // See this comment for how to log via Rollbar: https://github.com/Hyperbase/hyperbase/blob/009dcd1dc4c5204277c2939e7f61dfce74535f30/client/run_block_frame.tsx#L548
-  var rollbar = window.Rollbar;
-
-  if (rollbar === null || rollbar === void 0 ? void 0 : rollbar.warn) {
-    for (var _len2 = arguments.length, errorMessageArgs = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-      errorMessageArgs[_key2 - 1] = arguments[_key2];
-    }
+function logErrorToSentry(errorMessage, metadata) {
+  // See this comment for how to log via Sentry: https://github.com/Hyperbase/hyperbase/blob/2c5438ecaddcb9fa196e027e40df5e0c68c90989/client/run_block_frame.tsx#L333
+  var blocksErrorReporter = window.blocksErrorReporter;
 
-    rollbar.warn(spawnError(errorMessageFormat, ...errorMessageArgs));
+  if (blocksErrorReporter === null || blocksErrorReporter === void 0 ? void 0 : blocksErrorReporter.reportWarning) {
+    blocksErrorReporter.reportWarning(errorMessage, metadata);
   }
 }
 /**
@@ -88,8 +81,8 @@ function logErrorToRollbar(errorMessageFormat) {
 
 function invariant(condition, errorMessageFormat) {
   if (!condition) {
-    for (var _len3 = arguments.length, errorMessageArgs = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
-      errorMessageArgs[_key3 - 2] = arguments[_key3];
+    for (var _len2 = arguments.length, errorMessageArgs = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+      errorMessageArgs[_key2 - 2] = arguments[_key2];
     }
 
     throw spawnErrorWithOriginOmittedFromStackTrace(errorMessageFormat, errorMessageArgs, invariant);

package/dist/cjs/models/base.js

@@ -607,7 +607,7 @@ function (_AbstractModel) {
     value: function getMaxRecordsPerTable() {
       var _this$_data$maxRowsPe;
 
-      return (_this$_data$maxRowsPe = this._data.maxRowsPerTable) !== null && _this$_data$maxRowsPe !== void 0 ? _this$_data$maxRowsPe : 50000;
+      return (_this$_data$maxRowsPe = this._data.maxRowsPerTable) !== null && _this$_data$maxRowsPe !== void 0 ? _this$_data$maxRowsPe : 100000;
     }
     /**
      * @internal
@@ -864,6 +864,21 @@ function (_AbstractModel) {
     get: function get() {
       return this._data.name;
     }
+    /**
+     * The workspace id of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log('The workspace id of your base is', base.workspaceId);
+     * ```
+     */
+
+  }, {
+    key: "workspaceId",
+    get: function get() {
+      return this._data.workspaceId;
+    }
     /**
      * The color of the base.
      *

package/dist/cjs/models/cursor.js

@@ -268,9 +268,8 @@ function (_AbstractModelWithAsy) {
     key: "setActiveTable",
 
     /**
-     * Sets the specified table to active in the Airtable UI. If the apps pane is fullscreen, the
-     * table will still be set as active, but the apps pane will continue to be displayed
-     * fullscreen.
+     * Sets the specified table to active in the Airtable UI. If the app installation or apps pane
+     * is fullscreen, fullscreen mode will be exited.
      *
      * @param tableOrTableId The target table or table ID to set as active in the Airtable main page.
      */
@@ -280,9 +279,8 @@ function (_AbstractModelWithAsy) {
       this._sdk.__airtableInterface.setActiveViewOrTable(tableId);
     }
     /**
-     * Sets the specified view (and corresponding table) to active in the Airtable UI. If the apps
-     * pane is fullscreen, the view will still be set as active, but the apps pane will continue
-     * to be displayed fullscreen.
+     * Sets the specified view (and corresponding table) to active in the Airtable UI. If the app
+     * installation or apps pane is fullscreen, fullscreen mode will be exited.
      *
      * @param tableOrTableId The table or table ID that the target view belongs to.
      * @param viewOrViewId The target view or view ID to set as active in the Airtable main page.

package/dist/cjs/models/field.js

@@ -279,6 +279,101 @@ function (_AbstractModel) {
         }
       }, null, this);
     }
+    /**
+     * Checks whether the current user has permission to perform the given name update.
+     *
+     * Accepts partial input, in the same format as {@link updateNameAsync}.
+     *
+     * 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 name new name for the field
+     *
+     * @example
+     * ```js
+     * const updateFieldCheckResult = field.checkPermissionsForUpdateName();
+     *
+     * if (!updateFieldCheckResult.hasPermission) {
+     *     alert(updateFieldCheckResult.reasonDisplayString);
+     * }
+     * ```
+     */
+
+  }, {
+    key: "checkPermissionsForUpdateName",
+    value: function checkPermissionsForUpdateName(name) {
+      return this._sdk.__mutations.checkPermissionsForMutation({
+        type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME,
+        tableId: this.parentTable.id,
+        id: this.id,
+        name
+      });
+    }
+    /**
+     * An alias for `checkPermissionsForUpdateName(options).hasPermission`.
+     *
+     * Checks whether the current user has permission to perform the name update.
+     *
+     * Accepts partial input, in the same format as {@link updateNameAsync}.
+     *
+     * @param name new name for the field
+     *
+     * @example
+     * ```js
+     * const canUpdateField = field.hasPermissionToUpdateName();
+     *
+     * if (!canUpdateField) {
+     *     alert('not allowed!');
+     * }
+     * ```
+     */
+
+  }, {
+    key: "hasPermissionToUpdateName",
+    value: function hasPermissionToUpdateName(name) {
+      return this.checkPermissionsForUpdateName(name).hasPermission;
+    }
+    /**
+     * Updates the name for this field.
+     *
+     * Throws an error if the user does not have permission to update the field, or if an invalid
+     * name is provided.
+     *
+     * This action is asynchronous. Unlike updates to cell values, updates to field name are
+     * **not** applied optimistically locally. You must `await` the returned promise before
+     * relying on the change in your app.
+     *
+     * @param name new name for the field
+     *
+     * @example
+     * ```js
+     * await myTextField.updateNameAsync('My New Name');
+     * ```
+     */
+
+  }, {
+    key: "updateNameAsync",
+    value: function updateNameAsync(name) {
+      return _regenerator.default.async(function updateNameAsync$(_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_NAME,
+                tableId: this.parentTable.id,
+                id: this.id,
+                name
+              }));
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this);
+    }
     /**
      * Checks whether the current user has permission to perform the given description update.
      *
@@ -358,11 +453,11 @@ function (_AbstractModel) {
   }, {
     key: "updateDescriptionAsync",
     value: function updateDescriptionAsync(description) {
-      return _regenerator.default.async(function updateDescriptionAsync$(_context2) {
+      return _regenerator.default.async(function updateDescriptionAsync$(_context3) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
-              _context2.next = 2;
+              _context3.next = 2;
               return _regenerator.default.awrap(this._sdk.__mutations.applyMutationAsync({
                 type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,
                 tableId: this.parentTable.id,
@@ -372,7 +467,7 @@ function (_AbstractModel) {
 
             case 2:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
         }
       }, null, this);

package/dist/cjs/models/linked_records_query_result.js

@@ -549,12 +549,17 @@ function (_RecordQueryResult) {
   }, {
     key: "_onLinkedRecordIdsChange",
     value: function _onLinkedRecordIdsChange() {
-      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
-
-      if (!this.isDataLoaded) {
+      if (!this.isDataLoaded || this._record.isDeleted) {
+        //TODO(jamesmoody-at): Adding this._dataOrNullIfDeleted as an exit condition here is a temporary fix to address an issue where
+        // we are not reseting isValid to true while restoring deleted records that contain linked record fields. It seems the only way
+        // to do this is by creating a new LinkRecordsQueryResult instance but it seems like we might be reusing the original instance
+        // that we've already set isValid to false with. We'll need to do more investigating to figure out the right way to restore these
+        // records while keeping the behavior of isValid consistent
         return;
       }
 
+      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
+
       this._invalidateComputedData(); // we don't actually know at this stage whether anything changed or
       // not. it may have done though, so notify watchers
 
@@ -640,15 +645,19 @@ function (_RecordQueryResult) {
   }, {
     key: "_onOriginCellValueChange",
     value: function _onOriginCellValueChange() {
-      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
-
-      if (!this.isDataLoaded) {
+      if (!this.isDataLoaded || this._field.isDeleted) {
+        //TODO(jamesmoody-at): Adding this._dataOrNullIfDeleted as an exit condition here is a temporary fix to address an issue where
+        // we are not resetting isValid to true while restoring deleted records that contain linked record fields. It seems the only way
+        // to do this is by creating a new LinkRecordsQueryResult instance but it seems like we might be reusing the original instance
+        // that we've already set isValid to false with. We'll need to do more investigating to figure out the right way to restore these
+        // records while keeping the behavior of isValid consistent
         return;
-      } // when the origin cell value (listing all the linked records) changes,
+      }
+
+      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid'); // when the origin cell value (listing all the linked records) changes,
       // invalidate all the data we have stored - we need to completely
       // regenerate it
 
-
       this._invalidateComputedData(); // notify watchers that our set of linked records has changed
 
 

package/dist/cjs/models/mutations.js

@@ -215,6 +215,26 @@ function () {
     }
     /** @internal */
 
+  }, {
+    key: "_assertFieldNameIsValidForMutation",
+    value: function _assertFieldNameIsValidForMutation(name, table) {
+      if (!name) {
+        throw (0, _error_utils.spawnError)("Can't create or update field: must provide non-empty name");
+      }
+
+      if (name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
+        throw (0, _error_utils.spawnError)("Can't create or update field: name '%s' exceeds maximum length of %s characters", name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
+      } // Verify the new name doesn't collide with any existing field name.
+
+
+      var existingLowercaseFieldNames = table.fields.map(field => field.name.toLowerCase());
+
+      if (existingLowercaseFieldNames.includes(name.toLowerCase())) {
+        throw (0, _error_utils.spawnError)("Can't create or update field: field with name '%s' already exists", name);
+      }
+    }
+    /** @internal */
+
   }, {
     key: "_assertMutationIsValid",
     value: function _assertMutationIsValid(mutation) {
@@ -448,19 +468,7 @@ function () {
               throw (0, _error_utils.spawnError)("Can't create field: table already has the maximum of %s fields", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
             }
 
-            if (!name) {
-              throw (0, _error_utils.spawnError)("Can't create field: must provide non-empty name");
-            }
-
-            if (name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
-              throw (0, _error_utils.spawnError)("Can't create field: name '%s' exceeds maximum length of %s characters", name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
-            }
-
-            var existingLowercaseFieldNames = _table3.fields.map(field => field.name.toLowerCase());
-
-            if (existingLowercaseFieldNames.includes(name.toLowerCase())) {
-              throw (0, _error_utils.spawnError)("Can't create field: field with name '%s' already exists", name);
-            } // Current config / field data is null since the field doesn't exist.
+            this._assertFieldNameIsValidForMutation(name, _table3); // Current config / field data is null since the field doesn't exist.
 
 
             var _validationResult2 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, config, null, null, billingPlanGrouping);
@@ -534,23 +542,51 @@ function () {
             return;
           }
 
+        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+          {
+            var _tableId6 = mutation.tableId,
+                _id2 = mutation.id,
+                _name = mutation.name;
+
+            var _table6 = this._base.getTableByIdIfExists(_tableId6);
+
+            if (!_table6) {
+              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId6);
+            }
+
+            var _field4 = _table6.getFieldByIdIfExists(_id2);
+
+            if (!_field4) {
+              throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", _id2);
+            } // We skip name validation if it's the same name:
+            // If it's exactly same name, this will result in no-op;
+            // If it's only case change, we allow update and we know this name is already validated before;
+
+
+            if (_field4.name.toLowerCase() !== _name.toLowerCase()) {
+              this._assertFieldNameIsValidForMutation(_name, _table6);
+            }
+
+            return;
+          }
+
         case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
           {
-            var _name = mutation.name,
+            var _name2 = mutation.name,
                 fields = mutation.fields;
 
-            if (!_name) {
+            if (!_name2) {
               throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name");
             }
 
-            if (_name.length > _mutation_constants.MAX_TABLE_NAME_LENGTH) {
-              throw (0, _error_utils.spawnError)("Can't create table: name '%s' exceeds maximum length of %s characters", _name, _mutation_constants.MAX_TABLE_NAME_LENGTH);
+            if (_name2.length > _mutation_constants.MAX_TABLE_NAME_LENGTH) {
+              throw (0, _error_utils.spawnError)("Can't create table: name '%s' exceeds maximum length of %s characters", _name2, _mutation_constants.MAX_TABLE_NAME_LENGTH);
             }
 
             var existingLowercaseTableNames = this._base.tables.map(table => table.name.toLowerCase());
 
-            if (existingLowercaseTableNames.includes(_name.toLowerCase())) {
-              throw (0, _error_utils.spawnError)("Can't create table: table with name '%s' already exists", _name);
+            if (existingLowercaseTableNames.includes(_name2.toLowerCase())) {
+              throw (0, _error_utils.spawnError)("Can't create table: table with name '%s' already exists", _name2);
             }
 
             if (fields.length === 0) {
@@ -568,32 +604,32 @@ function () {
 
             try {
               for (var _iterator4 = fields[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-                var _field4 = _step4.value;
+                var _field5 = _step4.value;
 
-                if (!_field4.name) {
+                if (!_field5.name) {
                   throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name for every field");
                 }
 
-                if (_field4.name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
-                  throw (0, _error_utils.spawnError)("Can't create table: field name '%s' exceeds maximum length of %s characters", _field4.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
+                if (_field5.name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
+                  throw (0, _error_utils.spawnError)("Can't create table: field name '%s' exceeds maximum length of %s characters", _field5.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
                 }
 
-                var lowercaseFieldName = _field4.name.toLowerCase();
+                var lowercaseFieldName = _field5.name.toLowerCase();
 
                 if (lowercaseFieldNames.has(lowercaseFieldName)) {
-                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field4.name);
+                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field5.name);
                 }
 
                 lowercaseFieldNames.add(lowercaseFieldName); // Current config / field data is null since the field doesn't exist.
 
-                var _validationResult4 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _field4.config, null, null, billingPlanGrouping);
+                var _validationResult4 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _field5.config, null, null, billingPlanGrouping);
 
                 if (!_validationResult4.isValid) {
-                  throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", _field4.name, _validationResult4.reason);
+                  throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", _field5.name, _validationResult4.reason);
                 }
 
-                if (_field4.description && _field4.description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
-                  throw (0, _error_utils.spawnError)("Can't create table: description for field '%s' exceeds maximum length of %s characters", _field4.name, _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+                if (_field5.description && _field5.description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
+                  throw (0, _error_utils.spawnError)("Can't create table: description for field '%s' exceeds maximum length of %s characters", _field5.name, _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
                 }
               }
             } catch (err) {
@@ -622,7 +658,7 @@ function () {
 
         case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
           {
-            var _tableId6 = mutation.tableId,
+            var _tableId7 = mutation.tableId,
                 viewId = mutation.viewId;
             var runContext = this._airtableInterface.sdkInitData.runContext;
 
@@ -630,17 +666,17 @@ function () {
               throw (0, _error_utils.spawnError)('Setting view metadata is only valid for views');
             }
 
-            if (runContext.viewId !== viewId || runContext.tableId !== _tableId6) {
+            if (runContext.viewId !== viewId || runContext.tableId !== _tableId7) {
               throw (0, _error_utils.spawnError)('Custom views can only set view metadata on themselves');
             }
 
-            var _table6 = this._base.getTableByIdIfExists(_tableId6);
+            var _table7 = this._base.getTableByIdIfExists(_tableId7);
 
-            if (!_table6) {
-              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId6);
+            if (!_table7) {
+              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId7);
             }
 
-            var view = _table6.getViewByIdIfExists(viewId);
+            var view = _table7.getViewByIdIfExists(viewId);
 
             if (!view) {
               throw (0, _error_utils.spawnError)("Can't update metadata: No view with id %s exists", viewId);

package/dist/cjs/sdk.js

@@ -340,4 +340,4 @@ function () {
 }();
 
 exports.default = BlockSdk;
-(0, _defineProperty2.default)(BlockSdk, "VERSION", "1.10.2-experimental-640bd10-20220211");
+(0, _defineProperty2.default)(BlockSdk, "VERSION", "1.11.1-experimental-68738f2-20220526");

package/dist/cjs/testing/fixture_data.js

@@ -49,6 +49,7 @@ var MOCK_BASE_PERMISSION_LEVEL = 'create';
 var MOCK_CURRENT_USER_ID = 'usrGalSamari';
 var MOCK_BASE_COLOR = 'purple';
 var MOCK_BILLING_GROUP = 'pro';
+var MOCK_WORKSPACE_ID = 'wspUai0ZmWFWfSBtb';
 /** @hidden */
 
 function convertFixtureDataToSdkInitData(fixtureData) {
@@ -58,6 +59,7 @@ function convertFixtureDataToSdkInitData(fixtureData) {
       color = _fixtureData$base.color,
       tables = _fixtureData$base.tables,
       collaborators = _fixtureData$base.collaborators,
+      workspaceId = _fixtureData$base.workspaceId,
       globalConfig = fixtureData.globalConfig;
   var tablesById = {};
 
@@ -126,6 +128,7 @@ function convertFixtureDataToSdkInitData(fixtureData) {
         };
       }), _private_utils.getId),
       activeCollaboratorIds: collaborators.filter(c => c.isActive).map(c => c.id),
+      workspaceId: workspaceId !== null && workspaceId !== void 0 ? workspaceId : MOCK_WORKSPACE_ID,
       cursorData: null,
       billingPlanGrouping: MOCK_BILLING_GROUP,
       appInterface: {},

package/dist/cjs/testing/mock_base_data_stores.js

@@ -83,6 +83,7 @@ var unmodifiableFieldData = {
 };
 /** @hidden */
 
+/** @hidden */
 var MockBaseDataStore =
 /*#__PURE__*/
 function () {
@@ -286,46 +287,51 @@ function () {
               // mock implementation of isRecordPartiallyLoaded still returns `true`
               // for this given recordId
 
-              this._deletedRecordIds.push(recordId);
+              this._deletedRecordIds.push(recordId); // But we do remove the records from the views
+
 
+              table.views.forEach(view => {
+                var viewRecords = view.records.filter(r => r.id !== recordId);
+                view.records = viewRecords;
+              });
               _i = 0, _Object$values = Object.values(this._subscribedQuerySpecs);
 
-            case 6:
+            case 7:
               if (!(_i < _Object$values.length)) {
-                _context4.next = 16;
+                _context4.next = 17;
                 break;
               }
 
               _Object$values$_i = _Object$values[_i], querySpec = _Object$values$_i.querySpec, onChangeCallback = _Object$values$_i.onChangeCallback;
 
               if (onChangeCallback) {
-                _context4.next = 10;
+                _context4.next = 11;
                 break;
               }
 
-              return _context4.abrupt("continue", 13);
+              return _context4.abrupt("continue", 14);
 
-            case 10:
+            case 11:
               if (!(querySpec.sourceTableId !== tableId)) {
-                _context4.next = 12;
+                _context4.next = 13;
                 break;
               }
 
-              return _context4.abrupt("continue", 13);
+              return _context4.abrupt("continue", 14);
 
-            case 12:
+            case 13:
               onChangeCallback([{
                 type: _block_query_spec.BlockQuerySubscriptionChangeType.REMOVED_RECORD_IDS,
                 tableId,
                 recordIds: [recordId]
               }]);
 
-            case 13:
+            case 14:
               _i++;
-              _context4.next = 6;
+              _context4.next = 7;
               break;
 
-            case 16:
+            case 17:
             case "end":
               return _context4.stop();
           }
@@ -343,45 +349,51 @@ function () {
             case 0:
               table = this._tablesById[tableId];
               (0, _error_utils.invariant)(table, 'updateRecord called with missing table %s', tableId);
-              table.records.push(initialFixtureRecord);
+              table.records.push(initialFixtureRecord); // By default add records to all views within the table
+
+              table.views.forEach(view => {
+                view.records.push(_objectSpread({}, initialFixtureRecord, {
+                  color: null
+                }));
+              });
               _i2 = 0, _Object$values2 = Object.values(this._subscribedQuerySpecs);
 
-            case 4:
+            case 5:
               if (!(_i2 < _Object$values2.length)) {
-                _context5.next = 14;
+                _context5.next = 15;
                 break;
               }
 
               _Object$values2$_i = _Object$values2[_i2], querySpec = _Object$values2$_i.querySpec, onChangeCallback = _Object$values2$_i.onChangeCallback;
 
               if (onChangeCallback) {
-                _context5.next = 8;
+                _context5.next = 9;
                 break;
               }
 
-              return _context5.abrupt("continue", 11);
+              return _context5.abrupt("continue", 12);
 
-            case 8:
+            case 9:
               if (!(querySpec.sourceTableId !== tableId)) {
-                _context5.next = 10;
+                _context5.next = 11;
                 break;
               }
 
-              return _context5.abrupt("continue", 11);
+              return _context5.abrupt("continue", 12);
 
-            case 10:
+            case 11:
               onChangeCallback([{
                 type: _block_query_spec.BlockQuerySubscriptionChangeType.ADDED_RECORD_IDS,
                 tableId,
                 recordIds: [initialFixtureRecord.id]
               }]);
 
-            case 11:
+            case 12:
               _i2++;
-              _context5.next = 4;
+              _context5.next = 5;
               break;
 
-            case 14:
+            case 15:
             case "end":
               return _context5.stop();
           }
@@ -542,7 +554,10 @@ function () {
         isRecordCellValueLoadedForFieldId: (recordId, fieldId) => this._isRecordCellValueLoadedForFieldId(fixtureTable, recordId, fieldId),
         getRecordCellValueByFieldId: (recordId, fieldId) => this._getRecordCellValueByFieldId(fixtureTable, recordId, fieldId),
         getRecordCommentCount: recordId => this._getRecordCommentCount(fixtureTable, recordId),
-        getRecordCreatedTime: recordId => this._getRecordCreatedTime(fixtureTable, recordId)
+        getRecordCreatedTime: recordId => this._getRecordCreatedTime(fixtureTable, recordId),
+        // This doesn't concern loadedness; but allows test fixtures to do things like
+        // "pretend this record is highlighted", even if it isn't loaded by the block
+        hasRecordForTestsOnly: recordId => fixtureTable.records.some(record => record.id === recordId)
       };
     }
   }, {

package/dist/cjs/types/mutations.js

@@ -18,6 +18,7 @@ var MutationTypes = Object.freeze({
   CREATE_SINGLE_FIELD: 'createSingleField',
   UPDATE_SINGLE_FIELD_CONFIG: 'updateSingleFieldConfig',
   UPDATE_SINGLE_FIELD_DESCRIPTION: 'updateSingleFieldDescription',
+  UPDATE_SINGLE_FIELD_NAME: 'updateSingleFieldName',
   CREATE_SINGLE_TABLE: 'createSingleTable',
   UPDATE_VIEW_METADATA: 'updateViewMetadata'
 });