@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/rx-query.js

@@ -0,0 +1,703 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RxQueryBase = void 0;
+exports._getDefaultQuery = _getDefaultQuery;
+exports.createRxQuery = createRxQuery;
+exports.isFindOneByIdQuery = isFindOneByIdQuery;
+exports.isRxQuery = isRxQuery;
+exports.queryCollection = queryCollection;
+exports.tunnelQueryCache = tunnelQueryCache;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _rxjs = require("rxjs");
+var _operators = require("rxjs/operators");
+var _index = require("./plugins/utils/index.js");
+var _rxError = require("./rx-error.js");
+var _hooks = require("./hooks.js");
+var _eventReduce = require("./event-reduce.js");
+var _queryCache = require("./query-cache.js");
+var _rxQueryHelper = require("./rx-query-helper.js");
+var _rxQuerySingleResult = require("./rx-query-single-result.js");
+var _queryCount = 0;
+var newQueryID = function () {
+  return ++_queryCount;
+};
+
+/**
+ * Counter for _lastEnsureEqual.
+ * We only need ordering and zero-check for cache replacement,
+ * so a counter is cheaper than Date.now().
+ */
+var _ensureEqualCount = 0;
+var RxQueryBase = exports.RxQueryBase = /*#__PURE__*/function () {
+  /**
+   * Some stats then are used for debugging and cache replacement policies
+   */
+
+  /**
+   * @performance
+   * Use Date.now() instead of now() for creation time.
+   * The monotonic uniqueness guarantee of now() is not needed here
+   * since _creationTime is only used by the cache replacement policy
+   * for rough lifetime comparisons.
+   */
+
+  // used in the query-cache to determine if the RxQuery can be cleaned up.
+
+  // used to count the subscribers to the query
+
+  /**
+   * Contains the current result state
+   * or null if query has not run yet.
+   */
+
+  function RxQueryBase(op, mangoQuery, collection,
+  // used by some plugins
+  other = {}) {
+    this.id = newQueryID();
+    this._execOverDatabaseCount = 0;
+    this._creationTime = Date.now();
+    this._lastEnsureEqual = 0;
+    this.uncached = false;
+    this.refCount$ = new _rxjs.BehaviorSubject(null);
+    this._result = null;
+    this._latestChangeEvent = -1;
+    this._ensureEqualQueue = _index.PROMISE_RESOLVE_FALSE;
+    this.op = op;
+    this.mangoQuery = mangoQuery;
+    this.collection = collection;
+    this.other = other;
+    if (!mangoQuery) {
+      this.mangoQuery = _getDefaultQuery();
+    }
+
+    /**
+     * @performance
+     * isFindOneByIdQuery is only used by queryCollection()
+     * which is not called for 'count' queries.
+     * Skip the check for count queries to avoid unnecessary work.
+     */
+    if (op === 'count') {
+      this.isFindOneByIdQuery = false;
+    } else {
+      this.isFindOneByIdQuery = isFindOneByIdQuery(this.collection.schema.primaryPath, mangoQuery);
+    }
+  }
+  var _proto = RxQueryBase.prototype;
+  /**
+   * Returns an observable that emits the results
+   * This should behave like an rxjs-BehaviorSubject which means:
+   * - Emit the current result-set on subscribe
+   * - Emit the new result-set when an RxChangeEvent comes in
+   * - Do not emit anything before the first result-set was created (no null)
+   */
+  /**
+   * set the new result-data as result-docs of the query
+   * @param newResultData json-docs that were received from the storage
+   */
+  _proto._setResultData = function _setResultData(newResultData) {
+    if (typeof newResultData === 'undefined') {
+      throw (0, _rxError.newRxError)('QU18', {
+        database: this.collection.database.name,
+        collection: this.collection.name
+      });
+    }
+    if (typeof newResultData === 'number') {
+      this._result = new _rxQuerySingleResult.RxQuerySingleResult(this, [], newResultData);
+      return;
+    } else if (newResultData instanceof Map) {
+      newResultData = Array.from(newResultData.values());
+    }
+    var newQueryResult = new _rxQuerySingleResult.RxQuerySingleResult(this, newResultData, newResultData.length);
+    this._result = newQueryResult;
+  }
+
+  /**
+   * executes the query on the database
+   * @return results-array with document-data
+   */;
+  _proto._execOverDatabase = async function _execOverDatabase(rerunCount = 0) {
+    this._execOverDatabaseCount = this._execOverDatabaseCount + 1;
+    var result;
+
+    /**
+     * @performance
+     * Instead of subscribing to eventBulks$ to detect concurrent writes,
+     * we snapshot the change event counter before and after the query.
+     * If the counter changed, a write happened during execution and
+     * we must re-run the query to ensure correct results.
+     * This avoids the overhead of RxJS Subject subscribe/unsubscribe per query.
+     *
+     * @link https://github.com/pubkey/rxdb/issues/7067
+     */
+    var counterBefore = this.collection._changeEventBuffer.getCounter();
+    if (this.op === 'findByIds') {
+      var ids = (0, _index.ensureNotFalsy)(this.mangoQuery.selector)[this.collection.schema.primaryPath].$in;
+      var docsData = [];
+      var mustBeQueried = [];
+      // first try to fill from docCache
+      for (var i = 0; i < ids.length; i++) {
+        var id = ids[i];
+        var docData = this.collection._docCache.getLatestDocumentDataIfExists(id);
+        if (docData) {
+          if (!docData._deleted) {
+            docsData.push(docData);
+          }
+        } else {
+          mustBeQueried.push(id);
+        }
+      }
+      // everything which was not in docCache must be fetched from the storage
+      if (mustBeQueried.length > 0) {
+        var docs = await this.collection.storageInstance.findDocumentsById(mustBeQueried, false);
+        for (var _i = 0; _i < docs.length; _i++) {
+          docsData.push(docs[_i]);
+        }
+      }
+      result = {
+        result: docsData,
+        counter: this.collection._changeEventBuffer.getCounter()
+      };
+    } else if (this.op === 'count') {
+      var preparedQuery = this.getPreparedQuery();
+      var countResult = await this.collection.storageInstance.count(preparedQuery);
+      if (countResult.mode === 'slow' && !this.collection.database.allowSlowCount) {
+        throw (0, _rxError.newRxError)('QU14', {
+          collection: this.collection,
+          queryObj: this.mangoQuery
+        });
+      } else {
+        result = {
+          result: countResult.count,
+          counter: this.collection._changeEventBuffer.getCounter()
+        };
+      }
+    } else {
+      var queryResult = await queryCollection(this);
+      result = {
+        result: queryResult.docs,
+        counter: queryResult.counter
+      };
+    }
+    if (this.collection._changeEventBuffer.getCounter() !== counterBefore) {
+      await (0, _index.promiseWait)(rerunCount * 20);
+      return this._execOverDatabase(rerunCount + 1);
+    }
+    return result;
+  }
+
+  /**
+   * Execute the query
+   * To have an easier implementations,
+   * just subscribe and use the first result
+   */;
+  _proto.exec = async function exec(throwIfMissing) {
+    if (throwIfMissing && this.op !== 'findOne') {
+      throw (0, _rxError.newRxError)('QU9', {
+        collection: this.collection.name,
+        query: this.mangoQuery,
+        op: this.op
+      });
+    }
+
+    /**
+     * run _ensureEqual() here,
+     * this will make sure that errors in the query which throw inside of the RxStorage,
+     * will be thrown at this execution context and not in the background.
+     */
+    await _ensureEqual(this);
+    var useResult = (0, _index.ensureNotFalsy)(this._result);
+    return useResult.getValue(throwIfMissing);
+  }
+
+  /**
+   * Returns the normalized query.
+   * Caches the result so that multiple calls to
+   * queryMatcher, toString() and getPreparedQuery()
+   * do not have to run the normalization again.
+   * @overwrites itself with the actual value.
+   */;
+  /**
+   * returns a string that is used for equal-comparisons
+   * @overwrites itself with the actual value
+   */
+  _proto.toString = function toString() {
+    var stringObj = (0, _index.sortObject)({
+      op: this.op,
+      query: this.normalizedQuery,
+      other: this.other
+    }, true);
+    var value = JSON.stringify(stringObj);
+    this.toString = () => value;
+    return value;
+  }
+
+  /**
+   * returns the prepared query
+   * which can be sent to the storage instance to query for documents.
+   * @overwrites itself with the actual value.
+   */;
+  _proto.getPreparedQuery = function getPreparedQuery() {
+    var hookInput = {
+      rxQuery: this,
+      // can be mutated by the hooks so we have to deep clone first.
+      mangoQuery: (0, _index.clone)(this.normalizedQuery)
+    };
+    hookInput.mangoQuery.selector._deleted = {
+      $eq: false
+    };
+    if (hookInput.mangoQuery.index) {
+      hookInput.mangoQuery.index.unshift('_deleted');
+    }
+    (0, _hooks.runPluginHooks)('prePrepareQuery', hookInput);
+    var value = (0, _rxQueryHelper.prepareQuery)(this.collection.schema.jsonSchema, hookInput.mangoQuery);
+    this.getPreparedQuery = () => value;
+    return value;
+  }
+
+  /**
+   * returns true if the document matches the query,
+   * does not use the 'skip' and 'limit'
+   */;
+  _proto.doesDocumentDataMatch = function doesDocumentDataMatch(docData) {
+    // if doc is deleted, it cannot match
+    if (docData._deleted) {
+      return false;
+    }
+    return this.queryMatcher(docData);
+  }
+
+  /**
+   * deletes all found documents
+   * @return promise with deleted documents
+   */;
+  _proto.remove = async function remove() {
+    var docs = await this.exec();
+    if (Array.isArray(docs)) {
+      var result = await this.collection.bulkRemove(docs);
+      if (result.error.length > 0) {
+        throw (0, _rxError.rxStorageWriteErrorToRxError)(result.error[0]);
+      } else {
+        return result.success;
+      }
+    } else {
+      return docs.remove();
+    }
+  };
+  _proto.incrementalRemove = function incrementalRemove() {
+    return (0, _rxQueryHelper.runQueryUpdateFunction)(this.asRxQuery, doc => doc.incrementalRemove());
+  }
+
+  /**
+   * helper function to transform RxQueryBase to RxQuery type
+   */;
+  /**
+   * updates all found documents
+   * @overwritten by plugin (optional)
+   */
+  _proto.update = function update(_updateObj) {
+    throw (0, _index.pluginMissing)('update');
+  };
+  _proto.patch = function patch(_patch) {
+    return (0, _rxQueryHelper.runQueryUpdateFunction)(this.asRxQuery, doc => doc.patch(_patch));
+  };
+  _proto.incrementalPatch = function incrementalPatch(patch) {
+    return (0, _rxQueryHelper.runQueryUpdateFunction)(this.asRxQuery, doc => doc.incrementalPatch(patch));
+  };
+  _proto.modify = function modify(mutationFunction) {
+    return (0, _rxQueryHelper.runQueryUpdateFunction)(this.asRxQuery, doc => doc.modify(mutationFunction));
+  };
+  _proto.incrementalModify = function incrementalModify(mutationFunction) {
+    return (0, _rxQueryHelper.runQueryUpdateFunction)(this.asRxQuery, doc => doc.incrementalModify(mutationFunction));
+  }
+
+  // we only set some methods of query-builder here
+  // because the others depend on these ones
+;
+  _proto.where = function where(_queryObj) {
+    throw (0, _index.pluginMissing)('query-builder');
+  };
+  _proto.sort = function sort(_params) {
+    throw (0, _index.pluginMissing)('query-builder');
+  };
+  _proto.skip = function skip(_amount) {
+    throw (0, _index.pluginMissing)('query-builder');
+  };
+  _proto.limit = function limit(_amount) {
+    throw (0, _index.pluginMissing)('query-builder');
+  };
+  return (0, _createClass2.default)(RxQueryBase, [{
+    key: "$",
+    get: function () {
+      if (!this._$) {
+        var results$ = this.collection.eventBulks$.pipe(
+        /**
+         * Performance shortcut.
+         * Changes to local documents are not relevant for the query.
+         */
+        (0, _operators.filter)(bulk => !bulk.isLocal),
+        /**
+         * Start once to ensure the querying also starts
+         * when there where no changes.
+         */
+        (0, _operators.startWith)(null),
+        // ensure query results are up to date.
+        (0, _operators.mergeMap)(() => _ensureEqual(this)),
+        // use the current result set, written by _ensureEqual().
+        (0, _operators.map)(() => this._result),
+        // do not run stuff above for each new subscriber, only once.
+        (0, _operators.shareReplay)(_index.RXJS_SHARE_REPLAY_DEFAULTS),
+        // do not proceed if result set has not changed.
+        (0, _operators.distinctUntilChanged)((prev, curr) => {
+          if (prev && prev.time === (0, _index.ensureNotFalsy)(curr).time) {
+            return true;
+          } else {
+            return false;
+          }
+        }), (0, _operators.filter)(result => !!result),
+        /**
+         * Map the result set to a single RxDocument or an array,
+         * depending on query type
+         */
+        (0, _operators.map)(result => {
+          return (0, _index.ensureNotFalsy)(result).getValue();
+        }));
+        this._$ = (0, _rxjs.merge)(results$,
+        /**
+         * Also add the refCount$ to the query observable
+         * to allow us to count the amount of subscribers.
+         */
+        this.refCount$.pipe((0, _operators.filter)(() => false)));
+      }
+      return this._$;
+    }
+  }, {
+    key: "$$",
+    get: function () {
+      var reactivity = this.collection.database.getReactivityFactory();
+      return reactivity.fromObservable(this.$, undefined, this.collection.database);
+    }
+
+    // stores the changeEvent-number of the last handled change-event
+
+    /**
+     * ensures that the exec-runs
+     * are not run in parallel
+     */
+  }, {
+    key: "normalizedQuery",
+    get: function () {
+      return (0, _index.overwriteGetterForCaching)(this, 'normalizedQuery', (0, _rxQueryHelper.normalizeMangoQuery)(this.collection.schema.jsonSchema, this.mangoQuery, this.op === 'count'));
+    }
+
+    /**
+     * cached call to get the queryMatcher
+     * @overwrites itself with the actual value
+     */
+  }, {
+    key: "queryMatcher",
+    get: function () {
+      var schema = this.collection.schema.jsonSchema;
+      return (0, _index.overwriteGetterForCaching)(this, 'queryMatcher', (0, _rxQueryHelper.getQueryMatcher)(schema, this.normalizedQuery));
+    }
+  }, {
+    key: "asRxQuery",
+    get: function () {
+      return this;
+    }
+  }]);
+}();
+function _getDefaultQuery() {
+  return {
+    selector: {}
+  };
+}
+
+/**
+ * run this query through the QueryCache
+ */
+function tunnelQueryCache(rxQuery) {
+  return rxQuery.collection._queryCache.getByQuery(rxQuery);
+}
+function createRxQuery(op, queryObj, collection, other) {
+  (0, _hooks.runPluginHooks)('preCreateRxQuery', {
+    op,
+    queryObj,
+    collection,
+    other
+  });
+  var ret = new RxQueryBase(op, queryObj, collection, other);
+
+  // ensure when created with same params, only one is created
+  ret = tunnelQueryCache(ret);
+  (0, _queryCache.triggerCacheReplacement)(collection);
+  return ret;
+}
+
+/**
+ * Check if the current results-state is in sync with the database
+ * which means that no write event happened since the last run.
+ * @return false if not which means it should re-execute
+ */
+function _isResultsInSync(rxQuery) {
+  var currentLatestEventNumber = rxQuery.asRxQuery.collection._changeEventBuffer.getCounter();
+  if (rxQuery._latestChangeEvent >= currentLatestEventNumber) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * wraps __ensureEqual()
+ * to ensure it does not run in parallel
+ * @return true if has changed, false if not
+ *
+ * @performance
+ * Avoid async wrapper when awaitBeforeReads is empty (common case).
+ * This eliminates one unnecessary Promise allocation per query execution.
+ */
+function _ensureEqual(rxQuery) {
+  if (rxQuery.collection.awaitBeforeReads.size > 0) {
+    return Promise.all(Array.from(rxQuery.collection.awaitBeforeReads).map(fn => fn())).then(() => {
+      rxQuery._ensureEqualQueue = rxQuery._ensureEqualQueue.then(() => __ensureEqual(rxQuery));
+      return rxQuery._ensureEqualQueue;
+    });
+  }
+  rxQuery._ensureEqualQueue = rxQuery._ensureEqualQueue.then(() => __ensureEqual(rxQuery));
+  return rxQuery._ensureEqualQueue;
+}
+
+/**
+ * ensures that the results of this query is equal to the results which a query over the database would give
+ * @return true if results have changed
+ */
+function __ensureEqual(rxQuery) {
+  /**
+   * @performance
+   * Use a counter instead of Date.now() since _lastEnsureEqual
+   * is only used by the cache replacement policy for sorting queries
+   * by last usage and zero-check, not for time-based comparison.
+   */
+  rxQuery._lastEnsureEqual = ++_ensureEqualCount;
+
+  /**
+   * Optimisation shortcuts
+   */
+  if (
+  // db is closed
+  rxQuery.collection.database.closed ||
+  // nothing happened since last run
+  _isResultsInSync(rxQuery)) {
+    return _index.PROMISE_RESOLVE_FALSE;
+  }
+  var ret = false;
+  var mustReExec = false; // if this becomes true, a whole execution over the database is made
+  if (rxQuery._latestChangeEvent === -1) {
+    // have not executed yet -> must run
+    mustReExec = true;
+  }
+
+  /**
+   * try to use EventReduce to calculate the new results
+   */
+  if (!mustReExec) {
+    var missedChangeEvents = rxQuery.asRxQuery.collection._changeEventBuffer.getFrom(rxQuery._latestChangeEvent + 1);
+    if (missedChangeEvents === null) {
+      // changeEventBuffer is of bounds -> we must re-execute over the database
+      mustReExec = true;
+    } else {
+      rxQuery._latestChangeEvent = rxQuery.asRxQuery.collection._changeEventBuffer.getCounter();
+      var runChangeEvents = rxQuery.asRxQuery.collection._changeEventBuffer.reduceByLastOfDoc(missedChangeEvents);
+      if (rxQuery.op === 'count') {
+        // 'count' query
+        var previousCount = (0, _index.ensureNotFalsy)(rxQuery._result).count;
+        var newCount = previousCount;
+        runChangeEvents.forEach(cE => {
+          var didMatchBefore = cE.previousDocumentData && rxQuery.doesDocumentDataMatch(cE.previousDocumentData);
+          var doesMatchNow = rxQuery.doesDocumentDataMatch(cE.documentData);
+          if (!didMatchBefore && doesMatchNow) {
+            newCount++;
+          }
+          if (didMatchBefore && !doesMatchNow) {
+            newCount--;
+          }
+        });
+        if (newCount !== previousCount) {
+          ret = true; // true because results changed
+          rxQuery._setResultData(newCount);
+        }
+      } else {
+        // 'find' or 'findOne' query
+        var eventReduceResult = (0, _eventReduce.calculateNewResults)(rxQuery, runChangeEvents);
+        if (eventReduceResult.runFullQueryAgain) {
+          // could not calculate the new results, execute must be done
+          mustReExec = true;
+        } else if (eventReduceResult.changed) {
+          // we got the new results, we do not have to re-execute, mustReExec stays false
+          ret = true; // true because results changed
+          rxQuery._setResultData(eventReduceResult.newResults);
+        }
+      }
+    }
+  }
+
+  // oh no we have to re-execute the whole query over the database
+  if (mustReExec) {
+    return rxQuery._execOverDatabase().then(result => {
+      var newResultData = result.result;
+
+      /**
+       * The RxStorage is defined to always first emit events and then return
+       * on bulkWrite() calls. So here we have to use the counter AFTER the execOverDatabase()
+       * has been run, not the one from before.
+       */
+      rxQuery._latestChangeEvent = result.counter;
+
+      // A count query needs a different has-changed check.
+      if (typeof newResultData === 'number') {
+        if (!rxQuery._result || newResultData !== rxQuery._result.count) {
+          ret = true;
+          rxQuery._setResultData(newResultData);
+        }
+        return ret;
+      }
+      if (!rxQuery._result || !(0, _index.areRxDocumentArraysEqual)(rxQuery.collection.schema.primaryPath, newResultData, rxQuery._result.docsData)) {
+        ret = true; // true because results changed
+        rxQuery._setResultData(newResultData);
+      }
+      return ret;
+    });
+  }
+  return Promise.resolve(ret); // true if results have changed
+}
+
+/**
+ * Runs the query over the storage instance
+ * of the collection.
+ * Does some optimizations to ensure findById is used
+ * when specific queries are used.
+ */
+async function queryCollection(rxQuery) {
+  var docs = [];
+  var collection = rxQuery.collection;
+
+  /**
+   * Optimizations shortcut.
+   * If query is find-one-document-by-id,
+   * then we do not have to use the slow query() method
+   * but instead can use findDocumentsById()
+   */
+  if (rxQuery.isFindOneByIdQuery) {
+    var selector = rxQuery.mangoQuery.selector;
+    var primaryPath = collection.schema.primaryPath;
+    // isFindOneByIdQuery guarantees the primary key is in the selector
+    var primarySelectorValue = selector ? selector[primaryPath] : undefined;
+
+    // Check if there are extra operators on the primary key selector (e.g. $ne alongside $in)
+    var hasExtraOperators = typeof primarySelectorValue === 'object' && primarySelectorValue !== null && Object.keys(primarySelectorValue).length > 1;
+
+    // Check if there are selectors OTHER than the primary key
+    var hasOtherSelectors = selector ? Object.keys(selector).length > 1 : false;
+
+    // Normalize single ID to array and de-duplicate to avoid returning the same document multiple times
+    var docIdArray = Array.isArray(rxQuery.isFindOneByIdQuery) ? rxQuery.isFindOneByIdQuery : [rxQuery.isFindOneByIdQuery];
+    var docIds = Array.from(new Set(docIdArray));
+
+    // Separate cache hits from storage misses
+    var cacheMisses = [];
+    docIds.forEach(docId => {
+      var docData = rxQuery.collection._docCache.getLatestDocumentDataIfExists(docId);
+      if (docData && !docData._deleted) {
+        docs.push(docData);
+      } else if (!docData) {
+        // Only fetch from storage if not in cache
+        cacheMisses.push(docId);
+      }
+      // If found but deleted, skip entirely (no refetch)
+    });
+
+    // Fetch only cache misses from storage
+    if (cacheMisses.length > 0) {
+      var docsFromStorage = await collection.storageInstance.findDocumentsById(cacheMisses, false);
+      docs = docs.concat(docsFromStorage);
+    }
+
+    // Apply query matcher if there are extra operators or other selectors
+    if (hasExtraOperators || hasOtherSelectors) {
+      docs = docs.filter(doc => rxQuery.queryMatcher(doc));
+    }
+
+    /**
+     * The findDocumentsById() fast-path also does not apply `skip`/`limit`/`sort`.
+     * To keep behavior consistent with storageInstance.query(), we must
+     * apply them after queryMatcher for both find() and findOne() queries.
+     */
+    // Apply sorting for both find and findOne
+    if (docs.length > 1) {
+      var preparedQuery = rxQuery.getPreparedQuery();
+      var sortComparator = (0, _rxQueryHelper.getSortComparator)(collection.schema.jsonSchema, preparedQuery.query);
+      docs = docs.sort(sortComparator);
+    }
+
+    // Apply skip for both find and findOne
+    var skip = typeof rxQuery.mangoQuery.skip === 'number' && rxQuery.mangoQuery.skip > 0 ? rxQuery.mangoQuery.skip : 0;
+    if (skip > 0) {
+      docs = docs.slice(skip);
+    }
+
+    // Apply limit for both find and findOne
+    var limitIsNumber = typeof rxQuery.mangoQuery.limit === 'number' && rxQuery.mangoQuery.limit > 0;
+    if (limitIsNumber) {
+      var limit = rxQuery.mangoQuery.limit;
+      docs = docs.slice(0, limit);
+    }
+  } else {
+    var _preparedQuery = rxQuery.getPreparedQuery();
+    var queryResult = await collection.storageInstance.query(_preparedQuery);
+    docs = queryResult.documents;
+  }
+  return {
+    docs,
+    counter: collection._changeEventBuffer.getCounter()
+  };
+}
+
+/**
+ * Returns true if the given query
+ * selects documents by primary key using $eq or $in.
+ * Used to optimize performance: these queries use get-by-id
+ * instead of a full index scan. Additional operators beyond
+ * $eq/$in are handled via the queryMatcher after fetching.
+ * Skip, limit, and sort are also applied after fetching.
+ * Returns false if no such optimization is possible.
+ * Returns the document id (string) or ids (string[]) otherwise.
+ */
+function isFindOneByIdQuery(primaryPath, query) {
+  // primary key constraint can coexist with other selectors, skip, limit, and sort
+  // The optimization will fetch by ID, then apply queryMatcher, sort, skip, and limit
+  // Use hasOwnProperty to avoid prototype pollution from user-controlled input
+  if (query.selector && Object.prototype.hasOwnProperty.call(query.selector, primaryPath)) {
+    var value = query.selector[primaryPath];
+    if (typeof value === 'string') {
+      return value;
+    } else if (typeof value.$eq === 'string') {
+      return value.$eq;
+    }
+
+    // same with $in string arrays
+    if (Array.isArray(value.$in) &&
+    // must only contain strings
+    !value.$in.find(r => typeof r !== 'string')) {
+      return value.$in;
+    }
+  }
+  return false;
+}
+function isRxQuery(obj) {
+  return obj instanceof RxQueryBase;
+}
+//# sourceMappingURL=rx-query.js.map