@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/doc-cache.js

@@ -0,0 +1,231 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DocumentCache = void 0;
+exports.mapDocumentsDataToCacheDocs = mapDocumentsDataToCacheDocs;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _index2 = require("./plugins/utils/index.js");
+var _overwritable = require("./overwritable.js");
+/**
+ * Because we have to create many cache items,
+ * we use an array instead of an object with properties
+ * for better performance and less memory usage.
+ * @link https://stackoverflow.com/questions/17295056/array-vs-object-efficiency-in-javascript
+ */
+/**
+ * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+ */
+/**
+ * The DocumentCache stores RxDocument objects
+ * by their primary key and revision.
+ * This is useful on client side applications where
+ * it is not known how much memory can be used, so
+ * we de-duplicate RxDocument states to save memory.
+ * To not fill up the memory with old document states, the DocumentCache
+ * only contains weak references to the RxDocuments themself.
+ * @link https://caniuse.com/?search=weakref
+ */
+var DocumentCache = exports.DocumentCache = /*#__PURE__*/function () {
+  /**
+   * Process stuff lazy to not block the CPU
+   * on critical paths.
+   */
+
+  /**
+   * Some JavaScript runtimes like QuickJS,
+   * so not have a FinalizationRegistry or WeakRef.
+   * Therefore we need a workaround which might waste a lot of memory,
+   * but at least works.
+   */
+
+  function DocumentCache(primaryPath, changes$,
+  /**
+   * A method that can create a RxDocument by the given document data.
+   */
+  documentCreator) {
+    this.cacheItemByDocId = new Map();
+    this.tasks = new Set();
+    this.registry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(docMeta => {
+      var docId = docMeta.docId;
+      var cacheItem = this.cacheItemByDocId.get(docId);
+      if (cacheItem) {
+        cacheItem[0].delete(docMeta.revisionHeight + docMeta.lwt + '');
+        if (cacheItem[0].size === 0) {
+          /**
+           * No state of the document is cached anymore,
+           * so we can clean up.
+           */
+          this.cacheItemByDocId.delete(docId);
+        }
+      }
+    }) : undefined;
+    this.primaryPath = primaryPath;
+    this.changes$ = changes$;
+    this.documentCreator = documentCreator;
+    changes$.subscribe(events => {
+      this.tasks.add(() => {
+        var cacheItemByDocId = this.cacheItemByDocId;
+        for (var index = 0; index < events.length; index++) {
+          var event = events[index];
+          var cacheItem = cacheItemByDocId.get(event.documentId);
+          if (cacheItem) {
+            var documentData = event.documentData;
+            if (!documentData) {
+              documentData = event.previousDocumentData;
+            }
+            cacheItem[1] = documentData;
+          }
+        }
+      });
+      if (this.tasks.size <= 1) {
+        (0, _index2.requestIdlePromiseNoQueue)().then(() => {
+          this.processTasks();
+        });
+      }
+    });
+  }
+  var _proto = DocumentCache.prototype;
+  _proto.processTasks = function processTasks() {
+    if (this.tasks.size === 0) {
+      return;
+    }
+    var tasks = Array.from(this.tasks);
+    tasks.forEach(task => task());
+    this.tasks.clear();
+  }
+
+  /**
+   * Get the RxDocument from the cache
+   * and create a new one if not exits before.
+   * @overwrites itself with the actual function
+   * because this is @performance relevant.
+   * It is called on each document row for each write and read.
+   */;
+  /**
+   * Throws if not exists
+   */
+  _proto.getLatestDocumentData = function getLatestDocumentData(docId) {
+    this.processTasks();
+    var cacheItem = (0, _index2.getFromMapOrThrow)(this.cacheItemByDocId, docId);
+    return cacheItem[1];
+  };
+  _proto.getLatestDocumentDataIfExists = function getLatestDocumentDataIfExists(docId) {
+    this.processTasks();
+    var cacheItem = this.cacheItemByDocId.get(docId);
+    if (cacheItem) {
+      return cacheItem[1];
+    }
+  };
+  return (0, _createClass2.default)(DocumentCache, [{
+    key: "getCachedRxDocuments",
+    get: function () {
+      var fn = getCachedRxDocumentMonad(this);
+      return (0, _index2.overwriteGetterForCaching)(this, 'getCachedRxDocuments', fn);
+    }
+  }, {
+    key: "getCachedRxDocument",
+    get: function () {
+      var fn = getCachedRxDocumentMonad(this);
+      return (0, _index2.overwriteGetterForCaching)(this, 'getCachedRxDocument', doc => fn([doc])[0]);
+    }
+  }]);
+}();
+/**
+ * This function is called very very often.
+ * @hotPath This is one of the most important methods for performance.
+ * It is used in many places to transform the raw document data into RxDocuments.
+ */
+function getCachedRxDocumentMonad(docCache) {
+  var primaryPath = docCache.primaryPath;
+  var cacheItemByDocId = docCache.cacheItemByDocId;
+  var registry = docCache.registry;
+  var deepFreezeWhenDevMode = _overwritable.overwritable.deepFreezeWhenDevMode;
+  var documentCreator = docCache.documentCreator;
+  var fn = docsData => {
+    var ret = new Array(docsData.length);
+    var registryTasks = [];
+    for (var index = 0; index < docsData.length; index++) {
+      var docData = docsData[index];
+      var docId = docData[primaryPath];
+      var revisionHeight = (0, _index2.getHeightOfRevision)(docData._rev);
+
+      /**
+       * @performance
+       * Compute the byRev cache key once and reuse it
+       * for both the Map.get() and Map.set() calls.
+       */
+      var cacheKey = revisionHeight + docData._meta.lwt + '';
+      var byRev = void 0;
+      var cachedRxDocumentWeakRef = void 0;
+      var cacheItem = cacheItemByDocId.get(docId);
+      if (!cacheItem) {
+        byRev = new Map();
+        cacheItem = [byRev, docData];
+        cacheItemByDocId.set(docId, cacheItem);
+      } else {
+        byRev = cacheItem[0];
+        cachedRxDocumentWeakRef = byRev.get(cacheKey);
+      }
+      var cachedRxDocument = cachedRxDocumentWeakRef ? cachedRxDocumentWeakRef.deref() : undefined;
+      if (!cachedRxDocument) {
+        docData = deepFreezeWhenDevMode(docData);
+        cachedRxDocument = documentCreator(docData);
+        byRev.set(cacheKey, createWeakRefWithFallback(cachedRxDocument));
+        if (registry) {
+          registryTasks.push(cachedRxDocument);
+        }
+      }
+      ret[index] = cachedRxDocument;
+    }
+    if (registryTasks.length > 0 && registry) {
+      /**
+       * Calling registry.register() has shown to have
+       * really bad performance. So we add the cached documents
+       * lazily.
+       */
+      docCache.tasks.add(() => {
+        for (var _index = 0; _index < registryTasks.length; _index++) {
+          var doc = registryTasks[_index];
+          registry.register(doc, {
+            docId: doc.primary,
+            revisionHeight: (0, _index2.getHeightOfRevision)(doc.revision),
+            lwt: doc._data._meta.lwt
+          });
+        }
+      });
+      if (docCache.tasks.size <= 1) {
+        (0, _index2.requestIdlePromiseNoQueue)().then(() => {
+          docCache.processTasks();
+        });
+      }
+    }
+    return ret;
+  };
+  return fn;
+}
+function mapDocumentsDataToCacheDocs(docCache, docsData) {
+  var getCachedRxDocuments = docCache.getCachedRxDocuments;
+  return getCachedRxDocuments(docsData);
+}
+
+/**
+ * Fallback for JavaScript runtimes that do not support WeakRef.
+ * The fallback will keep the items in cache forever,
+ * but at least works.
+ */
+var HAS_WEAK_REF = typeof WeakRef === 'function';
+var createWeakRefWithFallback = HAS_WEAK_REF ? createWeakRef : createWeakRefFallback;
+function createWeakRef(obj) {
+  return new WeakRef(obj);
+}
+function createWeakRefFallback(obj) {
+  return {
+    deref() {
+      return obj;
+    }
+  };
+}
+//# sourceMappingURL=doc-cache.js.map

