@airtable/blocks 1.9.0 → 1.10.0-experimental-48096ae-20211116

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", (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
+      });
+
+      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;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/models/query_manager.ts"],"names":["QueryManager","sdk","Map","query","querySubscriptionOptions","_airtableInterface","subscribeToQueryAndPopulateStoresAsync","queryResponse","success","blockQueryId","queryIds","queryId","unsubscribeFromQueryId","unsubscribeFromQueryIdsAsync","watchableModel","watchKey","watchOnChangeCallback","callbackForRegistration","context","isOnChangeCallbackCanceled","callbackForCancelOnChange","onChangeCallback","changes","__incrementOnChangeCount","blockQueryIdPromise","fetchAndSubscribeToQueryAsync","queryRegistrationInfosForKey","_queryRegistrationInfosByWatchKey","get","set","push","queryRegistrationInfo","queryRegistrationInfos","watchersToUnwatch","watchersToKeep","forEach","watcher","isCallbackToUnwatch","length","delete","_unwatchFromQueryRegistrationInfoAsync","__airtableInterface","_sdk","watchKeys","key","_onChange","values"],"mappings":"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","sourcesContent":["import {spawnError} from '../error_utils';\nimport {fireAndForgetPromise} from '../private_utils';\nimport {AirtableInterface, BlockQuerySubscriptionOptions} from '../types/airtable_interface';\nimport {\n    BlockQuerySpec,\n    BlockQueryId,\n    BlockQuerySubscriptionOnChangeCallback,\n} from '../types/block_query_spec';\nimport {Sdk} from '../unstable_testing_utils';\nimport Watchable from '../watchable';\n\n/**\n * @internal\n */\ninterface QueryRegistrationInfo {\n    blockQueryIdPromise: Promise<BlockQueryId>;\n    // We have an extra cancellation callback to ensure that an immediate watch + unwatch\n    // without any async gaps properly cancels the request. This is not otherwise possible\n    // because we need to await the blockQueryId in order to cancel it.\n    callbackForCancelOnChange: () => void;\n    // This is the callback that the watch was registered with. This, along with the context\n    // is the unique key used to register this watch.\n    callbackForRegistration: unknown;\n    context: unknown | null | undefined;\n    // This should be called when there is a change (this is frequently a wrapper around\n    // callbackForRegistration that converts the arguments between the two)\n    // This, along with watchableModel, is needed so that we can call the onChangeCallback\n    // from an event within the SDK - eg: on initial load (see onLoadKeys)\n    onChangeCallback: BlockQuerySubscriptionOnChangeCallback;\n    watchableModel: Watchable<any>;\n}\n\n/**\n * This provides a singleton instance which is responsible for all queries sent\n * to PublicAirtableInterface.\n *\n * This can allow looking up queries by queryId.\n *\n * @internal\n */\nexport class QueryManager {\n    _airtableInterface: AirtableInterface;\n    _sdk: Sdk;\n    _queryRegistrationInfosByWatchKey: Map<string, Array<QueryRegistrationInfo>> = new Map();\n\n    constructor(sdk: Sdk) {\n        this._airtableInterface = sdk.__airtableInterface;\n        this._sdk = sdk;\n    }\n    fetchAndSubscribeToQueryAsync = async (\n        query: BlockQuerySpec,\n        querySubscriptionOptions?: BlockQuerySubscriptionOptions,\n    ): Promise<BlockQueryId> => {\n        const queryResponse = await this._airtableInterface.subscribeToQueryAndPopulateStoresAsync(\n            query,\n            querySubscriptionOptions ?? {},\n        );\n\n        if (!queryResponse.success) {\n            // TODO: (#proj-blocks-sdk-record-limits) Determine if we need to handle this error\n            throw spawnError('Subscription to query failed - unhandled error');\n        }\n\n        return queryResponse.blockQueryId;\n    };\n    unsubscribeFromQueryIds = (queryIds: Array<BlockQueryId>): void => {\n        for (const queryId of queryIds) {\n            // TODO: (#proj-blocks-sdk-record-limits) Add support for unsubscribing multiple at the same time\n            this.unsubscribeFromQueryId(queryId);\n        }\n    };\n    unsubscribeFromQueryId = (queryId: BlockQueryId): void => {\n        fireAndForgetPromise(() => this._airtableInterface.unsubscribeFromQueryIdsAsync([queryId]));\n    };\n\n    // TODO: (#proj-blocks-sdk-record-limits) Is this a reason to add back in an array request\n    //  of queries? We generally subscribe to many queries in a tight loop with this signature.\n    /**\n     * This registers a query with a watchable key and a callback to call whenever this query changes.\n     * Of note - callbackForRegistration and context are used only as a referencial equality check\n     * for \"unwatching\" because this is the semantic the consumer of the SDK uses for unwatching\n     */\n    watchWithQuerySpec = (\n        query: BlockQuerySpec,\n        watchableModel: Watchable<any>,\n        watchKey: string,\n        watchOnChangeCallback: BlockQuerySubscriptionOnChangeCallback,\n        callbackForRegistration: Function,\n        context?: unknown | null,\n    ): void => {\n        let isOnChangeCallbackCanceled = false;\n        const callbackForCancelOnChange = () => (isOnChangeCallbackCanceled = true);\n\n        const onChangeCallback: BlockQuerySubscriptionOnChangeCallback = changes => {\n            if (isOnChangeCallbackCanceled) {\n                return;\n            }\n            watchableModel.__incrementOnChangeCount();\n            watchOnChangeCallback(changes);\n        };\n\n        const blockQueryIdPromise = this.fetchAndSubscribeToQueryAsync(query, {\n            onChangeCallback,\n        });\n\n        let queryRegistrationInfosForKey = this._queryRegistrationInfosByWatchKey.get(watchKey);\n        if (!queryRegistrationInfosForKey) {\n            queryRegistrationInfosForKey = [];\n            this._queryRegistrationInfosByWatchKey.set(watchKey, queryRegistrationInfosForKey);\n        }\n        // It is safe to push onto queryRegistrationInfosForKey (vs copying) as long\n        // as we don't release the event loop when we iterate over it, which only\n        // happens in unwatchFromQueryKeys\n        queryRegistrationInfosForKey.push({\n            blockQueryIdPromise,\n            callbackForCancelOnChange,\n            callbackForRegistration,\n            context,\n            onChangeCallback,\n            watchableModel,\n        });\n    };\n\n    _unwatchFromQueryRegistrationInfoAsync = async (\n        queryRegistrationInfo: QueryRegistrationInfo,\n    ): Promise<void> => {\n        const {blockQueryIdPromise, callbackForCancelOnChange} = queryRegistrationInfo;\n        callbackForCancelOnChange();\n        const queryId = await blockQueryIdPromise;\n        this.unsubscribeFromQueryId(queryId);\n    };\n\n    unwatchFromQueryKey = (\n        watchKey: string,\n        callbackForRegistration: Function,\n        context?: unknown | null,\n    ): void => {\n        const queryRegistrationInfos = this._queryRegistrationInfosByWatchKey.get(watchKey);\n        if (queryRegistrationInfos) {\n            const watchersToUnwatch: Array<QueryRegistrationInfo> = [];\n            const watchersToKeep: Array<QueryRegistrationInfo> = [];\n\n            queryRegistrationInfos.forEach(watcher => {\n                const isCallbackToUnwatch =\n                    watcher.callbackForRegistration === callbackForRegistration &&\n                    watcher.context === context;\n                if (isCallbackToUnwatch) {\n                    watchersToUnwatch.push(watcher);\n                } else {\n                    watchersToKeep.push(watcher);\n                }\n            });\n\n            if (watchersToKeep.length > 0) {\n                this._queryRegistrationInfosByWatchKey.set(watchKey, watchersToKeep);\n            } else {\n                this._queryRegistrationInfosByWatchKey.delete(watchKey);\n            }\n\n            if (watchersToUnwatch.length > 0) {\n                // Do not await the response since unwatch is not async\n                watchersToUnwatch.forEach(this._unwatchFromQueryRegistrationInfoAsync);\n            }\n        }\n    };\n\n    _onChange(watchableModel: Watchable<any>, watchKey: string): void {\n        const queryRegistrationInfos = this._queryRegistrationInfosByWatchKey.get(watchKey);\n        if (!queryRegistrationInfos) {\n            return;\n        }\n        for (const watcher of queryRegistrationInfos) {\n            if (watcher.watchableModel === watchableModel) {\n                watcher.onChangeCallback([]);\n            }\n        }\n    }\n\n    onLoadKeys(watchableModel: Watchable<any>, watchKeys: Array<string>): void {\n        for (const key of watchKeys) {\n            this._onChange(watchableModel, key);\n        }\n    }\n\n    forceUnloadWatchesOnWatchableModel(watchableModel: Watchable<any>): void {\n        for (const queryRegistrationInfos of this._queryRegistrationInfosByWatchKey.values()) {\n            for (const watcher of queryRegistrationInfos) {\n                if (watcher.watchableModel === watchableModel) {\n                    this._unwatchFromQueryRegistrationInfoAsync(watcher);\n                }\n            }\n        }\n    }\n}\n"]}