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

package/dist/cjs/shared/models/mutations_core.js

@@ -1,65 +1,39 @@
 "use strict";
 
-require("core-js/modules/es.symbol.js");
-require("core-js/modules/es.symbol.description.js");
-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.MutationsCore = exports.MUTATIONS_MAX_BATCH_SIZE = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-require("core-js/modules/es.array.filter.js");
-require("core-js/modules/es.array.flat-map.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.promise.js");
-require("core-js/modules/es.set.js");
-require("core-js/modules/web.dom-collections.iterator.js");
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _mutations_core = require("../types/mutations_core");
 var _error_utils = require("../error_utils");
 var _private_utils = require("../private_utils");
-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; }
 // Limit for how many items can be updated from a single batch mutation.
 // This is number of records for MULTIPLE_RECORDS type mutations, and number of global config paths
 // for SET_MULTIPLE_GLOBAL_CONFIG_PATHS.
 // Same limit is enforced liveapp-side
-var MUTATIONS_MAX_BATCH_SIZE = exports.MUTATIONS_MAX_BATCH_SIZE = 50;
+const MUTATIONS_MAX_BATCH_SIZE = exports.MUTATIONS_MAX_BATCH_SIZE = 50;
 
 // Liveapp requests must be under 2mb in size: we enforce a 1.9mb limit here to allow space for
 // the other parts of the request
-var MUTATIONS_MAX_BODY_SIZE = 1.9 * 1024 * 1024;
-var MUTATION_HOLD_FOR_MS = 100;
+const MUTATIONS_MAX_BODY_SIZE = 1.9 * 1024 * 1024;
+const MUTATION_HOLD_FOR_MS = 100;
 
 /** @hidden */
