@airtable/blocks 1.11.1-experimental-68738f2-20220526 → 1.13.0

package/dist/cjs/models/mutations.js

@@ -6,12 +6,18 @@ require("core-js/modules/es.symbol");
 
 require("core-js/modules/es.symbol.description");
 
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.array.flat-map");
+
 require("core-js/modules/es.array.includes");
 
 require("core-js/modules/es.array.iterator");
 
 require("core-js/modules/es.array.map");
 
+require("core-js/modules/es.array.unscopables.flat-map");
+
 require("core-js/modules/es.object.to-string");
 
 require("core-js/modules/es.promise");
@@ -22,11 +28,15 @@ require("core-js/modules/es.string.includes");
 
 require("core-js/modules/web.dom-collections.iterator");
 
+require("core-js/modules/web.url.to-json");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 require("regenerator-runtime/runtime");
@@ -41,6 +51,8 @@ var _airtable_interface = require("../types/airtable_interface");
 
 var _mutations = require("../types/mutations");
 
+var _private_utils = require("../private_utils");
+
 var _error_utils = require("../error_utils");
 
 var _mutation_constants = require("./mutation_constants");
@@ -69,18 +81,22 @@ function () {
 
   /** @internal */
 
+  /** @internal */
+
   /** @hidden */
-  function Mutations(sdk, session, base, applyGlobalConfigUpdates) {
+  function Mutations(sdk, session, base, applyModelChanges, applyGlobalConfigUpdates) {
     (0, _classCallCheck2.default)(this, Mutations);
     (0, _defineProperty2.default)(this, "_airtableInterface", void 0);
     (0, _defineProperty2.default)(this, "_session", void 0);
     (0, _defineProperty2.default)(this, "_sdk", void 0);
     (0, _defineProperty2.default)(this, "_base", void 0);
+    (0, _defineProperty2.default)(this, "_applyModelChanges", void 0);
     (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 */
@@ -274,12 +290,9 @@ function () {
             try {
               for (var _iterator = records[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                 var record = _step.value;
-                var existingRecord = null; // Note - if isSubscribedToAllRecordsInTable is true then we know the record
-                // doesn't exist (or is deleted) but otherwise we can issue a mutation to a record
-                // that does not exist, having to deal with the error thrown by PublicAirtableInterfaceFrontend
-                // TODO: (#proj-blocks-sdk-record-limits) Write tests around this behavior
+                var existingRecord = null;
 
-                if (recordStore.isSubscribedToAllRecordsInTable || recordStore.isRecordLoaded(record.id)) {
+                if (recordStore.isRecordMetadataLoaded) {
                   existingRecord = recordStore.getRecordByIdIfExists(record.id);
 
                   if (!existingRecord) {
@@ -301,7 +314,7 @@ function () {
                     checkedFieldIds.add(fieldId);
                   }
 
-                  if (existingRecord && recordStore.isRecordCellValueLoadedForFieldId(record.id, fieldId)) {
+                  if (existingRecord && recordStore.areCellValuesLoadedForFieldId(fieldId)) {
                     var validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, record.cellValuesByFieldId[fieldId], existingRecord._getRawCellValue(field), field._data);
 
                     if (!validationResult.isValid) {
@@ -339,15 +352,9 @@ function () {
               throw (0, _error_utils.spawnError)("Can't delete records: No table with id %s exists", _tableId);
             }
 
-            var _recordStore = this._base.__getRecordStore(_tableId); // TODO: (#proj-blocks-sdk-record-limits) We substantially weaken our check here
-            // because we can only be sure if the record exists inside the SDK if we've loaded
-            // all records. It is possible to change this logic to ensure we don't double-delete
-            // records by caching previously deleted records (if the delete is undone, but
-            // we're not watching the record be re-created from the undo we would have to fail
-            // the delete if we detect double deletion). TODO to add tests around this behavior.
-
+            var _recordStore = this._base.__getRecordStore(_tableId);
 
-            if (_recordStore.isSubscribedToAllRecordsInTable) {
+            if (_recordStore.isRecordMetadataLoaded) {
               var _iteratorNormalCompletion2 = true;
               var _didIteratorError2 = false;
               var _iteratorError2 = undefined;
@@ -701,13 +708,151 @@ function () {
         this._applyGlobalConfigUpdates(mutation.updates);
 
         return true;
-      } // https://airtable.com/appahuJQw7qfQTBBU/tblSbpimM8Spp9txp/viweAFIus3MhU9Gxa/recHOckY4V9QmM6JV?blocks=hide
-      // TODO: (#proj-blocks-sdk-record-limits) Fix this in a future stacked diff where optimistic
-      // updates are re-enabled https://docs.google.com/document/d/1CVZ4ZoPWEtpzKq_9cRLASGwgY71WI4nl6RVvs8S7Ubw/edit#
+      }
+
+      var modelChanges = this._getOptimisticModelChangesForMutation(mutation);
 
+      if (modelChanges.length > 0) {
+        this._applyModelChanges(modelChanges);
+
+        return true;
+      }
 
       return false;
     }
+    /** @internal */
+
+  }, {
+    key: "_getOptimisticModelChangesForMutation",
+    value: function _getOptimisticModelChangesForMutation(mutation) {
+      switch (mutation.type) {
+        case _mutations.MutationTypes.SET_MULTIPLE_RECORDS_CELL_VALUES:
+          {
+            var tableId = mutation.tableId,
+                records = mutation.records;
+
+            var recordStore = this._base.__getRecordStore(tableId);
+
+            return records.flatMap(record => Object.keys(record.cellValuesByFieldId).filter(fieldId => recordStore.areCellValuesLoadedForFieldId(fieldId)).map(fieldId => ({
+              path: ['tablesById', tableId, 'recordsById', record.id, 'cellValuesByFieldId', fieldId],
+              value: record.cellValuesByFieldId[fieldId]
+            })));
+          }
+
+        case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
+          {
+            var _tableId8 = mutation.tableId,
+                recordIds = mutation.recordIds;
+
+            var _recordStore2 = this._base.__getRecordStore(_tableId8);
+
+            if (!_recordStore2.isRecordMetadataLoaded) {
+              return [];
+            }
+
+            return [...recordIds.map(recordId => ({
+              path: ['tablesById', _tableId8, 'recordsById', recordId],
+              value: undefined
+            })), ...this._base.getTableById(_tableId8).views.flatMap(view => {
+              var viewDataStore = _recordStore2.getViewDataStore(view.id);
+
+              if (!viewDataStore.isDataLoaded) {
+                return [];
+              }
+
+              return viewDataStore.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
+            })];
+          }
+
+        case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
+          {
+            var _tableId9 = mutation.tableId,
+                _records2 = mutation.records;
+
+            var _recordStore3 = this._base.__getRecordStore(_tableId9);
+
+            if (!_recordStore3.isRecordMetadataLoaded) {
+              return [];
+            }
+
+            return [..._records2.map(record => {
+              // Only apply optimistic changes for fields that are loaded
+              var filteredCellValuesByFieldId = {};
+              var _iteratorNormalCompletion5 = true;
+              var _didIteratorError5 = false;
+              var _iteratorError5 = undefined;
+
+              try {
+                for (var _iterator5 = (0, _private_utils.entries)(record.cellValuesByFieldId)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+                  var _step5$value = (0, _slicedToArray2.default)(_step5.value, 2),
+                      fieldId = _step5$value[0],
+                      cellValue = _step5$value[1];
+
+                  if (_recordStore3.areCellValuesLoadedForFieldId(fieldId)) {
+                    filteredCellValuesByFieldId[fieldId] = cellValue;
+                  }
+                }
+              } catch (err) {
+                _didIteratorError5 = true;
+                _iteratorError5 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                    _iterator5.return();
+                  }
+                } finally {
+                  if (_didIteratorError5) {
+                    throw _iteratorError5;
+                  }
+                }
+              }
+
+              return {
+                path: ['tablesById', _tableId9, 'recordsById', record.id],
+                value: {
+                  id: record.id,
+                  cellValuesByFieldId: filteredCellValuesByFieldId,
+                  commentCount: 0,
+                  createdTime: new Date().toJSON()
+                }
+              };
+            }), ...this._base.getTableById(_tableId9).views.flatMap(view => {
+              var viewDataStore = _recordStore3.getViewDataStore(view.id);
+
+              if (!viewDataStore.isDataLoaded) {
+                return [];
+              }
+
+              return viewDataStore.__generateChangesForParentTableAddMultipleRecords(_records2.map(record => record.id));
+            })];
+          }
+        // The following branch is unreachable because this method's only
+        // call site is preceded by an explicit guard for this condition.
+        // istanbul ignore next
+
+        case _mutations.MutationTypes.SET_MULTIPLE_GLOBAL_CONFIG_PATHS:
+          {
+            throw (0, _error_utils.spawnError)('attempting to generate model updates for SET_MULTIPLE_GLOBAL_CONFIG_PATH');
+          }
+
+        case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
+        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
+        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+        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');
+      }
+    }
   }]);
   return Mutations;
 }();