@airtable/blocks 0.0.0-experimental-d5ee5e823-20250501 → 0.0.0-experimental-15dc8a3ea-20250616

package/dist/cjs/base/models/linked_records_query_result.js

@@ -28,7 +28,7 @@ var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _field = require("../../shared/types/field");
+var _field_core = require("../../shared/types/field_core");
 var _error_utils = require("../../shared/error_utils");
 var _record_query_result = _interopRequireDefault(require("./record_query_result"));
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
@@ -622,7 +622,7 @@ var LinkedRecordsQueryResult = /*#__PURE__*/function (_RecordQueryResult) {
     value: function _onOriginFieldConfigChange() {
       (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
       var type = this._field.type;
-      if (type !== _field.FieldType.MULTIPLE_RECORD_LINKS) {
+      if (type !== _field_core.FieldType.MULTIPLE_RECORD_LINKS) {
         this._invalidateQueryResult();
         return;
       }

package/dist/cjs/base/models/models.js

@@ -23,19 +23,19 @@ Object.defineProperty(exports, "Cursor", {
 Object.defineProperty(exports, "Field", {
   enumerable: true,
   get: function get() {
-    return _field2.default;
+    return _field.default;
   }
 });
 Object.defineProperty(exports, "FieldConfig", {
   enumerable: true,
   get: function get() {
-    return _field.FieldConfig;
+    return _field_core.FieldConfig;
   }
 });
 Object.defineProperty(exports, "FieldType", {
   enumerable: true,
   get: function get() {
-    return _field.FieldType;
+    return _field_core.FieldType;
   }
 });
 Object.defineProperty(exports, "GroupedRecordQueryResult", {
@@ -102,11 +102,11 @@ exports.recordColoring = void 0;
 var recordColoring = _interopRequireWildcard(require("./record_coloring"));
 exports.recordColoring = recordColoring;
 var _create_aggregators = _interopRequireDefault(require("./create_aggregators"));
-var _field = require("../../shared/types/field");
+var _field_core = require("../../shared/types/field_core");
 var _view = require("../types/view");
 var _base = _interopRequireDefault(require("./base"));
 var _table = _interopRequireDefault(require("./table"));
-var _field2 = _interopRequireDefault(require("./field"));
+var _field = _interopRequireDefault(require("./field"));
 var _view2 = _interopRequireDefault(require("./view"));
 var _record = _interopRequireDefault(require("./record"));
 var _record_query_result = _interopRequireDefault(require("./record_query_result"));

package/dist/cjs/base/models/mutations.js

@@ -11,7 +11,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 require("core-js/modules/es.symbol.js");
 require("core-js/modules/es.symbol.description.js");
-require("core-js/modules/es.array.filter.js");
 require("core-js/modules/es.array.flat-map.js");
 require("core-js/modules/es.array.includes.js");
 require("core-js/modules/es.array.iterator.js");
@@ -21,15 +20,14 @@ require("core-js/modules/es.object.to-string.js");
 require("core-js/modules/es.set.js");
 require("core-js/modules/es.string.includes.js");
 require("core-js/modules/web.dom-collections.iterator.js");
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 var _airtable_interface = require("../types/airtable_interface");
 var _mutations = require("../types/mutations");
-var _private_utils = require("../../shared/private_utils");
 var _error_utils = require("../../shared/error_utils");
 var _mutation_constants = require("../../shared/types/mutation_constants");
 var _mutations_core = require("../../shared/models/mutations_core");
@@ -46,23 +44,17 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
   }
   (0, _inherits2.default)(Mutations, _MutationsCore);
   return (0, _createClass2.default)(Mutations, [{
-    key: "_doesMutationExceedBatchSizeLimit",
+    key: "_isRecordStoreReadyForMutations",
     value: /** @internal */
-    function _doesMutationExceedBatchSizeLimit(mutation) {
-      switch (mutation.type) {
-        case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
-        case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
-          return mutation.records.length > _mutations_core.MUTATIONS_MAX_BATCH_SIZE;
-        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
-          return mutation.recordIds.length > _mutations_core.MUTATIONS_MAX_BATCH_SIZE;
-        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
-          return mutation.updates.length > _mutations_core.MUTATIONS_MAX_BATCH_SIZE;
-        // The "default" case cannot be reached because this method is only
-        // invoked after the mutation type has been validated.
-        // istanbul ignore next
-        default:
-          return false;
-      }
+    function _isRecordStoreReadyForMutations(recordStore) {
+      return recordStore.isRecordMetadataLoaded;
+    }
+
+    /** @internal */
+  }, {
+    key: "_isFieldAvailableForMutation",
+    value: function _isFieldAvailableForMutation(recordStore, fieldId) {
+      return recordStore.areCellValuesLoadedForFieldId(fieldId);
     }
 
     /** @internal */
@@ -81,150 +73,33 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
       var appInterface = this._sdk.__appInterface;
       var billingPlanGrouping = this._base.__billingPlanGrouping;
       switch (mutation.type) {
+        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
         case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
-          {
-            var tableId = mutation.tableId,
-              records = mutation.records;
-            var table = this._base.getTableByIdIfExists(tableId);
-            if (!table) {
-              throw (0, _error_utils.spawnError)("Can't set cell values: No table with id %s exists", tableId);
-            }
-
-            // For every mutation, we check that we're not trying to set fields that we don't support
-            // mutations for yet. When record data is loaded, we also check that the record we're
-            // updating actually exists and that the cell values are valid.
-            var recordStore = this._base.__getRecordStore(tableId);
-            var checkedFieldIds = new Set();
-            var _iterator = _createForOfIteratorHelper(records),
-              _step;
-            try {
-              for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                var record = _step.value;
-                var existingRecord = null;
-                if (recordStore.isRecordMetadataLoaded) {
-                  existingRecord = recordStore.getRecordByIdIfExists(record.id);
-                  if (!existingRecord) {
-                    throw (0, _error_utils.spawnError)("Can't set cell values: No record with id %s exists", record.id);
-                  }
-                }
-                for (var _i = 0, _Object$keys = Object.keys(record.cellValuesByFieldId); _i < _Object$keys.length; _i++) {
-                  var fieldId = _Object$keys[_i];
-                  var field = table.getFieldByIdIfExists(fieldId);
-                  if (!field) {
-                    throw (0, _error_utils.spawnError)("Can't set cell values: No field with id %s exists in table '%s'", fieldId, table.name);
-                  }
-                  if (!checkedFieldIds.has(fieldId)) {
-                    this._assertFieldIsValidForMutation(field);
-                    checkedFieldIds.add(fieldId);
-                  }
-                  if (existingRecord && recordStore.areCellValuesLoadedForFieldId(fieldId)) {
-                    var validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, record.cellValuesByFieldId[fieldId], existingRecord._getRawCellValue(field), field._data);
-                    if (!validationResult.isValid) {
-                      throw (0, _error_utils.spawnError)("Can't set cell values: invalid cell value for field '%s'.\n%s", field.name, validationResult.reason);
-                    }
-                  }
-                }
-              }
-            } catch (err) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
-            }
-            return;
-          }
-        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
-          {
-            var _tableId = mutation.tableId,
-              recordIds = mutation.recordIds;
-            var _table = this._base.getTableByIdIfExists(_tableId);
-            if (!_table) {
-              throw (0, _error_utils.spawnError)("Can't delete records: No table with id %s exists", _tableId);
-            }
-            var _recordStore = this._base.__getRecordStore(_tableId);
-            if (_recordStore.isRecordMetadataLoaded) {
-              var _iterator2 = _createForOfIteratorHelper(recordIds),
-                _step2;
-              try {
-                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                  var recordId = _step2.value;
-                  var _record = _recordStore.getRecordByIdIfExists(recordId);
-                  if (!_record) {
-                    throw (0, _error_utils.spawnError)("Can't delete records: No record with id %s exists in table '%s'", recordId, _table.name);
-                  }
-                }
-              } catch (err) {
-                _iterator2.e(err);
-              } finally {
-                _iterator2.f();
-              }
-            }
-            return;
-          }
         case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
           {
-            var _tableId2 = mutation.tableId,
-              _records = mutation.records;
-            var _checkedFieldIds = new Set();
-            var _table2 = this._base.getTableByIdIfExists(_tableId2);
-            if (!_table2) {
-              throw (0, _error_utils.spawnError)("Can't create records: No table with id %s exists", _tableId2);
-            }
-            var _iterator3 = _createForOfIteratorHelper(_records),
-              _step3;
-            try {
-              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                var _record2 = _step3.value;
-                for (var _i2 = 0, _Object$keys2 = Object.keys(_record2.cellValuesByFieldId); _i2 < _Object$keys2.length; _i2++) {
-                  var _fieldId = _Object$keys2[_i2];
-                  var _field = _table2.getFieldByIdIfExists(_fieldId);
-                  if (!_field) {
-                    throw (0, _error_utils.spawnError)("Can't create records: No field with id %s exists in table '%s'", _fieldId, _table2.name);
-                  }
-                  if (!_checkedFieldIds.has(_fieldId)) {
-                    this._assertFieldIsValidForMutation(_field);
-                    _checkedFieldIds.add(_fieldId);
-                  }
-
-                  // Current cell value is null since the record doesn't exist.
-                  var _validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, _record2.cellValuesByFieldId[_fieldId], null, _field._data);
-                  if (!_validationResult.isValid) {
-                    throw (0, _error_utils.spawnError)("Can't create records: invalid cell value for field '%s'.\n%s", _field.name, _validationResult.reason);
-                  }
-                }
-              }
-            } catch (err) {
-              _iterator3.e(err);
-            } finally {
-              _iterator3.f();
-            }
-            return;
-          }
-        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
-          {
-            // globalConfig update is a special case: globalConfig handles validation before
-            // invoking this mutation, since it relies on internal state to validate the
-            // paths being set.
+            (0, _get2.default)((0, _getPrototypeOf2.default)(Mutations.prototype), "_assertMutationIsValid", this).call(this, mutation);
             return;
           }
         case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
           {
-            var _tableId3 = mutation.tableId,
+            var tableId = mutation.tableId,
               name = mutation.name,
               config = mutation.config,
               description = mutation.description;
-            var _table3 = this._base.getTableByIdIfExists(_tableId3);
-            if (!_table3) {
-              throw (0, _error_utils.spawnError)("Can't create field: No table with id %s exists", _tableId3);
+            var table = this._base.getTableByIdIfExists(tableId);
+            if (!table) {
+              throw (0, _error_utils.spawnError)("Can't create field: No table with id %s exists", tableId);
             }
-            if (_table3.fields.length >= _mutation_constants.MAX_NUM_FIELDS_PER_TABLE) {
+            if (table.fields.length >= _mutation_constants.MAX_NUM_FIELDS_PER_TABLE) {
               throw (0, _error_utils.spawnError)("Can't create field: table already has the maximum of %s fields", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
             }
-            this._assertFieldNameIsValidForMutation(name, _table3);
+            this._assertFieldNameIsValidForMutation(name, table);
 
             // Current config / field data is null since the field doesn't exist.
-            var _validationResult2 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, config, null, null, billingPlanGrouping);
-            if (!_validationResult2.isValid) {
-              throw (0, _error_utils.spawnError)("Can't create field: invalid field config.\n%s", _validationResult2.reason);
+            var validationResult = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, config, null, null, billingPlanGrouping);
+            if (!validationResult.isValid) {
+              throw (0, _error_utils.spawnError)("Can't create field: invalid field config.\n%s", validationResult.reason);
             }
             if (description && description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
               throw (0, _error_utils.spawnError)("Can't create field: description exceeds maximum length of %s characters", _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
@@ -233,40 +108,40 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
           }
         case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
           {
-            var _tableId4 = mutation.tableId,
+            var _tableId = mutation.tableId,
               id = mutation.id,
               _config = mutation.config,
               opts = mutation.opts;
-            var _table4 = this._base.getTableByIdIfExists(_tableId4);
-            if (!_table4) {
-              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId4);
+            var _table = this._base.getTableByIdIfExists(_tableId);
+            if (!_table) {
+              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId);
             }
-            var _field2 = _table4.getFieldByIdIfExists(id);
-            if (!_field2) {
+            var field = _table.getFieldByIdIfExists(id);
+            if (!field) {
               throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", id);
             }
 
             // we get the config directly instead of using field.type/field.options to get it
             // in one call and because field.options returns null instead of undefined when
             // a field does not have options, whilst we need to pass undefined
-            var currentConfig = this._airtableInterface.fieldTypeProvider.getConfig(appInterface, _field2._data, _field2.parentTable.__getFieldNamesById());
-            var _validationResult3 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _config, currentConfig, _field2._data, billingPlanGrouping, opts);
-            if (!_validationResult3.isValid) {
-              throw (0, _error_utils.spawnError)("Can't update field: invalid field config.\n%s", _validationResult3.reason);
+            var currentConfig = this._airtableInterface.fieldTypeProvider.getConfig(appInterface, field._data, field.parentTable.__getFieldNamesById());
+            var _validationResult = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _config, currentConfig, field._data, billingPlanGrouping, opts);
+            if (!_validationResult.isValid) {
+              throw (0, _error_utils.spawnError)("Can't update field: invalid field config.\n%s", _validationResult.reason);
             }
             return;
           }
         case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
           {
-            var _tableId5 = mutation.tableId,
+            var _tableId2 = mutation.tableId,
               _id = mutation.id,
               _description = mutation.description;
-            var _table5 = this._base.getTableByIdIfExists(_tableId5);
-            if (!_table5) {
-              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId5);
+            var _table2 = this._base.getTableByIdIfExists(_tableId2);
+            if (!_table2) {
+              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId2);
             }
-            var _field3 = _table5.getFieldByIdIfExists(_id);
-            if (!_field3) {
+            var _field = _table2.getFieldByIdIfExists(_id);
+            if (!_field) {
               throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", _id);
             }
             if (_description && _description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
@@ -276,23 +151,23 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
           }
         case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
           {
-            var _tableId6 = mutation.tableId,
+            var _tableId3 = 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 _table3 = this._base.getTableByIdIfExists(_tableId3);
+            if (!_table3) {
+              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId3);
             }
-            var _field4 = _table6.getFieldByIdIfExists(_id2);
-            if (!_field4) {
+            var _field2 = _table3.getFieldByIdIfExists(_id2);
+            if (!_field2) {
               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);
+            if (_field2.name.toLowerCase() !== _name.toLowerCase()) {
+              this._assertFieldNameIsValidForMutation(_name, _table3);
             }
             return;
           }
@@ -317,36 +192,36 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
               throw (0, _error_utils.spawnError)("Can't create table: number of fields exceeds maximum of %s", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
             }
             var lowercaseFieldNames = new Set();
-            var _iterator4 = _createForOfIteratorHelper(fields),
-              _step4;
+            var _iterator = _createForOfIteratorHelper(fields),
+              _step;
             try {
-              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-                var _field5 = _step4.value;
-                if (!_field5.name) {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var _field3 = _step.value;
+                if (!_field3.name) {
                   throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name for every field");
                 }
-                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);
+                if (_field3.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", _field3.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
                 }
-                var lowercaseFieldName = _field5.name.toLowerCase();
+                var lowercaseFieldName = _field3.name.toLowerCase();
                 if (lowercaseFieldNames.has(lowercaseFieldName)) {
-                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field5.name);
+                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field3.name);
                 }
                 lowercaseFieldNames.add(lowercaseFieldName);
 
                 // Current config / field data is null since the field doesn't exist.
-                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", _field5.name, _validationResult4.reason);
+                var _validationResult2 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _field3.config, null, null, billingPlanGrouping);
+                if (!_validationResult2.isValid) {
+                  throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", _field3.name, _validationResult2.reason);
                 }
-                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);
+                if (_field3.description && _field3.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", _field3.name, _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
                 }
               }
             } catch (err) {
-              _iterator4.e(err);
+              _iterator.e(err);
             } finally {
-              _iterator4.f();
+              _iterator.f();
             }
             var primaryField = fields[0];
             if (!this._airtableInterface.fieldTypeProvider.canBePrimary(appInterface, primaryField.config, billingPlanGrouping)) {
@@ -356,20 +231,20 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
           }
         case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
           {
-            var _tableId7 = mutation.tableId,
+            var _tableId4 = mutation.tableId,
               viewId = mutation.viewId;
             var runContext = this._airtableInterface.sdkInitData.runContext;
             if (runContext.type !== _airtable_interface.BlockRunContextType.VIEW) {
               throw (0, _error_utils.spawnError)('Setting view metadata is only valid for views');
             }
-            if (runContext.viewId !== viewId || runContext.tableId !== _tableId7) {
+            if (runContext.viewId !== viewId || runContext.tableId !== _tableId4) {
               throw (0, _error_utils.spawnError)('Custom views can only set view metadata on themselves');
             }
-            var _table7 = this._base.getTableByIdIfExists(_tableId7);
-            if (!_table7) {
-              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId7);
+            var _table4 = this._base.getTableByIdIfExists(_tableId4);
+            if (!_table4) {
+              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId4);
             }
-            var view = _table7.getViewByIdIfExists(viewId);
+            var view = _table4.getViewByIdIfExists(viewId);
             if (!view) {
               throw (0, _error_utils.spawnError)("Can't update metadata: No view with id %s exists", viewId);
             }
@@ -380,15 +255,6 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
       }
     }
 
-    /** @internal */
-  }, {
-    key: "_assertFieldIsValidForMutation",
-    value: function _assertFieldIsValidForMutation(field) {
-      if (field.isComputed) {
-        throw (0, _error_utils.spawnError)("Can't set cell values: Field '%s' is computed and cannot be set", field.name);
-      }
-    }
-
     /** @internal */
   }, {
     key: "_assertFieldNameIsValidForMutation",
@@ -412,87 +278,43 @@ var Mutations = /*#__PURE__*/function (_MutationsCore) {
     key: "_getOptimisticModelChangesForMutation",
     value: function _getOptimisticModelChangesForMutation(mutation) {
       switch (mutation.type) {
+        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
         case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
+          return (0, _get2.default)((0, _getPrototypeOf2.default)(Mutations.prototype), "_getOptimisticModelChangesForMutation", this).call(this, mutation);
+        case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
           {
             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 _tableId8 = mutation.tableId,
-              recordIds = mutation.recordIds;
-            var _recordStore2 = this._base.__getRecordStore(_tableId8);
-            if (!_recordStore2.isRecordMetadataLoaded) {
+            if (!recordStore.isRecordMetadataLoaded) {
               return [];
             }
-            return [...recordIds.map(recordId => ({
-              path: ['tablesById', _tableId8, 'recordsById', recordId],
-              value: undefined
-            })), ...this._base.getTableById(_tableId8).views.flatMap(view => {
-              var viewDataStore = _recordStore2.getViewDataStore(view.id);
+            var superChanges = (0, _get2.default)((0, _getPrototypeOf2.default)(Mutations.prototype), "_getOptimisticModelChangesForMutation", this).call(this, mutation);
+            return [...superChanges, ...this._base.getTableById(tableId).views.flatMap(view => {
+              var viewDataStore = recordStore.getViewDataStore(view.id);
               if (!viewDataStore.isDataLoaded) {
                 return [];
               }
-              return viewDataStore.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
+              return viewDataStore.__generateChangesForParentTableAddMultipleRecords(records.map(record => record.id));
             })];
           }
-        case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
           {
-            var _tableId9 = mutation.tableId,
-              _records2 = mutation.records;
-            var _recordStore3 = this._base.__getRecordStore(_tableId9);
-            if (!_recordStore3.isRecordMetadataLoaded) {
+            var _tableId5 = mutation.tableId,
+              recordIds = mutation.recordIds;
+            var _recordStore = this._base.__getRecordStore(_tableId5);
+            if (!_recordStore.isRecordMetadataLoaded) {
               return [];
             }
-            return [..._records2.map(record => {
-              // Only apply optimistic changes for fields that are loaded
-              var filteredCellValuesByFieldId = {};
-              var _iterator5 = _createForOfIteratorHelper((0, _private_utils.entries)(record.cellValuesByFieldId)),
-                _step5;
-              try {
-                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-                  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) {
-                _iterator5.e(err);
-              } finally {
-                _iterator5.f();
-              }
-              return {
-                path: ['tablesById', _tableId9, 'recordsById', record.id],
-                value: {
-                  id: record.id,
-                  cellValuesByFieldId: filteredCellValuesByFieldId,
-                  commentCount: 0,
-                  createdTime: new Date().toJSON()
-                }
-              };
-            }), ...this._base.getTableById(_tableId9).views.flatMap(view => {
-              var viewDataStore = _recordStore3.getViewDataStore(view.id);
+            var _superChanges = (0, _get2.default)((0, _getPrototypeOf2.default)(Mutations.prototype), "_getOptimisticModelChangesForMutation", this).call(this, mutation);
+            return [..._superChanges, ...this._base.getTableById(_tableId5).views.flatMap(view => {
+              var viewDataStore = _recordStore.getViewDataStore(view.id);
               if (!viewDataStore.isDataLoaded) {
                 return [];
               }
-              return viewDataStore.__generateChangesForParentTableAddMultipleRecords(_records2.map(record => record.id));
+              return viewDataStore.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
             })];
           }
-
-        // 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:

package/dist/cjs/base/models/record_query_result.js

@@ -28,11 +28,11 @@ require("core-js/modules/es.array.concat.js");
 require("core-js/modules/es.array.map.js");
 require("core-js/modules/es.string.starts-with.js");
 var _colors = _interopRequireDefault(require("../../shared/colors"));
-var _field = require("../../shared/types/field");
+var _field_core = require("../../shared/types/field_core");
 var _private_utils = require("../../shared/private_utils");
 var _error_utils = require("../../shared/error_utils");
 var _abstract_model_with_async_data = _interopRequireDefault(require("./abstract_model_with_async_data"));
-var _field2 = _interopRequireDefault(require("./field"));
+var _field = _interopRequireDefault(require("./field"));
 var _record_coloring = require("./record_coloring");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
@@ -406,7 +406,7 @@ var RecordQueryResult = /*#__PURE__*/function (_AbstractModelWithAsy) {
           return null;
         case _record_coloring.ModeTypes.BY_SELECT_FIELD:
           {
-            if (recordColorMode.selectField.type !== _field.FieldType.SINGLE_SELECT) {
+            if (recordColorMode.selectField.type !== _field_core.FieldType.SINGLE_SELECT) {
               return null;
             }
             var value = record.getCellValue(recordColorMode.selectField);
@@ -690,7 +690,7 @@ var RecordQueryResult = /*#__PURE__*/function (_AbstractModelWithAsy) {
               // can conveniently list conditional fields, e.g. [field1, isFoo && field2]
               continue;
             }
-            if (typeof fieldOrFieldIdOrFieldName !== 'string' && !(fieldOrFieldIdOrFieldName instanceof _field2.default)) {
+            if (typeof fieldOrFieldIdOrFieldName !== 'string' && !(fieldOrFieldIdOrFieldName instanceof _field.default)) {
               throw (0, _error_utils.spawnError)('Invalid value for field, expected a field, id, or name but got: %s', fieldOrFieldIdOrFieldName);
             }
             var field = table.__getFieldMatching(fieldOrFieldIdOrFieldName);
@@ -707,7 +707,7 @@ var RecordQueryResult = /*#__PURE__*/function (_AbstractModelWithAsy) {
         case _record_coloring.ModeTypes.NONE:
           break;
         case _record_coloring.ModeTypes.BY_SELECT_FIELD:
-          (0, _error_utils.invariant)(recordColorMode.selectField.type === _field.FieldType.SINGLE_SELECT, 'Invalid field for coloring records by select field: expected a %s, but got a %s', _field.FieldType.SINGLE_SELECT, recordColorMode.selectField.type);
+          (0, _error_utils.invariant)(recordColorMode.selectField.type === _field_core.FieldType.SINGLE_SELECT, 'Invalid field for coloring records by select field: expected a %s, but got a %s', _field_core.FieldType.SINGLE_SELECT, recordColorMode.selectField.type);
           (0, _error_utils.invariant)(recordColorMode.selectField.parentTable === table, 'Invalid field for coloring records by select field: the single select field is not in the same table as the records');
           if (fieldIdsOrNullIfAllFields) {
             fieldIdsOrNullIfAllFields.push(recordColorMode.selectField.id);