@airtable/blocks 0.0.0-experimental-f1c9010b3-20250609 → 0.0.0-experimental-c4b2228f4-20250630

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

@@ -1,19 +1,37 @@
 "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.
@@ -166,6 +184,256 @@ var MutationsCore = exports.MutationsCore = /*#__PURE__*/function () {
       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 */
   }]);
 }();

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

@@ -22,9 +22,9 @@ var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _private_utils = require("../private_utils");
 var _error_utils = require("../error_utils");
-var _field = require("../types/field");
+var _field_core = require("../types/field_core");
 var _abstract_model = _interopRequireDefault(require("./abstract_model"));
-var _field_core = require("./field_core");
+var _field_core2 = require("./field_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; }
@@ -96,7 +96,7 @@ var RecordCore = exports.RecordCore = /*#__PURE__*/function (_AbstractModel) {
   }, {
     key: "_getFieldMatching",
     value: function _getFieldMatching(fieldOrFieldIdOrFieldName) {
-      if (fieldOrFieldIdOrFieldName instanceof _field_core.FieldCore) {
+      if (fieldOrFieldIdOrFieldName instanceof _field_core2.FieldCore) {
         return this._parentTable.__getFieldMatching(fieldOrFieldIdOrFieldName.id);
       }
       return this.parentTable.__getFieldMatching(fieldOrFieldIdOrFieldName);
@@ -144,7 +144,7 @@ var RecordCore = exports.RecordCore = /*#__PURE__*/function (_AbstractModel) {
       var cellValue = this._getRawCellValue(field);
 
       // HACK: migrate to new public lookup cell value format if needed
-      if (typeof cellValue === 'object' && cellValue !== null && field.type === _field.FieldType.MULTIPLE_LOOKUP_VALUES && !this._sdk.__airtableInterface.sdkInitData.isUsingNewLookupCellValueFormat) {
+      if (typeof cellValue === 'object' && cellValue !== null && field.type === _field_core.FieldType.MULTIPLE_LOOKUP_VALUES && !this._sdk.__airtableInterface.sdkInitData.isUsingNewLookupCellValueFormat) {
         var cellValueForMigration = [];
         (0, _error_utils.invariant)(Array.isArray(cellValue.linkedRecordIds), 'linkedRecordIds');
         var _iterator = _createForOfIteratorHelper(cellValue.linkedRecordIds),