@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-75d011284-20250904

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

@@ -1,338 +1,312 @@
 "use strict";
 
-require("core-js/modules/es.array.from.js");
-require("core-js/modules/es.array.slice.js");
-require("core-js/modules/es.regexp.exec.js");
-require("core-js/modules/es.regexp.to-string.js");
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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.flat-map.js");
-require("core-js/modules/es.array.includes.js");
-require("core-js/modules/es.array.iterator.js");
-require("core-js/modules/es.array.map.js");
-require("core-js/modules/es.array.unscopables.flat-map.js");
-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 _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 _error_utils = require("../../shared/error_utils");
 var _mutation_constants = require("../../shared/types/mutation_constants");
 var _mutations_core = require("../../shared/models/mutations_core");
-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; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 /** @hidden */
-var Mutations = /*#__PURE__*/function (_MutationsCore) {
-  function Mutations() {
-    (0, _classCallCheck2.default)(this, Mutations);
-    return _callSuper(this, Mutations, arguments);
+class Mutations extends _mutations_core.MutationsCore {
+  /** @internal */
+  _isRecordStoreReadyForMutations(recordStore) {
+    return recordStore.isRecordMetadataLoaded;
   }
-  (0, _inherits2.default)(Mutations, _MutationsCore);
-  return (0, _createClass2.default)(Mutations, [{
-    key: "_isRecordStoreReadyForMutations",
-    value: /** @internal */
-    function _isRecordStoreReadyForMutations(recordStore) {
-      return recordStore.isRecordMetadataLoaded;
-    }
 
-    /** @internal */
-  }, {
-    key: "_isFieldAvailableForMutation",
-    value: function _isFieldAvailableForMutation(recordStore, fieldId) {
-      return recordStore.areCellValuesLoadedForFieldId(fieldId);
-    }
+  /** @internal */
+  _isFieldAvailableForMutation(recordStore, fieldId) {
+    return recordStore.areCellValuesLoadedForFieldId(fieldId);
+  }
+
+  /** @internal */
+  _getDefaultRecordProperties() {
+    return {
+      commentCount: 0,
+      createdTime: new Date().toJSON()
+    };
+  }
 
-    /** @internal */
-  }, {
-    key: "_assertMutationIsValid",
-    value: function _assertMutationIsValid(mutation) {
-      // We call validate the data (including any cell values) because if the data required for
-      // us to do that is already loaded in the block, we can error out before applying
-      // optimistic updates or sending the update to liveapp. That means that the error is
-      // recoverable. Once we apply optimistic updates, if liveapp rejects the update then we
-      // can't recover from that - we have to crash the block. We _could_ skip over these
-      // validations - it wouldn't cause issues outside of the block frame. But running them
-      // gives us slightly more confidence that we can do something other than completely crash
-      // the block in the event of an invalid mutation.
+  /** @internal */
+  _assertMutationIsValid(mutation) {
+    // We call validate the data (including any cell values) because if the data required for
+    // us to do that is already loaded in the block, we can error out before applying
+    // optimistic updates or sending the update to liveapp. That means that the error is
+    // recoverable. Once we apply optimistic updates, if liveapp rejects the update then we
+    // can't recover from that - we have to crash the block. We _could_ skip over these
+    // validations - it wouldn't cause issues outside of the block frame. But running them
+    // gives us slightly more confidence that we can do something other than completely crash
+    // the block in the event of an invalid mutation.
 
-      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:
-        case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
-        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
-          {
-            (0, _get2.default)((0, _getPrototypeOf2.default)(Mutations.prototype), "_assertMutationIsValid", this).call(this, mutation);
-            return;
+    const appInterface = this._sdk.__appInterface;
+    const billingPlanGrouping = this._base.__billingPlanGrouping;
+    switch (mutation.type) {
+      case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
+      case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+      case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
+        {
+          super._assertMutationIsValid(mutation);
+          return;
+        }
+      case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
+        {
+          const {
+            tableId,
+            name,
+            config,
+            description
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't create field: No table with id %s exists", tableId);
           }
-        case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
-          {
-            var tableId = mutation.tableId,
-              name = mutation.name,
-              config = mutation.config,
-              description = mutation.description;
-            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 (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, 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, table);
 
-            // Current config / field data is null since the field doesn't exist.
-            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);
-            }
-            return;
+          // Current config / field data is null since the field doesn't exist.
+          const 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);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
+        {
+          const {
+            tableId,
+            id,
+            config,
+            opts
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", tableId);
+          }
+          const field = table.getFieldByIdIfExists(id);
+          if (!field) {
+            throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", id);
           }
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
-          {
-            var _tableId = mutation.tableId,
-              id = mutation.id,
-              _config = mutation.config,
-              opts = mutation.opts;
-            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 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, 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;
+          // 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
+          const currentConfig = this._airtableInterface.fieldTypeProvider.getConfig(appInterface, field._data, field.parentTable.__getFieldNamesById());
+          const 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);
           }
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
-          {
-            var _tableId2 = mutation.tableId,
-              _id = mutation.id,
-              _description = mutation.description;
-            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 _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) {
-              throw (0, _error_utils.spawnError)("Can't update field: description exceeds maximum length of %s characters", _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
-            }
-            return;
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+        {
+          const {
+            tableId,
+            id,
+            description
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", tableId);
+          }
+          const field = table.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) {
+            throw (0, _error_utils.spawnError)("Can't update field: description exceeds maximum length of %s characters", _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+        {
+          const {
+            tableId,
+            id,
+            name
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", tableId);
+          }
+          const field = table.getFieldByIdIfExists(id);
+          if (!field) {
+            throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", id);
           }
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
-          {
-            var _tableId3 = mutation.tableId,
-              _id2 = mutation.id,
-              _name = mutation.name;
-            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 _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 (_field2.name.toLowerCase() !== _name.toLowerCase()) {
-              this._assertFieldNameIsValidForMutation(_name, _table3);
-            }
-            return;
+          // 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 (field.name.toLowerCase() !== name.toLowerCase()) {
+            this._assertFieldNameIsValidForMutation(name, table);
           }
-        case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
-          {
-            var _name2 = mutation.name,
-              fields = mutation.fields;
-            if (!_name2) {
-              throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name");
-            }
-            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(_name2.toLowerCase())) {
-              throw (0, _error_utils.spawnError)("Can't create table: table with name '%s' already exists", _name2);
+          return;
+        }
+      case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
+        {
+          const {
+            name,
+            fields
+          } = mutation;
+          if (!name) {
+            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);
+          }
+          const 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 (fields.length === 0) {
+            throw (0, _error_utils.spawnError)("Can't create table: must specify at least one field");
+          }
+          if (fields.length > _mutation_constants.MAX_NUM_FIELDS_PER_TABLE) {
+            throw (0, _error_utils.spawnError)("Can't create table: number of fields exceeds maximum of %s", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
+          }
+          const lowercaseFieldNames = new Set();
+          for (const field of fields) {
+            if (!field.name) {
+              throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name for every field");
             }
-            if (fields.length === 0) {
-              throw (0, _error_utils.spawnError)("Can't create table: must specify at least one field");
+            if (field.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", field.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
             }
-            if (fields.length > _mutation_constants.MAX_NUM_FIELDS_PER_TABLE) {
-              throw (0, _error_utils.spawnError)("Can't create table: number of fields exceeds maximum of %s", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
+            const lowercaseFieldName = field.name.toLowerCase();
+            if (lowercaseFieldNames.has(lowercaseFieldName)) {
+              throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", field.name);
             }
-            var lowercaseFieldNames = new Set();
-            var _iterator = _createForOfIteratorHelper(fields),
-              _step;
-            try {
-              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 (_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 = _field3.name.toLowerCase();
-                if (lowercaseFieldNames.has(lowercaseFieldName)) {
-                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field3.name);
-                }
-                lowercaseFieldNames.add(lowercaseFieldName);
+            lowercaseFieldNames.add(lowercaseFieldName);
 
-                // Current config / field data is null since the field doesn't exist.
-                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 (_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) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
+            // Current config / field data is null since the field doesn't exist.
+            const validationResult = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, field.config, null, null, billingPlanGrouping);
+            if (!validationResult.isValid) {
+              throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", field.name, validationResult.reason);
             }
-            var primaryField = fields[0];
-            if (!this._airtableInterface.fieldTypeProvider.canBePrimary(appInterface, primaryField.config, billingPlanGrouping)) {
-              throw (0, _error_utils.spawnError)("Can't create table: first field '%s' has type '%s' which cannot be a primary field", primaryField.name, primaryField.config.type);
+            if (field.description && field.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", field.name, _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
             }
-            return;
           }
-        case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
-          {
-            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 !== _tableId4) {
-              throw (0, _error_utils.spawnError)('Custom views can only set view metadata on themselves');
-            }
-            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 = _table4.getViewByIdIfExists(viewId);
-            if (!view) {
-              throw (0, _error_utils.spawnError)("Can't update metadata: No view with id %s exists", viewId);
-            }
-            return;
+          const primaryField = fields[0];
+          if (!this._airtableInterface.fieldTypeProvider.canBePrimary(appInterface, primaryField.config, billingPlanGrouping)) {
+            throw (0, _error_utils.spawnError)("Can't create table: first field '%s' has type '%s' which cannot be a primary field", primaryField.name, primaryField.config.type);
+          }
+          return;
+        }
+      case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
+        {
+          const {
+            tableId,
+            viewId
+          } = mutation;
+          const {
+            runContext
+          } = this._airtableInterface.sdkInitData;
+          if (runContext.type !== _airtable_interface.BlockRunContextType.VIEW) {
+            throw (0, _error_utils.spawnError)('Setting view metadata is only valid for views');
           }
-        default:
-          throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation, 'type');
-      }
+          if (runContext.viewId !== viewId || runContext.tableId !== tableId) {
+            throw (0, _error_utils.spawnError)('Custom views can only set view metadata on themselves');
+          }
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", tableId);
+          }
+          const view = table.getViewByIdIfExists(viewId);
+          if (!view) {
+            throw (0, _error_utils.spawnError)("Can't update metadata: No view with id %s exists", viewId);
+          }
+          return;
+        }
+      default:
+        throw (0, _error_utils.spawnUnknownSwitchCaseError)('mutation type', mutation, 'type');
     }
+  }
 
-    /** @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);
-      }
+  /** @internal */
+  _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);
-      }
+    // Verify the new name doesn't collide with any existing field name.
+    const 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: "_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);
-            if (!recordStore.isRecordMetadataLoaded) {
-              return [];
-            }
-            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.__generateChangesForParentTableAddMultipleRecords(records.map(record => record.id));
-            })];
+  /** @internal */
+  _getOptimisticModelChangesForMutation(mutation) {
+    switch (mutation.type) {
+      case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+      case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
+        return super._getOptimisticModelChangesForMutation(mutation);
+      case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            records
+          } = mutation;
+          const recordStore = this._base.__getRecordStore(tableId);
+          if (!recordStore.isRecordMetadataLoaded) {
+            return [];
           }
-        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
-          {
-            var _tableId5 = mutation.tableId,
-              recordIds = mutation.recordIds;
-            var _recordStore = this._base.__getRecordStore(_tableId5);
-            if (!_recordStore.isRecordMetadataLoaded) {
+          const superChanges = super._getOptimisticModelChangesForMutation(mutation);
+          return [...superChanges, ...this._base.getTableById(tableId).views.flatMap(view => {
+            const viewDataStore = recordStore.getViewDataStore(view.id);
+            if (!viewDataStore.isDataLoaded) {
               return [];
             }
-            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.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
-            })];
-          }
-        case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
-        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
-        case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
-        case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
-          {
-            // No optimistic updates for field, view metadata, or table mutations.
+            return viewDataStore.__generateChangesForParentTableAddMultipleRecords(records.map(record => record.id));
+          })];
+        }
+      case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            recordIds
+          } = mutation;
+          const recordStore = this._base.__getRecordStore(tableId);
+          if (!recordStore.isRecordMetadataLoaded) {
             return [];
           }
+          const superChanges = super._getOptimisticModelChangesForMutation(mutation);
+          return [...superChanges, ...this._base.getTableById(tableId).views.flatMap(view => {
+            const viewDataStore = recordStore.getViewDataStore(view.id);
+            if (!viewDataStore.isDataLoaded) {
+              return [];
+            }
+            return viewDataStore.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
+          })];
+        }
+      case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+      case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+      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');
-      }
+      // 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');
     }
-  }]);
-}(_mutations_core.MutationsCore);
+  }
+}
 var _default = exports.default = Mutations;