@airtable/blocks 0.0.0-experimental-c4b2228f4-20250630 → 0.0.0-experimental-3649c7162-20250904

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

@@ -1,439 +0,0 @@
-"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;
-
-// 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;
-
-/** @hidden */
-var MutationsCore = exports.MutationsCore = /*#__PURE__*/function () {
-  /** @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);
-    this._airtableInterface = sdk.__airtableInterface;
-    this._session = session;
-    this._sdk = sdk;
-    this._base = base;
-    this._applyModelChanges = applyModelChanges;
-    this._applyGlobalConfigUpdates = applyGlobalConfigUpdates;
-  }
-
-  /** @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);
-      }
-      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;
-    }
-
-    /** @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);
-      }
-    }
-
-    /** @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 */
-  }, {
-    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 */
-  }, {
-    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: "_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.
-
-      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);
-            }
-
-            // 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);
-                    }
-                  }
-                }
-              }
-            } 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);
-                  }
-                }
-              } 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);
-            }
-            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);
-                  }
-
-                  // 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);
-                  }
-                }
-              }
-            } 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);
-      }
-    }
-
-    /** @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();
-              }
-              return {
-                path: ['tablesById', _tableId4, 'recordsById', record.id],
-                value: {
-                  id: record.id,
-                  cellValuesByFieldId: filteredCellValuesByFieldId,
-                  commentCount: 0,
-                  createdTime: new Date().toJSON()
-                }
-              };
-            });
-          }
-
-        // 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);
-      }
-    }
-
-    /** @internal */
-  }]);
-}();