-var MutationsCore = exports.MutationsCore = /*#__PURE__*/function () {
+class MutationsCore {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
   /** @hidden */
-  function MutationsCore(sdk, session, base, applyModelChanges, applyGlobalConfigUpdates) {
-    (0, _classCallCheck2.default)(this, MutationsCore);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_airtableInterface", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_session", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_sdk", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_base", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_applyModelChanges", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(this, "_applyGlobalConfigUpdates", void 0);
+  constructor(sdk, session, base, applyModelChanges, applyGlobalConfigUpdates) {
     this._airtableInterface = sdk.__airtableInterface;
     this._session = session;
     this._sdk = sdk;
@@ -69,371 +43,301 @@ var MutationsCore = exports.MutationsCore = /*#__PURE__*/function () {
   }
 
   /** @hidden */
-  return (0, _createClass2.default)(MutationsCore, [{
-    key: "applyMutationAsync",
-    value: (function () {
-      var _applyMutationAsync = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(mutation) {
-        var permissionCheck, didApplyOptimisticUpdates;
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              this._assertMutationIsValid(mutation);
-              // Limit check is after validity check so that we display errors for when users pass in
-              // objects correctly (eg updating linked records cell value to be a record object) -
-              // otherwise the limit check will fail due to circular objects being converted to JSON first
-              this._assertMutationUnderLimits(mutation);
-              permissionCheck = this.checkPermissionsForMutation(mutation);
-              if (permissionCheck.hasPermission) {
-                _context.next = 5;
-                break;
-              }
-              throw (0, _error_utils.spawnError)('Cannot apply %s mutation: %s', mutation.type, permissionCheck.reasonDisplayString);
-            case 5:
-              didApplyOptimisticUpdates = this._applyOptimisticUpdatesForMutation(mutation);
-              _context.prev = 6;
-              _context.next = 9;
-              return this._getAirtableInterfaceAsAirtableInterfaceCore().applyMutationAsync(mutation, {
-                holdForMs: MUTATION_HOLD_FOR_MS
-              });
-            case 9:
-              _context.next = 20;
-              break;
-            case 11:
-              _context.prev = 11;
-              _context.t0 = _context["catch"](6);
-              if (!didApplyOptimisticUpdates) {
-                _context.next = 19;
-                break;
-              }
-              // if we applied optimistic updates, we can't gracefully handle a promise rejection
-              // here - we can't un-apply optimistic updates, so the SDK's internal data model is
-              // in an unexpected state. Instead of letting this promise get rejected, throw an
-              // error after an async gap to crash the block, and make this promise await
-              // something that will never resolve so we don't run any of the developers error-
-              // handling code.
-              setTimeout(() => {
-                throw _context.t0;
-              }, 0);
-              _context.next = 17;
-              return new Promise(() => {});
-            case 17:
-              _context.next = 20;
-              break;
-            case 19:
-              throw _context.t0;
-            case 20:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[6, 11]]);
-      }));
-      function applyMutationAsync(_x) {
-        return _applyMutationAsync.apply(this, arguments);
+  async applyMutationAsync(mutation) {
+    this._assertMutationIsValid(mutation);
+    // Limit check is after validity check so that we display errors for when users pass in
+    // objects correctly (eg updating linked records cell value to be a record object) -
+    // otherwise the limit check will fail due to circular objects being converted to JSON first
+    this._assertMutationUnderLimits(mutation);
+    const permissionCheck = this.checkPermissionsForMutation(mutation);
+    if (!permissionCheck.hasPermission) {
+      throw (0, _error_utils.spawnError)('Cannot apply %s mutation: %s', mutation.type, permissionCheck.reasonDisplayString);
+    }
+    const didApplyOptimisticUpdates = this._applyOptimisticUpdatesForMutation(mutation);
+    try {
+      await this._getAirtableInterfaceAsAirtableInterfaceCore().applyMutationAsync(mutation, {
+        holdForMs: MUTATION_HOLD_FOR_MS
+      });
+    } catch (err) {
+      if (didApplyOptimisticUpdates) {
+        // if we applied optimistic updates, we can't gracefully handle a promise rejection
+        // here - we can't un-apply optimistic updates, so the SDK's internal data model is
+        // in an unexpected state. Instead of letting this promise get rejected, throw an
+        // error after an async gap to crash the block, and make this promise await
+        // something that will never resolve so we don't run any of the developers error-
+        // handling code.
+        setTimeout(() => {
+          throw err;
+        }, 0);
+        await new Promise(() => {});
+      } else {
+        throw err;
       }
-      return applyMutationAsync;
-    }() /** @hidden */)
-  }, {
-    key: "checkPermissionsForMutation",
-    value: function checkPermissionsForMutation(mutation) {
-      return this._getAirtableInterfaceAsAirtableInterfaceCore().checkPermissionsForMutation(mutation, this._base.__getBaseData());
     }
+  }
 
-    // Not really sure why this is necessary. It seems like all callsites could just use
-    // this._airtableInterface directly, but TS complains.
-    /** @hidden */
-  }, {
-    key: "_getAirtableInterfaceAsAirtableInterfaceCore",
-    value: function _getAirtableInterfaceAsAirtableInterfaceCore() {
-      return this._airtableInterface;
-    }
+  /** @hidden */
+  checkPermissionsForMutation(mutation) {
+    return this._getAirtableInterfaceAsAirtableInterfaceCore().checkPermissionsForMutation(mutation, this._base.__getBaseData());
+  }
 
-    /** @internal */
-  }, {
-    key: "_assertMutationUnderLimits",
-    value: function _assertMutationUnderLimits(mutation) {
-      // Two limits to check here:
-      // - for record-related mutations, it isn't above MUTATIONS_MAX_BATCH_SIZE
-      // - mutation payload size won't exceed liveapp request payload size limit
-      // Requests are sent as form-encoded utf-8 (1 byte characters)
-      if (encodeURIComponent(JSON.stringify(mutation)).length > MUTATIONS_MAX_BODY_SIZE) {
-        throw (0, _error_utils.spawnError)('Request exceeds maximum size limit of %s bytes', MUTATIONS_MAX_BODY_SIZE);
-      }
-      if (this._doesMutationExceedBatchSizeLimit(mutation)) {
-        throw (0, _error_utils.spawnError)('Request exceeds maximum batch size limit of %s items', MUTATIONS_MAX_BATCH_SIZE);
-      }
+  // Not really sure why this is necessary. It seems like all callsites could just use
+  // this._airtableInterface directly, but TS complains.
+  /** @hidden */
+  _getAirtableInterfaceAsAirtableInterfaceCore() {
+    return this._airtableInterface;
+  }
+
+  /** @internal */
+  _assertMutationUnderLimits(mutation) {
+    // Two limits to check here:
+    // - for record-related mutations, it isn't above MUTATIONS_MAX_BATCH_SIZE
+    // - mutation payload size won't exceed liveapp request payload size limit
+    // Requests are sent as form-encoded utf-8 (1 byte characters)
+    if (encodeURIComponent(JSON.stringify(mutation)).length > MUTATIONS_MAX_BODY_SIZE) {
+      throw (0, _error_utils.spawnError)('Request exceeds maximum size limit of %s bytes', MUTATIONS_MAX_BODY_SIZE);
     }
+    if (this._doesMutationExceedBatchSizeLimit(mutation)) {
+      throw (0, _error_utils.spawnError)('Request exceeds maximum batch size limit of %s items', MUTATIONS_MAX_BATCH_SIZE);
+    }
+  }
 
-    /** @internal */
-  }, {
-    key: "_applyOptimisticUpdatesForMutation",
-    value: function _applyOptimisticUpdatesForMutation(mutation) {
-      // GlobalConfig updates are different to other mutations (on models): for models, we
-      // only apply optimistic updates if the relevant models are loaded, whereas for
-      // SET_MULTIPLE_GLOBAL_CONFIG_PATHS we always apply optimistic updates.
-      if (mutation.type === _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS) {
-        // Not sure why this cast is necessary, but TS complains without it.
-        var _mutation = mutation;
-        this._applyGlobalConfigUpdates(_mutation.updates);
-        return true;
-      }
-      var modelChanges = this._getOptimisticModelChangesForMutation(mutation);
-      if (modelChanges.length > 0) {
-        this._applyModelChanges(modelChanges);
-        return true;
-      }
-      return false;
+  /** @internal */
+  _applyOptimisticUpdatesForMutation(mutation) {
+    // GlobalConfig updates are different to other mutations (on models): for models, we
+    // only apply optimistic updates if the relevant models are loaded, whereas for
+    // SET_MULTIPLE_GLOBAL_CONFIG_PATHS we always apply optimistic updates.
+    if (mutation.type === _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS) {
+      // Not sure why this cast is necessary, but TS complains without it.
+      const _mutation = mutation;
+      this._applyGlobalConfigUpdates(_mutation.updates);
+      return true;
     }
+    const modelChanges = this._getOptimisticModelChangesForMutation(mutation);
+    if (modelChanges.length > 0) {
+      this._applyModelChanges(modelChanges);
+      return true;
+    }
+    return false;
+  }
 
-    /** @internal */
-  }, {
-    key: "_doesMutationExceedBatchSizeLimit",
-    value: function _doesMutationExceedBatchSizeLimit(mutation) {
-      switch (mutation.type) {
-        case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
-        case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
-          return mutation.records.length > MUTATIONS_MAX_BATCH_SIZE;
-        case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
-          return mutation.recordIds.length > MUTATIONS_MAX_BATCH_SIZE;
-        case _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
-          return mutation.updates.length > 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;
-      }
+  /** @internal */
+  _doesMutationExceedBatchSizeLimit(mutation) {
+    switch (mutation.type) {
+      case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
+      case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
+        return mutation.records.length > MUTATIONS_MAX_BATCH_SIZE;
+      case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
+        return mutation.recordIds.length > MUTATIONS_MAX_BATCH_SIZE;
+      case _mutations_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+        return mutation.updates.length > 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;
     }
+  }
 
-    /** @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 */
+  _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: "_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;
-      switch (mutation.type) {
-        case _mutations_core.MutationTypesCore.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);
-            }
+    const appInterface = this._sdk.__appInterface;
+    switch (mutation.type) {
+      case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
+        {
+          const {
+            tableId,
+            records
+          } = mutation;
+          const 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 (this._isRecordStoreReadyForMutations(_recordStore)) {
-                  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 && this._isFieldAvailableForMutation(_recordStore, field.id)) {
-                    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);
-                    }
-                  }
-                }
+          // 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.
+          const recordStore = this._base.__getRecordStore(tableId);
+          const checkedFieldIds = new Set();
+          for (const record of records) {
+            let existingRecord = null;
+            if (this._isRecordStoreReadyForMutations(recordStore)) {
+              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);
               }
-            } catch (err) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
-            }
-            return;
-          }
-        case _mutations_core.MutationTypesCore.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 _recordStore2 = this._base.__getRecordStore(_tableId);
-            if (this._isRecordStoreReadyForMutations(_recordStore2)) {
-              var _iterator2 = _createForOfIteratorHelper(recordIds),
-                _step2;
-              try {
-                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                  var recordId = _step2.value;
-                  var _record = _recordStore2.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);
-                  }
+            for (const fieldId of Object.keys(record.cellValuesByFieldId)) {
+              const 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 && this._isFieldAvailableForMutation(recordStore, field.id)) {
+                const 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) {
-                _iterator2.e(err);
-              } finally {
-                _iterator2.f();
               }
             }
-            return;
           }
-        case _mutations_core.MutationTypesCore.CREATE_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);
+          return;
+        }
+      case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            recordIds
+          } = mutation;
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't delete records: No table with id %s exists", tableId);
+          }
+          const recordStore = this._base.__getRecordStore(tableId);
+          if (this._isRecordStoreReadyForMutations(recordStore)) {
+            for (const recordId of recordIds) {
+              const 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);
+              }
             }
