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

package/CHANGELOG.md

@@ -9,10 +9,14 @@ 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.10.1...HEAD)
+## [Unreleased](https://github.com/airtable/blocks/compare/@airtable/blocks@1.10.2...HEAD)
 
 No changes.
 
+## [1.10.2](https://github.com/airtable/blocks/compare/@airtable/blocks@1.10.1...@airtable/blocks@1.10.2) - 2022-01-25
+
+-   Rare invariant failure addressed
+
 ## [1.10.1](https://github.com/airtable/blocks/compare/@airtable/blocks@1.10.0...@airtable/blocks@1.10.1) - 2021-12-22
 
 -   Update examples for table, view and field URLs.

package/dist/cjs/error_utils.js

@@ -1,13 +1,19 @@
 "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.invariant = invariant;
 exports.spawnUnknownSwitchCaseError = spawnUnknownSwitchCaseError;
+exports.spawnExhaustiveSwitchError = spawnExhaustiveSwitchError;
 exports.spawnAbstractMethodError = spawnAbstractMethodError;
 
 // If errorOriginFn is specified, all frames above and including the call to errorOriginFn
@@ -52,6 +58,26 @@ function spawnError(errorMessageFormat) {
   }
 
   return spawnErrorWithOriginOmittedFromStackTrace(errorMessageFormat, errorMessageArgs, spawnError);
+} // istanbul ignore next
+
+/**
+ * Logs an error to Rollbar
+ *
+ * @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];
+    }
+
+    rollbar.warn(spawnError(errorMessageFormat, ...errorMessageArgs));
+  }
 }
 /**
  * An alternative to facebook's invariant that's safe to use with base data
@@ -62,8 +88,8 @@ function spawnError(errorMessageFormat) {
 
 function invariant(condition, errorMessageFormat) {
   if (!condition) {
-    for (var _len2 = arguments.length, errorMessageArgs = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
-      errorMessageArgs[_key2 - 2] = arguments[_key2];
+    for (var _len3 = arguments.length, errorMessageArgs = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+      errorMessageArgs[_key3 - 2] = arguments[_key3];
     }
 
     throw spawnErrorWithOriginOmittedFromStackTrace(errorMessageFormat, errorMessageArgs, invariant);
@@ -79,6 +105,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/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,14 @@ var _field = require("../types/field");
 
 var _error_utils = require("../error_utils");
 
+var _block_query_spec = require("../types/block_query_spec");
+
+var _airtable_interface = require("../types/airtable_interface");
+
 var _record_query_result = _interopRequireDefault(require("./record_query_result"));
 
+var _record_store = require("./record_store");
+
 /** @module @airtable/blocks/models: RecordQueryResult */
 
 /** */
