@airtable/blocks 1.9.0 → 1.10.2-experimental-640bd10-20220211

package/dist/cjs/models/mutations.js

@@ -6,18 +6,12 @@ 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");
@@ -28,15 +22,11 @@ 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");
@@ -51,8 +41,6 @@ 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");
@@ -81,22 +69,18 @@ function () {
 
   /** @internal */
 
-  /** @internal */
-
   /** @hidden */
-  function Mutations(sdk, session, base, applyModelChanges, applyGlobalConfigUpdates) {
+  function Mutations(sdk, session, base, 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 */
@@ -270,9 +254,12 @@ function () {
             try {
               for (var _iterator = records[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                 var record = _step.value;
-                var existingRecord = null;
+                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
 
-                if (recordStore.isRecordMetadataLoaded) {
+                if (recordStore.isSubscribedToAllRecordsInTable || recordStore.isRecordLoaded(record.id)) {
                   existingRecord = recordStore.getRecordByIdIfExists(record.id);
 
                   if (!existingRecord) {
@@ -294,7 +281,7 @@ function () {
                     checkedFieldIds.add(fieldId);
                   }
 
-                  if (existingRecord && recordStore.areCellValuesLoadedForFieldId(fieldId)) {
+                  if (existingRecord && recordStore.isRecordCellValueLoadedForFieldId(record.id, fieldId)) {
                     var validationResult = this._airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, record.cellValuesByFieldId[fieldId], existingRecord._getRawCellValue(field), field._data);
 
                     if (!validationResult.isValid) {
@@ -332,9 +319,15 @@ function () {
               throw (0, _error_utils.spawnError)("Can't delete records: No table with id %s exists", _tableId);
             }
 
-            var _recordStore = this._base.__getRecordStore(_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.
+
 
-            if (_recordStore.isRecordMetadataLoaded) {
+            if (_recordStore.isSubscribedToAllRecordsInTable) {
               var _iteratorNormalCompletion2 = true;
               var _didIteratorError2 = false;
               var _iteratorError2 = undefined;
@@ -672,150 +665,13 @@ function () {
         this._applyGlobalConfigUpdates(mutation.updates);
 
         return true;
-      }
-
-      var modelChanges = this._getOptimisticModelChangesForMutation(mutation);
+      } // 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#
 
-      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 _tableId7 = mutation.tableId,
-                recordIds = mutation.recordIds;
-
-            var _recordStore2 = this._base.__getRecordStore(_tableId7);
-
-            if (!_recordStore2.isRecordMetadataLoaded) {
-              return [];
-            }
-
-            return [...recordIds.map(recordId => ({
-              path: ['tablesById', _tableId7, 'recordsById', recordId],
-              value: undefined
-            })), ...this._base.getTableById(_tableId7).views.flatMap(view => {
-              var viewDataStore = _recordStore2.getViewDataStore(view.id);
-
-              if (!viewDataStore.isDataLoaded) {
-                return [];
-              }
-
-              return viewDataStore.__generateChangesForParentTableDeleteMultipleRecords(recordIds);
-            })];
-          }
-
-        case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
-          {
-            var _tableId8 = mutation.tableId,
-                _records2 = mutation.records;
-
-            var _recordStore3 = this._base.__getRecordStore(_tableId8);
-
-            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', _tableId8, 'recordsById', record.id],
-                value: {
-                  id: record.id,
-                  cellValuesByFieldId: filteredCellValuesByFieldId,
-                  commentCount: 0,
-                  createdTime: new Date().toJSON()
-                }
-              };
-            }), ...this._base.getTableById(_tableId8).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_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;
 }();

package/dist/cjs/models/query_manager.js

@@ -0,0 +1,328 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+require("core-js/modules/es.array.iterator");
+
+require("core-js/modules/es.map");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/web.dom-collections.for-each");
+
+require("core-js/modules/web.dom-collections.iterator");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.QueryManager = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+require("regenerator-runtime/runtime");
+
+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 _error_utils = require("../error_utils");
+
+var _private_utils = require("../private_utils");
+
+/**
+ * This provides a singleton instance which is responsible for all queries sent
+ * to PublicAirtableInterface.
+ *
+ * This can allow looking up queries by queryId.
+ *
+ * @internal
+ */
+var QueryManager =
+/*#__PURE__*/
+function () {
+  function QueryManager(sdk) {
+    (0, _classCallCheck2.default)(this, QueryManager);
+    (0, _defineProperty2.default)(this, "_airtableInterface", void 0);
+    (0, _defineProperty2.default)(this, "_sdk", void 0);
+    (0, _defineProperty2.default)(this, "_queryRegistrationInfosByWatchKey", new Map());
+    (0, _defineProperty2.default)(this, "fetchAndSubscribeToQueryAsync", (query, querySubscriptionOptions) => {
+      var queryResponse;
+      return _regenerator.default.async(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return _regenerator.default.awrap(this._airtableInterface.subscribeToQueryAndPopulateStoresAsync(query, querySubscriptionOptions !== null && querySubscriptionOptions !== void 0 ? querySubscriptionOptions : {}));
+
+            case 2:
+              queryResponse = _context.sent;
+
+              if (queryResponse.success) {
+                _context.next = 5;
+                break;
+              }
+
+              throw (0, _error_utils.spawnError)('Subscription to query failed - unhandled error');
+
+            case 5:
+              return _context.abrupt("return", queryResponse.blockQueryId);
+
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, null, this);
+    });
+    (0, _defineProperty2.default)(this, "unsubscribeFromQueryIds", queryIds => {
+      var _iteratorNormalCompletion = true;
+      var _didIteratorError = false;
+      var _iteratorError = undefined;
+
+      try {
+        for (var _iterator = queryIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var queryId = _step.value;
+          // TODO: (#proj-blocks-sdk-record-limits) Add support for unsubscribing multiple at the same time
+          this.unsubscribeFromQueryId(queryId);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    });
+    (0, _defineProperty2.default)(this, "unsubscribeFromQueryId", queryId => {
+      (0, _private_utils.fireAndForgetPromise)(() => this._airtableInterface.unsubscribeFromQueryIdsAsync([queryId]));
+    });
+    (0, _defineProperty2.default)(this, "watchWithQuerySpec", (callbackPriority, query, watchableModel, watchKey, watchOnChangeCallback, callbackForRegistration, context) => {
+      var isOnChangeCallbackCanceled = false;
+
+      var callbackForCancelOnChange = () => isOnChangeCallbackCanceled = true;
+
+      var onChangeCallback = changes => {
+        if (isOnChangeCallbackCanceled) {
+          return;
+        }
+
+        watchableModel.__incrementOnChangeCount();
+
+        watchOnChangeCallback(changes);
+      };
+
+      var blockQueryIdPromise = this.fetchAndSubscribeToQueryAsync(query, {
+        onChangeCallback,
+        callbackPriority
+      });
+
+      var queryRegistrationInfosForKey = this._queryRegistrationInfosByWatchKey.get(watchKey);
+
+      if (!queryRegistrationInfosForKey) {
+        queryRegistrationInfosForKey = [];
+
+        this._queryRegistrationInfosByWatchKey.set(watchKey, queryRegistrationInfosForKey);
+      } // It is safe to push onto queryRegistrationInfosForKey (vs copying) as long
+      // as we don't release the event loop when we iterate over it, which only
+      // happens in unwatchFromQueryKeys
+
+
+      queryRegistrationInfosForKey.push({
+        blockQueryIdPromise,
+        callbackForCancelOnChange,
+        callbackForRegistration,
+        context,
+        onChangeCallback,
+        watchableModel
+      });
+    });
+    (0, _defineProperty2.default)(this, "_unwatchFromQueryRegistrationInfoAsync", queryRegistrationInfo => {
+      var blockQueryIdPromise, callbackForCancelOnChange, queryId;
+      return _regenerator.default.async(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              blockQueryIdPromise = queryRegistrationInfo.blockQueryIdPromise, callbackForCancelOnChange = queryRegistrationInfo.callbackForCancelOnChange;
+              callbackForCancelOnChange();
+              _context2.next = 4;
+              return _regenerator.default.awrap(blockQueryIdPromise);
+
+            case 4:
+              queryId = _context2.sent;
+              this.unsubscribeFromQueryId(queryId);
+
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this);
+    });
+    (0, _defineProperty2.default)(this, "unwatchFromQueryKey", (watchKey, callbackForRegistration, context) => {
+      var queryRegistrationInfos = this._queryRegistrationInfosByWatchKey.get(watchKey);
+
+      if (queryRegistrationInfos) {
+        var watchersToUnwatch = [];
+        var watchersToKeep = [];
+        queryRegistrationInfos.forEach(watcher => {
+          var isCallbackToUnwatch = watcher.callbackForRegistration === callbackForRegistration && watcher.context === context;
+
+          if (isCallbackToUnwatch) {
+            watchersToUnwatch.push(watcher);
+          } else {
+            watchersToKeep.push(watcher);
+          }
+        });
+
+        if (watchersToKeep.length > 0) {
+          this._queryRegistrationInfosByWatchKey.set(watchKey, watchersToKeep);
+        } else {
+          this._queryRegistrationInfosByWatchKey.delete(watchKey);
+        }
+
+        if (watchersToUnwatch.length > 0) {
+          // Do not await the response since unwatch is not async
+          watchersToUnwatch.forEach(this._unwatchFromQueryRegistrationInfoAsync);
+        }
+      }
+    });
+    this._airtableInterface = sdk.__airtableInterface;
+    this._sdk = sdk;
+  }
+
+  (0, _createClass2.default)(QueryManager, [{
+    key: "_onChange",
+    value: function _onChange(watchableModel, watchKey) {
+      var queryRegistrationInfos = this._queryRegistrationInfosByWatchKey.get(watchKey);
+
+      if (!queryRegistrationInfos) {
+        return;
+      }
+
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = queryRegistrationInfos[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var watcher = _step2.value;
+
+          if (watcher.watchableModel === watchableModel) {
+            watcher.onChangeCallback([]);
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    }
+  }, {
+    key: "onLoadKeys",
+    value: function onLoadKeys(watchableModel, watchKeys) {
+      var _iteratorNormalCompletion3 = true;
+      var _didIteratorError3 = false;
+      var _iteratorError3 = undefined;
+
+      try {
+        for (var _iterator3 = watchKeys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          var key = _step3.value;
+
+          this._onChange(watchableModel, key);
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+    }
+  }, {
+    key: "forceUnloadWatchesOnWatchableModel",
+    value: function forceUnloadWatchesOnWatchableModel(watchableModel) {
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
+
+      try {
+        for (var _iterator4 = this._queryRegistrationInfosByWatchKey.values()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var queryRegistrationInfos = _step4.value;
+          var _iteratorNormalCompletion5 = true;
+          var _didIteratorError5 = false;
+          var _iteratorError5 = undefined;
+
+          try {
+            for (var _iterator5 = queryRegistrationInfos[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+              var watcher = _step5.value;
+
+              if (watcher.watchableModel === watchableModel) {
+                this._unwatchFromQueryRegistrationInfoAsync(watcher);
+              }
+            }
+          } catch (err) {
+            _didIteratorError5 = true;
+            _iteratorError5 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                _iterator5.return();
+              }
+            } finally {
+              if (_didIteratorError5) {
+                throw _iteratorError5;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
+      }
+    }
+  }]);
+  return QueryManager;
+}();
+
+exports.QueryManager = QueryManager;