-            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 _fieldId2 = _Object$keys2[_i2];
-                  var _field = _table2.getFieldByIdIfExists(_fieldId2);
-                  if (!_field) {
-                    throw (0, _error_utils.spawnError)("Can't create records: No field with id %s exists in table '%s'", _fieldId2, _table2.name);
-                  }
-                  if (!_checkedFieldIds.has(_fieldId2)) {
-                    this._assertFieldIsValidForMutation(_field);
-                    _checkedFieldIds.add(_fieldId2);
-                  }
+          }
+          return;
+        }
+      case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            records
+          } = mutation;
+          const checkedFieldIds = new Set();
+          const table = this._base.getTableByIdIfExists(tableId);
+          if (!table) {
+            throw (0, _error_utils.spawnError)("Can't create records: No table with id %s exists", tableId);
+          }
+          for (const record of records) {
+            for (const fieldId of Object.keys(record.cellValuesByFieldId)) {
+              const field = table.getFieldByIdIfExists(fieldId);
+              if (!field) {
+                throw (0, _error_utils.spawnError)("Can't create records: No field with id %s exists in table '%s'", fieldId, table.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[_fieldId2], 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);
-                  }
-                }
+              // Current cell value is null since the record doesn't exist.
+              const validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, record.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_core.MutationTypesCore.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.
-            return;
           }