package/dist/cjs/doc-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-cache.js","names":["_index2","require","_overwritable","DocumentCache","exports","primaryPath","changes$","documentCreator","cacheItemByDocId","Map","tasks","Set","registry","FinalizationRegistry","docMeta","docId","cacheItem","get","delete","revisionHeight","lwt","size","undefined","subscribe","events","add","index","length","event","documentId","documentData","previousDocumentData","requestIdlePromiseNoQueue","then","processTasks","_proto","prototype","Array","from","forEach","task","clear","getLatestDocumentData","getFromMapOrThrow","getLatestDocumentDataIfExists","_createClass2","default","key","fn","getCachedRxDocumentMonad","overwriteGetterForCaching","doc","docCache","deepFreezeWhenDevMode","overwritable","docsData","ret","registryTasks","docData","getHeightOfRevision","_rev","cacheKey","_meta","byRev","cachedRxDocumentWeakRef","set","cachedRxDocument","deref","createWeakRefWithFallback","push","register","primary","revision","_data","mapDocumentsDataToCacheDocs","getCachedRxDocuments","HAS_WEAK_REF","WeakRef","createWeakRef","createWeakRefFallback","obj"],"sources":["../../src/doc-cache.ts"],"sourcesContent":["import type {\r\n    RxDocument,\r\n    RxDocumentData,\r\n    RxStorageChangeEvent,\r\n    WeakRef,\r\n    FinalizationRegistry\r\n} from './types/index.d.ts';\r\nimport {\r\n    getFromMapOrThrow,\r\n    getHeightOfRevision,\r\n    overwriteGetterForCaching,\r\n    requestIdlePromiseNoQueue\r\n} from './plugins/utils/index.ts';\r\nimport {\r\n    overwritable\r\n} from './overwritable.ts';\r\nimport { Observable } from 'rxjs';\r\n\r\n/**\r\n * Because we have to create many cache items,\r\n * we use an array instead of an object with properties\r\n * for better performance and less memory usage.\r\n * @link https://stackoverflow.com/questions/17295056/array-vs-object-efficiency-in-javascript\r\n */\r\ndeclare type CacheItem<RxDocType, OrmMethods> = [\r\n    /**\r\n     * Store the different document states of time\r\n     * based on their [revisionHeight+_meta.lwt] .\r\n     * We store WeakRefs so that we can later clean up\r\n     * document states that are no longer needed.\r\n     *\r\n     * Notice that we can not only rely on the revisionHeight\r\n     * because when cleanup is used, two document states can end up with\r\n     * the same revision but different _meta.lwt.\r\n     */\r\n    Map<string, WeakRef<RxDocument<RxDocType, OrmMethods>>>,\r\n\r\n    /**\r\n     * Store the latest known document state.\r\n     * As long as any state of the document is in the cache,\r\n     * we observe the changestream and update the latestDoc accordingly.\r\n     * This makes it easier to optimize performance on other parts\r\n     * because for each known document we can always get the current state\r\n     * in the storage.\r\n     * Also it makes it possible to call RxDocument.latest() in a non-async way\r\n     * to retrieve the latest document state or to observe$ some property.\r\n     *\r\n     * To not prevent the whole cacheItem from being garbage collected,\r\n     * we store only the document data here, but not the RxDocument.\r\n     */\r\n    RxDocumentData<RxDocType>\r\n];\r\n\r\n\r\n/**\r\n * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry\r\n */\r\ndeclare type FinalizationRegistryValue = {\r\n    docId: string;\r\n    revisionHeight: number;\r\n    lwt: number;\r\n};\r\n\r\n/**\r\n * The DocumentCache stores RxDocument objects\r\n * by their primary key and revision.\r\n * This is useful on client side applications where\r\n * it is not known how much memory can be used, so\r\n * we de-duplicate RxDocument states to save memory.\r\n * To not fill up the memory with old document states, the DocumentCache\r\n * only contains weak references to the RxDocuments themself.\r\n * @link https://caniuse.com/?search=weakref\r\n */\r\nexport class DocumentCache<RxDocType, OrmMethods> {\r\n    public readonly cacheItemByDocId = new Map<string, CacheItem<RxDocType, OrmMethods>>();\r\n\r\n    /**\r\n     * Process stuff lazy to not block the CPU\r\n     * on critical paths.\r\n     */\r\n    public readonly tasks = new Set<Function>();\r\n\r\n    /**\r\n     * Some JavaScript runtimes like QuickJS,\r\n     * so not have a FinalizationRegistry or WeakRef.\r\n     * Therefore we need a workaround which might waste a lot of memory,\r\n     * but at least works.\r\n     */\r\n    public readonly registry?: FinalizationRegistry<FinalizationRegistryValue> = typeof FinalizationRegistry === 'function' ?\r\n        new FinalizationRegistry<FinalizationRegistryValue>(docMeta => {\r\n            const docId = docMeta.docId;\r\n            const cacheItem = this.cacheItemByDocId.get(docId);\r\n            if (cacheItem) {\r\n                cacheItem[0].delete(docMeta.revisionHeight + docMeta.lwt + '');\r\n                if (cacheItem[0].size === 0) {\r\n                    /**\r\n                     * No state of the document is cached anymore,\r\n                     * so we can clean up.\r\n                     */\r\n                    this.cacheItemByDocId.delete(docId);\r\n                }\r\n            }\r\n        }) as any :\r\n        undefined;\r\n\r\n    constructor(\r\n        public readonly primaryPath: string,\r\n        public readonly changes$: Observable<RxStorageChangeEvent<RxDocType>[]>,\r\n        /**\r\n         * A method that can create a RxDocument by the given document data.\r\n         */\r\n        public documentCreator: (docData: RxDocumentData<RxDocType>) => RxDocument<RxDocType, OrmMethods>\r\n    ) {\r\n        changes$.subscribe((events: RxStorageChangeEvent<RxDocType>[]) => {\r\n            this.tasks.add(() => {\r\n                const cacheItemByDocId = this.cacheItemByDocId;\r\n                for (let index = 0; index < events.length; index++) {\r\n                    const event = events[index];\r\n                    const cacheItem = cacheItemByDocId.get(event.documentId);\r\n                    if (cacheItem) {\r\n                        let documentData = event.documentData;\r\n                        if (!documentData) {\r\n                            documentData = event.previousDocumentData as any;\r\n                        }\r\n                        cacheItem[1] = documentData;\r\n                    }\r\n                }\r\n            });\r\n            if (this.tasks.size <= 1) {\r\n                requestIdlePromiseNoQueue().then(() => {\r\n                    this.processTasks();\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n    public processTasks() {\r\n        if (this.tasks.size === 0) {\r\n            return;\r\n        }\r\n        const tasks = Array.from(this.tasks);\r\n        tasks.forEach(task => task());\r\n        this.tasks.clear();\r\n    }\r\n\r\n    /**\r\n     * Get the RxDocument from the cache\r\n     * and create a new one if not exits before.\r\n     * @overwrites itself with the actual function\r\n     * because this is @performance relevant.\r\n     * It is called on each document row for each write and read.\r\n     */\r\n    get getCachedRxDocuments(): (docsData: RxDocumentData<RxDocType>[]) => RxDocument<RxDocType, OrmMethods>[] {\r\n        const fn = getCachedRxDocumentMonad(this);\r\n        return overwriteGetterForCaching(\r\n            this,\r\n            'getCachedRxDocuments',\r\n            fn\r\n        );\r\n    }\r\n\r\n    get getCachedRxDocument(): (docData: RxDocumentData<RxDocType>) => RxDocument<RxDocType, OrmMethods> {\r\n        const fn = getCachedRxDocumentMonad(this);\r\n        return overwriteGetterForCaching(\r\n            this,\r\n            'getCachedRxDocument',\r\n            doc => fn([doc])[0]\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Throws if not exists\r\n     */\r\n    public getLatestDocumentData(docId: string): RxDocumentData<RxDocType> {\r\n        this.processTasks();\r\n        const cacheItem = getFromMapOrThrow(this.cacheItemByDocId, docId);\r\n        return cacheItem[1];\r\n    }\r\n\r\n    public getLatestDocumentDataIfExists(docId: string): RxDocumentData<RxDocType> | undefined {\r\n        this.processTasks();\r\n        const cacheItem = this.cacheItemByDocId.get(docId);\r\n        if (cacheItem) {\r\n            return cacheItem[1];\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * This function is called very very often.\r\n * @hotPath This is one of the most important methods for performance.\r\n * It is used in many places to transform the raw document data into RxDocuments.\r\n */\r\nfunction getCachedRxDocumentMonad<RxDocType, OrmMethods>(\r\n    docCache: DocumentCache<RxDocType, OrmMethods>\r\n): (docsData: RxDocumentData<RxDocType>[]) => RxDocument<RxDocType, OrmMethods>[] {\r\n    const primaryPath = docCache.primaryPath;\r\n    const cacheItemByDocId = docCache.cacheItemByDocId;\r\n    const registry = docCache.registry;\r\n    const deepFreezeWhenDevMode = overwritable.deepFreezeWhenDevMode;\r\n    const documentCreator = docCache.documentCreator;\r\n    const fn: (docsData: RxDocumentData<RxDocType>[]) => RxDocument<RxDocType, OrmMethods>[] = (docsData: RxDocumentData<RxDocType>[]) => {\r\n        const ret: RxDocument<RxDocType, OrmMethods>[] = new Array(docsData.length);\r\n        const registryTasks: RxDocument<RxDocType, OrmMethods>[] = [];\r\n        for (let index = 0; index < docsData.length; index++) {\r\n            let docData = docsData[index];\r\n            const docId: string = (docData as any)[primaryPath];\r\n\r\n            const revisionHeight = getHeightOfRevision(docData._rev);\r\n\r\n            /**\r\n             * @performance\r\n             * Compute the byRev cache key once and reuse it\r\n             * for both the Map.get() and Map.set() calls.\r\n             */\r\n            const cacheKey = revisionHeight + docData._meta.lwt + '';\r\n\r\n            let byRev: Map<string, WeakRef<RxDocument<RxDocType, OrmMethods>>>;\r\n            let cachedRxDocumentWeakRef: WeakRef<RxDocument<RxDocType, OrmMethods>> | undefined;\r\n            let cacheItem = cacheItemByDocId.get(docId);\r\n            if (!cacheItem) {\r\n                byRev = new Map();\r\n                cacheItem = [\r\n                    byRev,\r\n                    docData\r\n                ];\r\n                cacheItemByDocId.set(docId, cacheItem);\r\n            } else {\r\n                byRev = cacheItem[0];\r\n                cachedRxDocumentWeakRef = byRev.get(cacheKey);\r\n            }\r\n            let cachedRxDocument = cachedRxDocumentWeakRef ? cachedRxDocumentWeakRef.deref() : undefined;\r\n            if (!cachedRxDocument) {\r\n                docData = deepFreezeWhenDevMode(docData) as any;\r\n                cachedRxDocument = documentCreator(docData) as RxDocument<RxDocType, OrmMethods>;\r\n                byRev.set(cacheKey, createWeakRefWithFallback(cachedRxDocument));\r\n                if (registry) {\r\n                    registryTasks.push(cachedRxDocument);\r\n                }\r\n            }\r\n            ret[index] = cachedRxDocument;\r\n        }\r\n        if (registryTasks.length > 0 && registry) {\r\n            /**\r\n             * Calling registry.register() has shown to have\r\n             * really bad performance. So we add the cached documents\r\n             * lazily.\r\n             */\r\n            docCache.tasks.add(() => {\r\n                for (let index = 0; index < registryTasks.length; index++) {\r\n                    const doc = registryTasks[index];\r\n                    registry.register(doc, {\r\n                        docId: doc.primary,\r\n                        revisionHeight: getHeightOfRevision(doc.revision),\r\n                        lwt: doc._data._meta.lwt\r\n                    });\r\n                }\r\n            });\r\n            if (docCache.tasks.size <= 1) {\r\n                requestIdlePromiseNoQueue().then(() => {\r\n                    docCache.processTasks();\r\n                });\r\n            }\r\n        }\r\n        return ret;\r\n    };\r\n    return fn;\r\n}\r\n\r\nexport function mapDocumentsDataToCacheDocs<RxDocType, OrmMethods>(\r\n    docCache: DocumentCache<RxDocType, OrmMethods>,\r\n    docsData: RxDocumentData<RxDocType>[]\r\n) {\r\n    const getCachedRxDocuments = docCache.getCachedRxDocuments;\r\n    return getCachedRxDocuments(docsData);\r\n}\r\n\r\n/**\r\n * Fallback for JavaScript runtimes that do not support WeakRef.\r\n * The fallback will keep the items in cache forever,\r\n * but at least works.\r\n */\r\nconst HAS_WEAK_REF = typeof WeakRef === 'function';\r\nconst createWeakRefWithFallback = HAS_WEAK_REF ? createWeakRef : createWeakRefFallback;\r\nfunction createWeakRef<T extends object>(obj: T): WeakRef<T> {\r\n    return new WeakRef(obj) as any;\r\n}\r\nfunction createWeakRefFallback<T extends object>(obj: T): WeakRef<T> {\r\n    return {\r\n        deref() {\r\n            return obj;\r\n        }\r\n    } as any;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/event-reduce.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RXQUERY_QUERY_PARAMS_CACHE = void 0;
+exports.calculateNewResults = calculateNewResults;
+exports.getQueryParams = getQueryParams;
+exports.getSortFieldsOfQuery = getSortFieldsOfQuery;
+var _eventReduceJs = require("event-reduce-js");
+var _rxChangeEvent = require("./rx-change-event.js");
+var _index = require("./plugins/utils/index.js");
+var _rxQueryHelper = require("./rx-query-helper.js");
+function getSortFieldsOfQuery(primaryKey, query) {
+  if (!query.sort || query.sort.length === 0) {
+    return [primaryKey];
+  } else {
+    return query.sort.map(part => Object.keys(part)[0]);
+  }
+}
+var RXQUERY_QUERY_PARAMS_CACHE = exports.RXQUERY_QUERY_PARAMS_CACHE = new WeakMap();
+function getQueryParams(rxQuery) {
+  return (0, _index.getFromMapOrCreate)(RXQUERY_QUERY_PARAMS_CACHE, rxQuery, () => {
+    var collection = rxQuery.collection;
+    var normalizedMangoQuery = (0, _rxQueryHelper.normalizeMangoQuery)(collection.storageInstance.schema, (0, _index.clone)(rxQuery.mangoQuery));
+    var primaryKey = collection.schema.primaryPath;
+
+    /**
+     * Create a custom sort comparator
+     * that uses the hooks to ensure
+     * we send for example compressed documents to be sorted by compressed queries.
+     *
+     * @performance
+     * Avoid creating intermediate wrapper objects on every comparison call.
+     * The sortComparator and queryMatcher are called directly.
+     */
+    var useSortComparator = (0, _rxQueryHelper.getSortComparator)(collection.schema.jsonSchema, normalizedMangoQuery);
+
+    /**
+     * Create a custom query matcher
+     * that uses the hooks to ensure
+     * we send for example compressed documents to match compressed queries.
+     */
+    var useQueryMatcher = (0, _rxQueryHelper.getQueryMatcher)(collection.schema.jsonSchema, normalizedMangoQuery);
+    var ret = {
+      primaryKey: rxQuery.collection.schema.primaryPath,
+      skip: normalizedMangoQuery.skip,
+      limit: normalizedMangoQuery.limit,
+      sortFields: getSortFieldsOfQuery(primaryKey, normalizedMangoQuery),
+      sortComparator: useSortComparator,
+      queryMatcher: useQueryMatcher
+    };
+    return ret;
+  });
+}
+function calculateNewResults(rxQuery, rxChangeEvents) {
+  if (!rxQuery.collection.database.eventReduce) {
+    return {
+      runFullQueryAgain: true
+    };
+  }
+  var queryParams = getQueryParams(rxQuery);
+  var previousResults = (0, _index.ensureNotFalsy)(rxQuery._result).docsData.slice(0);
+  var previousResultsMap = (0, _index.ensureNotFalsy)(rxQuery._result).docsDataMap;
+  var changed = false;
+  var eventReduceEvents = [];
+  for (var index = 0; index < rxChangeEvents.length; index++) {
+    var cE = rxChangeEvents[index];
+    var eventReduceEvent = (0, _rxChangeEvent.rxChangeEventToEventReduceChangeEvent)(cE);
+    if (eventReduceEvent) {
+      eventReduceEvents.push(eventReduceEvent);
+    }
+  }
+  var foundNonOptimizeable = eventReduceEvents.find(eventReduceEvent => {
+    var stateResolveFunctionInput = {
+      queryParams,
+      changeEvent: eventReduceEvent,
+      previousResults,
+      keyDocumentMap: previousResultsMap
+    };
+    var actionName = (0, _eventReduceJs.calculateActionName)(stateResolveFunctionInput);
+    if (actionName === 'runFullQueryAgain') {
+      return true;
+    } else if (actionName !== 'doNothing') {
+      changed = true;
+      (0, _eventReduceJs.runAction)(actionName, queryParams, eventReduceEvent, previousResults, previousResultsMap);
+      return false;
+    }
+  });
+  if (foundNonOptimizeable) {
+    return {
+      runFullQueryAgain: true
+    };
+  } else {
+    return {
+      runFullQueryAgain: false,
+      changed,
+      newResults: previousResults
+    };
+  }
+}
+//# sourceMappingURL=event-reduce.js.map

package/dist/cjs/event-reduce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-reduce.js","names":["_eventReduceJs","require","_rxChangeEvent","_index","_rxQueryHelper","getSortFieldsOfQuery","primaryKey","query","sort","length","map","part","Object","keys","RXQUERY_QUERY_PARAMS_CACHE","exports","WeakMap","getQueryParams","rxQuery","getFromMapOrCreate","collection","normalizedMangoQuery","normalizeMangoQuery","storageInstance","schema","clone","mangoQuery","primaryPath","useSortComparator","getSortComparator","jsonSchema","useQueryMatcher","getQueryMatcher","ret","skip","limit","sortFields","sortComparator","queryMatcher","calculateNewResults","rxChangeEvents","database","eventReduce","runFullQueryAgain","queryParams","previousResults","ensureNotFalsy","_result","docsData","slice","previousResultsMap","docsDataMap","changed","eventReduceEvents","index","cE","eventReduceEvent","rxChangeEventToEventReduceChangeEvent","push","foundNonOptimizeable","find","stateResolveFunctionInput","changeEvent","keyDocumentMap","actionName","calculateActionName","runAction","newResults"],"sources":["../../src/event-reduce.ts"],"sourcesContent":["import {\r\n    ActionName,\r\n    calculateActionName,\r\n    runAction,\r\n    QueryParams,\r\n    StateResolveFunctionInput,\r\n    ChangeEvent\r\n} from 'event-reduce-js';\r\nimport type {\r\n    RxQuery,\r\n    MangoQuery,\r\n    StringKeys,\r\n    RxDocumentData,\r\n    RxStorageChangeEvent\r\n} from './types/index.d.ts';\r\nimport { rxChangeEventToEventReduceChangeEvent } from './rx-change-event.ts';\r\nimport {\r\n    clone,\r\n    ensureNotFalsy,\r\n    getFromMapOrCreate\r\n} from './plugins/utils/index.ts';\r\nimport { getQueryMatcher, getSortComparator, normalizeMangoQuery } from './rx-query-helper.ts';\r\n\r\nexport type EventReduceResultNeg = {\r\n    runFullQueryAgain: true;\r\n};\r\nexport type EventReduceResultPos<RxDocumentType> = {\r\n    runFullQueryAgain: false;\r\n    changed: boolean;\r\n    newResults: RxDocumentType[];\r\n};\r\nexport type EventReduceResult<RxDocumentType> = EventReduceResultNeg | EventReduceResultPos<RxDocumentType>;\r\n\r\n\r\nexport function getSortFieldsOfQuery<RxDocType>(\r\n    primaryKey: StringKeys<RxDocumentData<RxDocType>>,\r\n    query: MangoQuery<RxDocType>\r\n): (string | StringKeys<RxDocType>)[] {\r\n    if (!query.sort || query.sort.length === 0) {\r\n        return [primaryKey];\r\n    } else {\r\n        return query.sort.map(part => Object.keys(part)[0]);\r\n    }\r\n}\r\n\r\n\r\n\r\nexport const RXQUERY_QUERY_PARAMS_CACHE: WeakMap<RxQuery, QueryParams<any>> = new WeakMap();\r\nexport function getQueryParams<RxDocType>(\r\n    rxQuery: RxQuery<RxDocType>\r\n): QueryParams<RxDocType> {\r\n    return getFromMapOrCreate(\r\n        RXQUERY_QUERY_PARAMS_CACHE,\r\n        rxQuery,\r\n        () => {\r\n            const collection = rxQuery.collection;\r\n            const normalizedMangoQuery = normalizeMangoQuery(\r\n                collection.storageInstance.schema,\r\n                clone(rxQuery.mangoQuery)\r\n            );\r\n            const primaryKey = collection.schema.primaryPath;\r\n\r\n            /**\r\n             * Create a custom sort comparator\r\n             * that uses the hooks to ensure\r\n             * we send for example compressed documents to be sorted by compressed queries.\r\n             *\r\n             * @performance\r\n             * Avoid creating intermediate wrapper objects on every comparison call.\r\n             * The sortComparator and queryMatcher are called directly.\r\n             */\r\n            const useSortComparator = getSortComparator(\r\n                collection.schema.jsonSchema,\r\n                normalizedMangoQuery\r\n            );\r\n\r\n            /**\r\n             * Create a custom query matcher\r\n             * that uses the hooks to ensure\r\n             * we send for example compressed documents to match compressed queries.\r\n             */\r\n            const useQueryMatcher = getQueryMatcher(\r\n                collection.schema.jsonSchema,\r\n                normalizedMangoQuery\r\n            );\r\n\r\n            const ret: QueryParams<any> = {\r\n                primaryKey: rxQuery.collection.schema.primaryPath as any,\r\n                skip: normalizedMangoQuery.skip,\r\n                limit: normalizedMangoQuery.limit,\r\n                sortFields: getSortFieldsOfQuery(primaryKey, normalizedMangoQuery) as string[],\r\n                sortComparator: useSortComparator,\r\n                queryMatcher: useQueryMatcher\r\n            };\r\n            return ret;\r\n        }\r\n    );\r\n}\r\n\r\n\r\nexport function calculateNewResults<RxDocumentType>(\r\n    rxQuery: RxQuery<RxDocumentType>,\r\n    rxChangeEvents: RxStorageChangeEvent<RxDocumentType>[]\r\n): EventReduceResult<RxDocumentType> {\r\n    if (!rxQuery.collection.database.eventReduce) {\r\n        return {\r\n            runFullQueryAgain: true\r\n        };\r\n    }\r\n    const queryParams = getQueryParams(rxQuery);\r\n    const previousResults: RxDocumentType[] = ensureNotFalsy(rxQuery._result).docsData.slice(0);\r\n    const previousResultsMap: Map<string, RxDocumentType> = ensureNotFalsy(rxQuery._result).docsDataMap;\r\n    let changed: boolean = false;\r\n\r\n\r\n    const eventReduceEvents: ChangeEvent<RxDocumentType>[] = [];\r\n    for (let index = 0; index < rxChangeEvents.length; index++) {\r\n        const cE = rxChangeEvents[index];\r\n        const eventReduceEvent = rxChangeEventToEventReduceChangeEvent(cE);\r\n        if (eventReduceEvent) {\r\n            eventReduceEvents.push(eventReduceEvent);\r\n        }\r\n    }\r\n\r\n    const foundNonOptimizeable = eventReduceEvents.find(eventReduceEvent => {\r\n        const stateResolveFunctionInput: StateResolveFunctionInput<RxDocumentType> = {\r\n            queryParams,\r\n            changeEvent: eventReduceEvent,\r\n            previousResults,\r\n            keyDocumentMap: previousResultsMap\r\n        };\r\n\r\n        const actionName: ActionName = calculateActionName(stateResolveFunctionInput);\r\n        if (actionName === 'runFullQueryAgain') {\r\n            return true;\r\n        } else if (actionName !== 'doNothing') {\r\n            changed = true;\r\n            runAction(\r\n                actionName,\r\n                queryParams,\r\n                eventReduceEvent,\r\n                previousResults,\r\n                previousResultsMap\r\n            );\r\n            return false;\r\n        }\r\n    });\r\n    if (foundNonOptimizeable) {\r\n        return {\r\n            runFullQueryAgain: true,\r\n        };\r\n    } else {\r\n        return {\r\n            runFullQueryAgain: false,\r\n            changed,\r\n            newResults: previousResults\r\n        };\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/hooks.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HOOKS = void 0;
+exports._clearHook = _clearHook;
+exports.runAsyncPluginHooks = runAsyncPluginHooks;
+exports.runPluginHooks = runPluginHooks;
+/**
+ * hook-functions that can be extended by the plugin
+ */
+var HOOKS = exports.HOOKS = {
+  /**
+   * Runs before a plugin is added.
+   * Use this to block the usage of non-compatible plugins.
+   */
+  preAddRxPlugin: [],
+  /**
+   * functions that run before the database is created
+   */
+  preCreateRxDatabase: [],
+  /**
+   * runs after the database is created and prepared
+   * but before the instance is returned to the user
+   * @async
+   */
+  createRxDatabase: [],
+  preCreateRxCollection: [],
+  createRxCollection: [],
+  createRxState: [],
+  /**
+  * runs at the end of the close-process of a collection
+  * @async
+  */
+  postCloseRxCollection: [],
+  /**
+   * Runs after a collection is removed.
+   * @async
+   */
+  postRemoveRxCollection: [],
+  /**
+    * functions that get the json-schema as input
+    * to do additionally checks/manipulation
+    */
+  preCreateRxSchema: [],
+  /**
+   * functions that run after the RxSchema is created
+   * gets RxSchema as attribute
+   */
+  createRxSchema: [],
+  prePrepareRxQuery: [],
+  preCreateRxQuery: [],
+  /**
+   * Runs before a query is sent to the
+   * prepareQuery function of the storage engine.
+   */
+  prePrepareQuery: [],
+  createRxDocument: [],
+  /**
+   * runs after a RxDocument is created,
+   * cannot be async
+   */
+  postCreateRxDocument: [],
+  /**
+   * Runs before a RxStorageInstance is created
+   * gets the params of createStorageInstance()
+   * as attribute so you can manipulate them.
+   * Notice that you have to clone stuff before mutating the inputs.
+   */
+  preCreateRxStorageInstance: [],
+  preStorageWrite: [],
+  /**
+   * runs on the document-data before the document is migrated
+   * {
+   *   doc: Object, // original doc-data
+   *   migrated: // migrated doc-data after run through migration-strategies
+   * }
+   */
+  preMigrateDocument: [],
+  /**
+   * runs after the migration of a document has been done
+   */
+  postMigrateDocument: [],
+  /**
+   * runs at the beginning of the close-process of a database
+   */
+  preCloseRxDatabase: [],
+  /**
+   * runs after a database has been removed
+   * @async
+   */
+  postRemoveRxDatabase: [],
+  postCleanup: [],
+  /**
+   * runs before the replication writes the rows to master
+   * but before the rows have been modified
+   * @async
+   */
+  preReplicationMasterWrite: [],
+  /**
+   * runs after the replication has been sent to the server
+   * but before the new documents have been handled
+   * @async
+   */
+  preReplicationMasterWriteDocumentsHandle: []
+};
+function runPluginHooks(hookKey, obj) {
+  if (HOOKS[hookKey].length > 0) {
+    HOOKS[hookKey].forEach(fun => fun(obj));
+  }
+}
+
+/**
+ * We do intentionally not run the hooks in parallel
+ * because that makes stuff unpredictable and we use runAsyncPluginHooks()
+ * only in places that are not that relevant for performance.
+ */
+async function runAsyncPluginHooks(hookKey, obj) {
+  for (var fn of HOOKS[hookKey]) {
+    await fn(obj);
+  }
+}
+
+/**
+ * used in tests to remove hooks
+ */
+function _clearHook(type, fun) {
+  HOOKS[type] = HOOKS[type].filter(h => h !== fun);
+}
+//# sourceMappingURL=hooks.js.map

package/dist/cjs/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","names":["HOOKS","exports","preAddRxPlugin","preCreateRxDatabase","createRxDatabase","preCreateRxCollection","createRxCollection","createRxState","postCloseRxCollection","postRemoveRxCollection","preCreateRxSchema","createRxSchema","prePrepareRxQuery","preCreateRxQuery","prePrepareQuery","createRxDocument","postCreateRxDocument","preCreateRxStorageInstance","preStorageWrite","preMigrateDocument","postMigrateDocument","preCloseRxDatabase","postRemoveRxDatabase","postCleanup","preReplicationMasterWrite","preReplicationMasterWriteDocumentsHandle","runPluginHooks","hookKey","obj","length","forEach","fun","runAsyncPluginHooks","fn","_clearHook","type","filter","h"],"sources":["../../src/hooks.ts"],"sourcesContent":["\r\n/**\r\n * hook-functions that can be extended by the plugin\r\n */\r\nexport const HOOKS = {\r\n    /**\r\n     * Runs before a plugin is added.\r\n     * Use this to block the usage of non-compatible plugins.\r\n     */\r\n    preAddRxPlugin: [],\r\n    /**\r\n     * functions that run before the database is created\r\n     */\r\n    preCreateRxDatabase: [],\r\n    /**\r\n     * runs after the database is created and prepared\r\n     * but before the instance is returned to the user\r\n     * @async\r\n     */\r\n    createRxDatabase: [],\r\n    preCreateRxCollection: [],\r\n    createRxCollection: [],\r\n    createRxState: [],\r\n    /**\r\n    * runs at the end of the close-process of a collection\r\n    * @async\r\n    */\r\n    postCloseRxCollection: [],\r\n    /**\r\n     * Runs after a collection is removed.\r\n     * @async\r\n     */\r\n    postRemoveRxCollection: [],\r\n    /**\r\n      * functions that get the json-schema as input\r\n      * to do additionally checks/manipulation\r\n      */\r\n    preCreateRxSchema: [],\r\n    /**\r\n     * functions that run after the RxSchema is created\r\n     * gets RxSchema as attribute\r\n     */\r\n    createRxSchema: [],\r\n    prePrepareRxQuery: [],\r\n    preCreateRxQuery: [],\r\n    /**\r\n     * Runs before a query is sent to the\r\n     * prepareQuery function of the storage engine.\r\n     */\r\n    prePrepareQuery: [],\r\n    createRxDocument: [],\r\n    /**\r\n     * runs after a RxDocument is created,\r\n     * cannot be async\r\n     */\r\n    postCreateRxDocument: [],\r\n    /**\r\n     * Runs before a RxStorageInstance is created\r\n     * gets the params of createStorageInstance()\r\n     * as attribute so you can manipulate them.\r\n     * Notice that you have to clone stuff before mutating the inputs.\r\n     */\r\n    preCreateRxStorageInstance: [],\r\n    preStorageWrite: [],\r\n    /**\r\n     * runs on the document-data before the document is migrated\r\n     * {\r\n     *   doc: Object, // original doc-data\r\n     *   migrated: // migrated doc-data after run through migration-strategies\r\n     * }\r\n     */\r\n    preMigrateDocument: [],\r\n    /**\r\n     * runs after the migration of a document has been done\r\n     */\r\n    postMigrateDocument: [],\r\n    /**\r\n     * runs at the beginning of the close-process of a database\r\n     */\r\n    preCloseRxDatabase: [],\r\n    /**\r\n     * runs after a database has been removed\r\n     * @async\r\n     */\r\n    postRemoveRxDatabase: [],\r\n\r\n\r\n    postCleanup: [],\r\n\r\n    /**\r\n     * runs before the replication writes the rows to master\r\n     * but before the rows have been modified\r\n     * @async\r\n     */\r\n    preReplicationMasterWrite: [],\r\n\r\n    /**\r\n     * runs after the replication has been sent to the server\r\n     * but before the new documents have been handled\r\n     * @async\r\n     */\r\n    preReplicationMasterWriteDocumentsHandle: [],\r\n};\r\n\r\nexport function runPluginHooks(hookKey: keyof typeof HOOKS, obj: any) {\r\n    if (HOOKS[hookKey].length > 0) {\r\n        HOOKS[hookKey].forEach(fun => (fun as any)(obj));\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * We do intentionally not run the hooks in parallel\r\n * because that makes stuff unpredictable and we use runAsyncPluginHooks()\r\n * only in places that are not that relevant for performance.\r\n */\r\nexport async function runAsyncPluginHooks(hookKey: keyof typeof HOOKS, obj: any): Promise<any> {\r\n    for (const fn of HOOKS[hookKey]) {\r\n        await (fn as any)(obj);\r\n    }\r\n}\r\n\r\n/**\r\n * used in tests to remove hooks\r\n */\r\nexport function _clearHook(type: keyof typeof HOOKS, fun: Function) {\r\n    HOOKS[type] = HOOKS[type].filter(h => h !== fun);\r\n}\r\n"],"mappings":";;;;;;;;;AACA;AACA;AACA;AACO,IAAMA,KAAK,GAAAC,OAAA,CAAAD,KAAA,GAAG;EACjB;AACJ;AACA;AACA;EACIE,cAAc,EAAE,EAAE;EAClB;AACJ;AACA;EACIC,mBAAmB,EAAE,EAAE;EACvB;AACJ;AACA;AACA;AACA;EACIC,gBAAgB,EAAE,EAAE;EACpBC,qBAAqB,EAAE,EAAE;EACzBC,kBAAkB,EAAE,EAAE;EACtBC,aAAa,EAAE,EAAE;EACjB;AACJ;AACA;AACA;EACIC,qBAAqB,EAAE,EAAE;EACzB;AACJ;AACA;AACA;EACIC,sBAAsB,EAAE,EAAE;EAC1B;AACJ;AACA;AACA;EACIC,iBAAiB,EAAE,EAAE;EACrB;AACJ;AACA;AACA;EACIC,cAAc,EAAE,EAAE;EAClBC,iBAAiB,EAAE,EAAE;EACrBC,gBAAgB,EAAE,EAAE;EACpB;AACJ;AACA;AACA;EACIC,eAAe,EAAE,EAAE;EACnBC,gBAAgB,EAAE,EAAE;EACpB;AACJ;AACA;AACA;EACIC,oBAAoB,EAAE,EAAE;EACxB;AACJ;AACA;AACA;AACA;AACA;EACIC,0BAA0B,EAAE,EAAE;EAC9BC,eAAe,EAAE,EAAE;EACnB;AACJ;AACA;AACA;AACA;AACA;AACA;EACIC,kBAAkB,EAAE,EAAE;EACtB;AACJ;AACA;EACIC,mBAAmB,EAAE,EAAE;EACvB;AACJ;AACA;EACIC,kBAAkB,EAAE,EAAE;EACtB;AACJ;AACA;AACA;EACIC,oBAAoB,EAAE,EAAE;EAGxBC,WAAW,EAAE,EAAE;EAEf;AACJ;AACA;AACA;AACA;EACIC,yBAAyB,EAAE,EAAE;EAE7B;AACJ;AACA;AACA;AACA;EACIC,wCAAwC,EAAE;AAC9C,CAAC;AAEM,SAASC,cAAcA,CAACC,OAA2B,EAAEC,GAAQ,EAAE;EAClE,IAAI5B,KAAK,CAAC2B,OAAO,CAAC,CAACE,MAAM,GAAG,CAAC,EAAE;IAC3B7B,KAAK,CAAC2B,OAAO,CAAC,CAACG,OAAO,CAACC,GAAG,IAAKA,GAAG,CAASH,GAAG,CAAC,CAAC;EACpD;AACJ;;AAGA;AACA;AACA;AACA;AACA;AACO,eAAeI,mBAAmBA,CAACL,OAA2B,EAAEC,GAAQ,EAAgB;EAC3F,KAAK,IAAMK,EAAE,IAAIjC,KAAK,CAAC2B,OAAO,CAAC,EAAE;IAC7B,MAAOM,EAAE,CAASL,GAAG,CAAC;EAC1B;AACJ;;AAEA;AACA;AACA;AACO,SAASM,UAAUA,CAACC,IAAwB,EAAEJ,GAAa,EAAE;EAChE/B,KAAK,CAACmC,IAAI,CAAC,GAAGnC,KAAK,CAACmC,IAAI,CAAC,CAACC,MAAM,CAACC,CAAC,IAAIA,CAAC,KAAKN,GAAG,CAAC;AACpD","ignoreList":[]}