@@ -118,6 +126,8 @@ function (_RecordQueryResult) {
 
   /** @internal */
 
+  /** @internal */
+
   /** @internal */
   function LinkedRecordsQueryResult(record, field, normalizedOpts, sdk) {
     var _this;
@@ -134,6 +144,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 +290,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 +302,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 +332,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 +397,9 @@ function (_RecordQueryResult) {
 
         this._unwatchLinkedQueryResult();
 
-        this._originRecordStore.unloadCellValuesInFieldIds([this._field.id]);
+        (0, _error_utils.invariant)(this._recordStoreQueryId, 'Unsubscribing from linked record record store without queryId');
+
+        this._originRecordStore.unloadCellValuesForQueryIdsThatAreSubscribedToAllCells([this._recordStoreQueryId]);
 
         this._linkedQueryResult.unloadData();
 
@@ -448,7 +471,13 @@ 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({
+        priority: _airtable_interface.BlockQueryCallbackPriority.SDK,
+        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 +621,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 +806,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/mutations.js

@@ -6,18 +6,12 @@ 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.flat-map");
-
 require("core-js/modules/es.array.includes");
 
 require("core-js/modules/es.array.iterator");
 
 require("core-js/modules/es.array.map");
 
-require("core-js/modules/es.array.unscopables.flat-map");
-
 require("core-js/modules/es.object.to-string");
 
 require("core-js/modules/es.promise");
@@ -28,15 +22,11 @@ require("core-js/modules/es.string.includes");
 
 require("core-js/modules/web.dom-collections.iterator");
 
-require("core-js/modules/web.url.to-json");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 require("regenerator-runtime/runtime");
@@ -51,8 +41,6 @@ var _airtable_interface = require("../types/airtable_interface");
 
 var _mutations = require("../types/mutations");
 
-var _private_utils = require("../private_utils");
-
 var _error_utils = require("../error_utils");
 
 var _mutation_constants = require("./mutation_constants");
@@ -81,22 +69,18 @@ function () {
 
   /** @internal */
 
-  /** @internal */
-
   /** @hidden */
-  function Mutations(sdk, session, base, applyModelChanges, applyGlobalConfigUpdates) {
+  function Mutations(sdk, session, base, applyGlobalConfigUpdates) {
     (0, _classCallCheck2.default)(this, Mutations);
     (0, _defineProperty2.default)(this, "_airtableInterface", void 0);
     (0, _defineProperty2.default)(this, "_session", void 0);
     (0, _defineProperty2.default)(this, "_sdk", void 0);
     (0, _defineProperty2.default)(this, "_base", void 0);
-    (0, _defineProperty2.default)(this, "_applyModelChanges", void 0);
     (0, _defineProperty2.default)(this, "_applyGlobalConfigUpdates", void 0);
     this._airtableInterface = sdk.__airtableInterface;
     this._session = session;
     this._sdk = sdk;
     this._base = base;
-    this._applyModelChanges = applyModelChanges;
     this._applyGlobalConfigUpdates = applyGlobalConfigUpdates;
   }
   /** @hidden */
@@ -270,9 +254,12 @@ function () {
             try {
               for (var _iterator = records[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                 var record = _step.value;
-                var existingRecord = null;
+                var existingRecord = null; // Note - if isSubscribedToAllRecordsInTable is true then we know the record
+                // doesn't exist (or is deleted) but otherwise we can issue a mutation to a record
+                // that does not exist, having to deal with the error thrown by PublicAirtableInterfaceFrontend
+                // TODO: (#proj-blocks-sdk-record-limits) Write tests around this behavior
 
-                if (recordStore.isRecordMetadataLoaded) {
+                if (recordStore.isSubscribedToAllRecordsInTable || recordStore.isRecordLoaded(record.id)) {
                   existingRecord = recordStore.getRecordByIdIfExists(record.id);
 
                   if (!existingRecord) {
@@ -294,7 +281,7 @@ function () {
                     checkedFieldIds.add(fieldId);
                   }
 
-                  if (existingRecord && recordStore.areCellValuesLoadedForFieldId(fieldId)) {
+                  if (existingRecord && recordStore.isRecordCellValueLoadedForFieldId(record.id, fieldId)) {
                     var validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, record.cellValuesByFieldId[fieldId], existingRecord._getRawCellValue(field), field._data);
 
                     if (!validationResult.isValid) {
@@ -332,9 +319,15 @@ function () {
               throw (0, _error_utils.spawnError)("Can't delete records: No table with id %s exists", _tableId);
             }
 
-            var _recordStore = this._base.__getRecordStore(_tableId);
+            var _recordStore = this._base.__getRecordStore(_tableId); // TODO: (#proj-blocks-sdk-record-limits) We substantially weaken our check here
+            // because we can only be sure if the record exists inside the SDK if we've loaded
+            // all records. It is possible to change this logic to ensure we don't double-delete
+            // records by caching previously deleted records (if the delete is undone, but
+            // we're not watching the record be re-created from the undo we would have to fail
+            // the delete if we detect double deletion). TODO to add tests around this behavior.
+
 
-            if (_recordStore.isRecordMetadataLoaded) {
+            if (_recordStore.isSubscribedToAllRecordsInTable) {
               var _iteratorNormalCompletion2 = true;
               var _didIteratorError2 = false;
               var _iteratorError2 = undefined;
@@ -672,150 +665,13 @@ function () {
         this._applyGlobalConfigUpdates(mutation.updates);
 
         return true;
-      }
-
-      var modelChanges = this._getOptimisticModelChangesForMutation(mutation);
+      } // https://airtable.com/appahuJQw7qfQTBBU/tblSbpimM8Spp9txp/viweAFIus3MhU9Gxa/recHOckY4V9QmM6JV?blocks=hide
+      // TODO: (#proj-blocks-sdk-record-limits) Fix this in a future stacked diff where optimistic
+      // updates are re-enabled https://docs.google.com/document/d/1CVZ4ZoPWEtpzKq_9cRLASGwgY71WI4nl6RVvs8S7Ubw/edit#
 
-      if (modelChanges.length > 0) {
-        this._applyModelChanges(modelChanges);
-
-        return true;
-      }
 
       return false;
     }
-    /** @internal */
-
-  }, {
-    key: "_getOptimisticModelChangesForMutation",
-    value: function _getOptimisticModelChangesForMutation(mutation) {
-      switch (mutation.type) {
-        case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
-          {
-            var tableId = mutation.tableId,
-                records = mutation.records;
-
-            var recordStore = this._base.__getRecordStore(tableId);
-
-            return records.flatMap(record => Object.keys(record.cellValuesByFieldId).filter(fieldId => recordStore.areCellValuesLoadedForFieldId(fieldId)).map(fieldId => ({
-              path: ['tablesById', tableId, 'recordsById', record.id, 'cellValuesByFieldId', fieldId],
-              value: record.cellValuesByFieldId[fieldId]
-            })));
-          }
-
-        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
-          {
-            var _tableId7 = mutation.tableId,
-                recordIds = mutation.recordIds;
-
-            var _recordStore2 = this._base.__getRecordStore(_tableId7);
-
-            if (!_recordStore2.isRecordMetadataLoaded) {
-              return [];
-            }
-
-            return [...recordIds.map(recordId => ({
-              path: ['tablesById', _tableId7, 'recordsById', recordId],
-              value: undefined
-            })), ...this._base.getTableById(_tableId7).views.flatMap(view => {
-              var viewDataStore = _recordStore2.getViewDataStore(view.id);
-
-              if (!viewDataStore.isDataLoaded) {
-                return [];
-              }
-
-              return viewDataStore.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
-            })];
-          }
-
-        case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
-          {
-            var _tableId8 = mutation.tableId,
-                _records2 = mutation.records;
-
-            var _recordStore3 = this._base.__getRecordStore(_tableId8);
-
-            if (!_recordStore3.isRecordMetadataLoaded) {
-              return [];
-            }
-
-            return [..._records2.map(record => {
-              // Only apply optimistic changes for fields that are loaded
-              var filteredCellValuesByFieldId = {};
-              var _iteratorNormalCompletion5 = true;
-              var _didIteratorError5 = false;
-              var _iteratorError5 = undefined;
-
-              try {
-                for (var _iterator5 = (0, _private_utils.entries)(record.cellValuesByFieldId)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-                  var _step5$value = (0, _slicedToArray2.default)(_step5.value, 2),
-                      fieldId = _step5$value[0],
-                      cellValue = _step5$value[1];
-
-                  if (_recordStore3.areCellValuesLoadedForFieldId(fieldId)) {
-                    filteredCellValuesByFieldId[fieldId] = cellValue;
-                  }
-                }
-              } catch (err) {
-                _didIteratorError5 = true;
-                _iteratorError5 = err;
-              } finally {
-                try {
-                  if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-                    _iterator5.return();
-                  }
-                } finally {
-                  if (_didIteratorError5) {
-                    throw _iteratorError5;
-                  }
-                }
-              }
-
-              return {
-                path: ['tablesById', _tableId8, 'recordsById', record.id],
-                value: {
-                  id: record.id,
-                  cellValuesByFieldId: filteredCellValuesByFieldId,
-                  commentCount: 0,
-                  createdTime: new Date().toJSON()
-                }
-              };
-            }), ...this._base.getTableById(_tableId8).views.flatMap(view => {
-              var viewDataStore = _recordStore3.getViewDataStore(view.id);
-
-              if (!viewDataStore.isDataLoaded) {
-                return [];
-              }
-
-              return viewDataStore.__generateChangesForParentTableAddMultipleRecords(_records2.map(record => record.id));
-            })];
-          }
-        // The following branch is unreachable because this method's only
-        // call site is preceded by an explicit guard for this condition.
-        // istanbul ignore next
-
-        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
-          {
-            throw (0, _error_utils.spawnError)('attempting to generate model updates for SET_MULTIPLE_GLOBAL_CONFIG_PATH');
-          }
-
-        case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
-        case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
-        case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
-          {
-            // No optimistic updates for field, view metadata, or table mutations.
-            return [];
-          }
-        // The following branch is unreachable because this method's only
-        // call site is preceded by an explicit guard for this condition.
-        // istanbul ignore next
-
-        default:
-          throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation, 'type');
-      }
-    }
   }]);
   return Mutations;
 }();