-        default:
-          throw (0, _error_utils.spawnError)('unhandled mutation type: %s', mutation.type);
-      }
+          return;
+        }
+      case _mutations_core.MutationTypesCore.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.
+          return;
+        }
+      default:
+        throw (0, _error_utils.spawnError)('unhandled mutation type: %s', mutation.type);
     }
+  }
 
-    /** @internal */
-  }, {
-    key: "_getOptimisticModelChangesForMutation",
-    value: function _getOptimisticModelChangesForMutation(mutation) {
-      switch (mutation.type) {
-        case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
-          {
-            var tableId = mutation.tableId,
-              records = mutation.records;
-            var _recordStore3 = this._base.__getRecordStore(tableId);
-            return records.flatMap(record => Object.keys(record.cellValuesByFieldId).filter(fieldId => this._isFieldAvailableForMutation(_recordStore3, fieldId)).map(fieldId => ({
-              path: ['tablesById', tableId, 'recordsById', record.id, 'cellValuesByFieldId', fieldId],
-              value: record.cellValuesByFieldId[fieldId]
-            })));
-          }
-        case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
-          {
-            var _tableId3 = mutation.tableId,
-              recordIds = mutation.recordIds;
-            return recordIds.map(recordId => ({
-              path: ['tablesById', _tableId3, 'recordsById', recordId],
-              value: undefined
-            }));
-          }
-        case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
-          {
-            var _tableId4 = mutation.tableId,
-              _records2 = mutation.records;
-            var _recordStore4 = this._base.__getRecordStore(_tableId4);
-            return _records2.map(record => {
-              // Only apply optimistic changes for fields that are "available" for mutation
-              var filteredCellValuesByFieldId = {};
-              var _iterator4 = _createForOfIteratorHelper((0, _private_utils.entries)(record.cellValuesByFieldId)),
-                _step4;
-              try {
-                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-                  var _step4$value = (0, _slicedToArray2.default)(_step4.value, 2),
-                    _fieldId3 = _step4$value[0],
-                    cellValue = _step4$value[1];
-                  if (this._isFieldAvailableForMutation(_recordStore4, _fieldId3)) {
-                    filteredCellValuesByFieldId[_fieldId3] = cellValue;
-                  }
-                }
-              } catch (err) {
-                _iterator4.e(err);
-              } finally {
-                _iterator4.f();
+  /** @internal */
+  _getOptimisticModelChangesForMutation(mutation) {
+    switch (mutation.type) {
+      case _mutations_core.MutationTypesCore.SET_MULTIPLE_RECORDS_CELL_VALUES:
+        {
+          const {
+            tableId,
+            records
+          } = mutation;
+          const recordStore = this._base.__getRecordStore(tableId);
+          return records.flatMap(record => Object.keys(record.cellValuesByFieldId).filter(fieldId => this._isFieldAvailableForMutation(recordStore, fieldId)).map(fieldId => ({
+            path: ['tablesById', tableId, 'recordsById', record.id, 'cellValuesByFieldId', fieldId],
+            value: record.cellValuesByFieldId[fieldId]
+          })));
+        }
+      case _mutations_core.MutationTypesCore.DELETE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            recordIds
+          } = mutation;
+          return recordIds.map(recordId => ({
+            path: ['tablesById', tableId, 'recordsById', recordId],
+            value: undefined
+          }));
+        }
+      case _mutations_core.MutationTypesCore.CREATE_MULTIPLE_RECORDS:
+        {
+          const {
+            tableId,
+            records
+          } = mutation;
+          const recordStore = this._base.__getRecordStore(tableId);
+          return records.map(record => {
+            // Only apply optimistic changes for fields that are "available" for mutation
+            const filteredCellValuesByFieldId = {};
+            for (const [fieldId, cellValue] of (0, _private_utils.entries)(record.cellValuesByFieldId)) {
+              if (this._isFieldAvailableForMutation(recordStore, fieldId)) {
+                filteredCellValuesByFieldId[fieldId] = cellValue;
               }
-              return {
-                path: ['tablesById', _tableId4, 'recordsById', record.id],
-                value: {
-                  id: record.id,
-                  cellValuesByFieldId: filteredCellValuesByFieldId,
-                  commentCount: 0,
-                  createdTime: new Date().toJSON()
-                }
-              };
-            });
-          }
+            }
+            return {
+              path: ['tablesById', tableId, 'recordsById', record.id],
+              value: {
+                ...this._getDefaultRecordProperties(),
+                id: record.id,
+                cellValuesByFieldId: filteredCellValuesByFieldId
+              }
+            };
+          });
+        }
 
-        // 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_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
-          {
-            throw (0, _error_utils.spawnError)('attempting to generate model updates for SET_MULTIPLE_GLOBAL_CONFIG_PATH');
-          }
+      // 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_core.MutationTypesCore.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+        {
+          throw (0, _error_utils.spawnError)('attempting to generate model updates for SET_MULTIPLE_GLOBAL_CONFIG_PATH');
+        }
 
-        // 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.spawnError)('unhandled mutation type: %s', 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.spawnError)('unhandled mutation type: %s', mutation.type);
     }
+  }
+
+  /** @internal */
+
+  /** @internal */
 
-    /** @internal */
-  }]);
-}();
+  /** @internal */
+}
+exports.MutationsCore = MutationsCore;