@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/event-reduce.js

@@ -0,0 +1,93 @@
+import { calculateActionName, runAction } from 'event-reduce-js';
+import { rxChangeEventToEventReduceChangeEvent } from "./rx-change-event.js";
+import { clone, ensureNotFalsy, getFromMapOrCreate } from "./plugins/utils/index.js";
+import { getQueryMatcher, getSortComparator, normalizeMangoQuery } from "./rx-query-helper.js";
+export function getSortFieldsOfQuery(primaryKey, query) {
+  if (!query.sort || query.sort.length === 0) {
+    return [primaryKey];
+  } else {
+    return query.sort.map(part => Object.keys(part)[0]);
+  }
+}
+export var RXQUERY_QUERY_PARAMS_CACHE = new WeakMap();
+export function getQueryParams(rxQuery) {
+  return getFromMapOrCreate(RXQUERY_QUERY_PARAMS_CACHE, rxQuery, () => {
+    var collection = rxQuery.collection;
+    var normalizedMangoQuery = normalizeMangoQuery(collection.storageInstance.schema, 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 = 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 = 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;
+  });
+}
+export function calculateNewResults(rxQuery, rxChangeEvents) {
+  if (!rxQuery.collection.database.eventReduce) {
+    return {
+      runFullQueryAgain: true
+    };
+  }
+  var queryParams = getQueryParams(rxQuery);
+  var previousResults = ensureNotFalsy(rxQuery._result).docsData.slice(0);
+  var previousResultsMap = ensureNotFalsy(rxQuery._result).docsDataMap;
+  var changed = false;
+  var eventReduceEvents = [];
+  for (var index = 0; index < rxChangeEvents.length; index++) {
+    var cE = rxChangeEvents[index];
+    var eventReduceEvent = rxChangeEventToEventReduceChangeEvent(cE);
+    if (eventReduceEvent) {
+      eventReduceEvents.push(eventReduceEvent);
+    }
+  }
+  var foundNonOptimizeable = eventReduceEvents.find(eventReduceEvent => {
+    var stateResolveFunctionInput = {
+      queryParams,
+      changeEvent: eventReduceEvent,
+      previousResults,
+      keyDocumentMap: previousResultsMap
+    };
+    var actionName = calculateActionName(stateResolveFunctionInput);
+    if (actionName === 'runFullQueryAgain') {
+      return true;
+    } else if (actionName !== 'doNothing') {
+      changed = true;
+      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/esm/event-reduce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-reduce.js","names":["calculateActionName","runAction","rxChangeEventToEventReduceChangeEvent","clone","ensureNotFalsy","getFromMapOrCreate","getQueryMatcher","getSortComparator","normalizeMangoQuery","getSortFieldsOfQuery","primaryKey","query","sort","length","map","part","Object","keys","RXQUERY_QUERY_PARAMS_CACHE","WeakMap","getQueryParams","rxQuery","collection","normalizedMangoQuery","storageInstance","schema","mangoQuery","primaryPath","useSortComparator","jsonSchema","useQueryMatcher","ret","skip","limit","sortFields","sortComparator","queryMatcher","calculateNewResults","rxChangeEvents","database","eventReduce","runFullQueryAgain","queryParams","previousResults","_result","docsData","slice","previousResultsMap","docsDataMap","changed","eventReduceEvents","index","cE","eventReduceEvent","push","foundNonOptimizeable","find","stateResolveFunctionInput","changeEvent","keyDocumentMap","actionName","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/esm/hooks.js

@@ -0,0 +1,122 @@
+/**
+ * hook-functions that can be extended by the plugin
+ */
+export var 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: []
+};
+export 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.
+ */
+export async function runAsyncPluginHooks(hookKey, obj) {
+  for (var fn of HOOKS[hookKey]) {
+    await fn(obj);
+  }
+}
+
+/**
+ * used in tests to remove hooks
+ */
+export function _clearHook(type, fun) {
+  HOOKS[type] = HOOKS[type].filter(h => h !== fun);
+}
+//# sourceMappingURL=hooks.js.map

package/dist/esm/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","names":["HOOKS","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;AACA,OAAO,IAAMA,KAAK,GAAG;EACjB;AACJ;AACA;AACA;EACIC,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;AAED,OAAO,SAASC,cAAcA,CAACC,OAA2B,EAAEC,GAAQ,EAAE;EAClE,IAAI3B,KAAK,CAAC0B,OAAO,CAAC,CAACE,MAAM,GAAG,CAAC,EAAE;IAC3B5B,KAAK,CAAC0B,OAAO,CAAC,CAACG,OAAO,CAACC,GAAG,IAAKA,GAAG,CAASH,GAAG,CAAC,CAAC;EACpD;AACJ;;AAGA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeI,mBAAmBA,CAACL,OAA2B,EAAEC,GAAQ,EAAgB;EAC3F,KAAK,IAAMK,EAAE,IAAIhC,KAAK,CAAC0B,OAAO,CAAC,EAAE;IAC7B,MAAOM,EAAE,CAASL,GAAG,CAAC;EAC1B;AACJ;;AAEA;AACA;AACA;AACA,OAAO,SAASM,UAAUA,CAACC,IAAwB,EAAEJ,GAAa,EAAE;EAChE9B,KAAK,CAACkC,IAAI,CAAC,GAAGlC,KAAK,CAACkC,IAAI,CAAC,CAACC,MAAM,CAACC,CAAC,IAAIA,CAAC,KAAKN,GAAG,CAAC;AACpD","ignoreList":[]}

package/dist/esm/incremental-write.js

@@ -0,0 +1,161 @@
+import { isBulkWriteConflictError, rxStorageWriteErrorToRxError } from "./rx-error.js";
+import { clone, ensureNotFalsy, getFromMapOrCreate, getFromMapOrThrow, getHeightOfRevision, stripMetaDataFromDocument } from "./plugins/utils/index.js";
+import { getWrittenDocumentsFromBulkWriteResponse } from "./rx-storage-helper.js";
+/**
+ * The incremental write queue
+ * batches up all incremental writes to a collection
+ * so that performance can be improved by:
+ * - Running only one write even when there are multiple modifications to the same document.
+ * - Run all writes ins a single bulkWrite() call even when there are writes to many documents.
+ */
+export var IncrementalWriteQueue = /*#__PURE__*/function () {
+  function IncrementalWriteQueue(storageInstance, primaryPath,
+  // can be used to run hooks etc.
+  preWrite, postWrite) {
+    this.queueByDocId = new Map();
+    this.isRunning = false;
+    this.storageInstance = storageInstance;
+    this.primaryPath = primaryPath;
+    this.preWrite = preWrite;
+    this.postWrite = postWrite;
+  }
+  var _proto = IncrementalWriteQueue.prototype;
+  _proto.addWrite = function addWrite(lastKnownDocumentState, modifier) {
+    var docId = lastKnownDocumentState[this.primaryPath];
+    var ar = getFromMapOrCreate(this.queueByDocId, docId, () => []);
+    var ret = new Promise((resolve, reject) => {
+      var item = {
+        lastKnownDocumentState,
+        modifier,
+        resolve,
+        reject
+      };
+      ensureNotFalsy(ar).push(item);
+      this.triggerRun();
+    });
+    return ret;
+  };
+  _proto.triggerRun = async function triggerRun() {
+    if (this.isRunning === true || this.queueByDocId.size === 0) {
+      // already running
+      return;
+    }
+    this.isRunning = true;
+    var writeRows = [];
+
+    /**
+     * 'take over' so that while the async functions runs,
+     * new incremental updates could be added from the outside.
+     */
+    var itemsById = this.queueByDocId;
+    this.queueByDocId = new Map();
+    await Promise.all(Array.from(itemsById.entries()).map(async ([_docId, items]) => {
+      var oldData = findNewestOfDocumentStates(items.map(i => i.lastKnownDocumentState));
+      var newData = oldData;
+      for (var item of items) {
+        try {
+          newData = await item.modifier(
+          /**
+           * We have to clone() each time because the modifier
+           * might throw while it already changed some properties
+           * of the document.
+           */
+          clone(newData));
+        } catch (err) {
+          item.reject(err);
+          item.reject = () => {};
+          item.resolve = () => {};
+        }
+      }
+      try {
+        await this.preWrite(newData, oldData);
+      } catch (err) {
+        /**
+         * If the before-hooks fail,
+         * we reject all of the writes because it is
+         * not possible to determine which one is to blame.
+         */
+        items.forEach(item => item.reject(err));
+        return;
+      }
+      writeRows.push({
+        previous: oldData,
+        document: newData
+      });
+    }));
+    var writeResult = writeRows.length > 0 ? await this.storageInstance.bulkWrite(writeRows, 'incremental-write') : {
+      error: []
+    };
+
+    // process success
+    await Promise.all(getWrittenDocumentsFromBulkWriteResponse(this.primaryPath, writeRows, writeResult).map(result => {
+      var docId = result[this.primaryPath];
+      this.postWrite(result);
+      var items = getFromMapOrThrow(itemsById, docId);
+      items.forEach(item => item.resolve(result));
+    }));
+
+    // process errors
+    writeResult.error.forEach(error => {
+      var docId = error.documentId;
+      var items = getFromMapOrThrow(itemsById, docId);
+      var isConflict = isBulkWriteConflictError(error);
+      if (isConflict) {
+        // had conflict -> retry afterwards
+        var ar = getFromMapOrCreate(this.queueByDocId, docId, () => []);
+        /**
+         * Add the items back to this.queueByDocId
+         * by maintaining the original order.
+         */
+        items.reverse().forEach(item => {
+          item.lastKnownDocumentState = ensureNotFalsy(isConflict.documentInDb);
+          ensureNotFalsy(ar).unshift(item);
+        });
+      } else {
+        // other error -> must be thrown
+        var rxError = rxStorageWriteErrorToRxError(error);
+        items.forEach(item => item.reject(rxError));
+      }
+    });
+    this.isRunning = false;
+
+    /**
+     * Always trigger another run
+     * because in between there might be new items
+     * been added to the queue.
+     */
+    return this.triggerRun();
+  };
+  return IncrementalWriteQueue;
+}();
+export function modifierFromPublicToInternal(publicModifier) {
+  var ret = async docData => {
+    var withoutMeta = stripMetaDataFromDocument(docData);
+    withoutMeta._deleted = docData._deleted;
+    var modified = await publicModifier(withoutMeta);
+    var reattachedMeta = Object.assign({}, modified, {
+      _meta: docData._meta,
+      _attachments: docData._attachments,
+      _rev: docData._rev,
+      _deleted: typeof modified._deleted !== 'undefined' ? modified._deleted : docData._deleted
+    });
+    if (typeof reattachedMeta._deleted === 'undefined') {
+      reattachedMeta._deleted = false;
+    }
+    return reattachedMeta;
+  };
+  return ret;
+}
+export function findNewestOfDocumentStates(docs) {
+  var newest = docs[0];
+  var newestRevisionHeight = getHeightOfRevision(newest._rev);
+  docs.forEach(doc => {
+    var height = getHeightOfRevision(doc._rev);
+    if (height > newestRevisionHeight) {
+      newest = doc;
+      newestRevisionHeight = height;
+    }
+  });
+  return newest;
+}
+//# sourceMappingURL=incremental-write.js.map

package/dist/esm/incremental-write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental-write.js","names":["isBulkWriteConflictError","rxStorageWriteErrorToRxError","clone","ensureNotFalsy","getFromMapOrCreate","getFromMapOrThrow","getHeightOfRevision","stripMetaDataFromDocument","getWrittenDocumentsFromBulkWriteResponse","IncrementalWriteQueue","storageInstance","primaryPath","preWrite","postWrite","queueByDocId","Map","isRunning","_proto","prototype","addWrite","lastKnownDocumentState","modifier","docId","ar","ret","Promise","resolve","reject","item","push","triggerRun","size","writeRows","itemsById","all","Array","from","entries","map","_docId","items","oldData","findNewestOfDocumentStates","i","newData","err","forEach","previous","document","writeResult","length","bulkWrite","error","result","documentId","isConflict","reverse","documentInDb","unshift","rxError","modifierFromPublicToInternal","publicModifier","docData","withoutMeta","_deleted","modified","reattachedMeta","Object","assign","_meta","_attachments","_rev","docs","newest","newestRevisionHeight","doc","height"],"sources":["../../src/incremental-write.ts"],"sourcesContent":["import {\r\n    isBulkWriteConflictError,\r\n    rxStorageWriteErrorToRxError\r\n} from './rx-error.ts';\r\nimport type {\r\n    ModifyFunction,\r\n    BulkWriteRow,\r\n    MaybePromise,\r\n    RxDocumentData,\r\n    RxDocumentWriteData,\r\n    RxError,\r\n    RxStorageBulkWriteResponse,\r\n    RxStorageInstance,\r\n    StringKeys,\r\n    WithDeleted\r\n} from './types/index.d.ts';\r\nimport {\r\n    clone,\r\n    ensureNotFalsy,\r\n    getFromMapOrCreate,\r\n    getFromMapOrThrow,\r\n    getHeightOfRevision,\r\n    stripMetaDataFromDocument\r\n} from './plugins/utils/index.ts';\r\nimport { getWrittenDocumentsFromBulkWriteResponse } from './rx-storage-helper.ts';\r\n\r\n\r\n\r\nexport type IncrementalWriteModifier<RxDocType> = (\r\n    doc: RxDocumentData<RxDocType>\r\n) => MaybePromise<RxDocumentData<RxDocType>> | MaybePromise<RxDocumentWriteData<RxDocType>>;\r\n\r\n\r\ntype IncrementalWriteQueueItem<RxDocType> = {\r\n    lastKnownDocumentState: RxDocumentData<RxDocType>;\r\n    modifier: IncrementalWriteModifier<RxDocType>;\r\n    resolve: (d: RxDocumentData<RxDocType>) => void;\r\n    reject: (error: RxError) => void;\r\n};\r\n\r\n/**\r\n * The incremental write queue\r\n * batches up all incremental writes to a collection\r\n * so that performance can be improved by:\r\n * - Running only one write even when there are multiple modifications to the same document.\r\n * - Run all writes ins a single bulkWrite() call even when there are writes to many documents.\r\n */\r\nexport class IncrementalWriteQueue<RxDocType> {\r\n    public queueByDocId = new Map<string, IncrementalWriteQueueItem<RxDocType>[]>();\r\n    public isRunning: boolean = false;\r\n\r\n    constructor(\r\n        public readonly storageInstance: RxStorageInstance<RxDocType, any, any>,\r\n        public readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>,\r\n        // can be used to run hooks etc.\r\n        public readonly preWrite: (newData: RxDocumentData<RxDocType>, oldData: RxDocumentData<RxDocType>) => MaybePromise<void>,\r\n        public readonly postWrite: (docData: RxDocumentData<RxDocType>) => void\r\n\r\n    ) { }\r\n\r\n    addWrite(\r\n        lastKnownDocumentState: RxDocumentData<RxDocType>,\r\n        modifier: IncrementalWriteModifier<RxDocType>\r\n    ): Promise<RxDocumentData<RxDocType>> {\r\n        const docId: string = lastKnownDocumentState[this.primaryPath] as any;\r\n        const ar = getFromMapOrCreate(this.queueByDocId, docId, () => []);\r\n        const ret = new Promise<RxDocumentData<RxDocType>>((resolve, reject) => {\r\n            const item: IncrementalWriteQueueItem<RxDocType> = {\r\n                lastKnownDocumentState,\r\n                modifier,\r\n                resolve,\r\n                reject\r\n            };\r\n            ensureNotFalsy(ar).push(item);\r\n            this.triggerRun();\r\n        });\r\n        return ret;\r\n    }\r\n\r\n    async triggerRun(): Promise<void> {\r\n        if (\r\n            this.isRunning === true ||\r\n            this.queueByDocId.size === 0\r\n        ) {\r\n            // already running\r\n            return;\r\n        }\r\n        this.isRunning = true;\r\n        const writeRows: BulkWriteRow<RxDocType>[] = [];\r\n\r\n        /**\r\n         * 'take over' so that while the async functions runs,\r\n         * new incremental updates could be added from the outside.\r\n         */\r\n        const itemsById = this.queueByDocId;\r\n        this.queueByDocId = new Map();\r\n        await Promise.all(\r\n            Array.from(itemsById.entries())\r\n                .map(async ([_docId, items]) => {\r\n                    const oldData = findNewestOfDocumentStates(\r\n                        items.map(i => i.lastKnownDocumentState)\r\n                    );\r\n                    let newData = oldData;\r\n                    for (const item of items) {\r\n                        try {\r\n                            newData = await item.modifier(\r\n                                /**\r\n                                 * We have to clone() each time because the modifier\r\n                                 * might throw while it already changed some properties\r\n                                 * of the document.\r\n                                 */\r\n                                clone(newData)\r\n                            ) as any;\r\n                        } catch (err: any) {\r\n                            item.reject(err);\r\n                            item.reject = () => { };\r\n                            item.resolve = () => { };\r\n                        }\r\n                    }\r\n\r\n                    try {\r\n                        await this.preWrite(newData, oldData);\r\n                    } catch (err: any) {\r\n                        /**\r\n                         * If the before-hooks fail,\r\n                         * we reject all of the writes because it is\r\n                         * not possible to determine which one is to blame.\r\n                         */\r\n                        items.forEach(item => item.reject(err));\r\n                        return;\r\n                    }\r\n                    writeRows.push({\r\n                        previous: oldData,\r\n                        document: newData\r\n                    });\r\n                })\r\n        );\r\n        const writeResult: RxStorageBulkWriteResponse<RxDocType> = writeRows.length > 0 ?\r\n            await this.storageInstance.bulkWrite(writeRows, 'incremental-write') :\r\n            { error: [] };\r\n\r\n        // process success\r\n        await Promise.all(\r\n            getWrittenDocumentsFromBulkWriteResponse(this.primaryPath, writeRows, writeResult).map(result => {\r\n                const docId = result[this.primaryPath] as string;\r\n                this.postWrite(result);\r\n                const items = getFromMapOrThrow(itemsById, docId);\r\n                items.forEach(item => item.resolve(result));\r\n            })\r\n        );\r\n\r\n        // process errors\r\n        writeResult.error\r\n            .forEach(error => {\r\n                const docId = error.documentId;\r\n                const items = getFromMapOrThrow(itemsById, docId);\r\n                const isConflict = isBulkWriteConflictError<RxDocType>(error);\r\n                if (isConflict) {\r\n                    // had conflict -> retry afterwards\r\n                    const ar = getFromMapOrCreate(this.queueByDocId, docId, () => []);\r\n                    /**\r\n                     * Add the items back to this.queueByDocId\r\n                     * by maintaining the original order.\r\n                     */\r\n                    items\r\n                        .reverse()\r\n                        .forEach(item => {\r\n                            item.lastKnownDocumentState = ensureNotFalsy(isConflict.documentInDb);\r\n                            ensureNotFalsy(ar).unshift(item);\r\n                        });\r\n                } else {\r\n                    // other error -> must be thrown\r\n                    const rxError = rxStorageWriteErrorToRxError(error);\r\n                    items.forEach(item => item.reject(rxError));\r\n                }\r\n            });\r\n        this.isRunning = false;\r\n\r\n        /**\r\n         * Always trigger another run\r\n         * because in between there might be new items\r\n         * been added to the queue.\r\n         */\r\n        return this.triggerRun();\r\n    }\r\n}\r\n\r\n\r\nexport function modifierFromPublicToInternal<RxDocType>(\r\n    publicModifier: ModifyFunction<RxDocType>\r\n): IncrementalWriteModifier<RxDocType> {\r\n    const ret = async (docData: RxDocumentData<RxDocType>) => {\r\n        const withoutMeta: WithDeleted<RxDocType> = stripMetaDataFromDocument(docData) as any;\r\n        withoutMeta._deleted = docData._deleted;\r\n        const modified = await publicModifier(withoutMeta);\r\n        const reattachedMeta: RxDocumentData<RxDocType> = Object.assign({}, modified, {\r\n            _meta: docData._meta,\r\n            _attachments: docData._attachments,\r\n            _rev: docData._rev,\r\n            _deleted: typeof (modified as WithDeleted<RxDocType>)._deleted !== 'undefined' ?\r\n                (modified as WithDeleted<RxDocType>)._deleted :\r\n                docData._deleted\r\n        });\r\n        if (typeof reattachedMeta._deleted === 'undefined') {\r\n            reattachedMeta._deleted = false;\r\n        }\r\n        return reattachedMeta;\r\n    };\r\n    return ret;\r\n}\r\n\r\n\r\nexport function findNewestOfDocumentStates<RxDocType>(\r\n    docs: RxDocumentData<RxDocType>[]\r\n): RxDocumentData<RxDocType> {\r\n\r\n    let newest = docs[0];\r\n    let newestRevisionHeight = getHeightOfRevision(newest._rev);\r\n    docs.forEach(doc => {\r\n        const height = getHeightOfRevision(doc._rev);\r\n        if (height > newestRevisionHeight) {\r\n            newest = doc;\r\n            newestRevisionHeight = height;\r\n        }\r\n    });\r\n    return newest;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/index.js

@@ -0,0 +1,30 @@
+/**
+ * this is the main entry-point
+ * for when the you call "import from 'rxdb'".
+ */
+
+export * from "./plugin.js";
+export * from "./rx-database.js";
+export * from "./rx-error.js";
+export * from "./rx-database-internal-store.js";
+export * from "./overwritable.js";
+export * from "./rx-collection.js";
+export * from "./rx-collection-helper.js";
+export * from "./rx-document.js";
+export * from "./rx-change-event.js";
+export * from "./rx-document-prototype-merge.js";
+export * from "./rx-query.js";
+export * from "./rx-query-single-result.js";
+export * from "./rx-query-helper.js";
+export * from "./rx-schema.js";
+export * from "./rx-schema-helper.js";
+export * from "./rx-storage-helper.js";
+export * from "./replication-protocol/index.js";
+export * from "./rx-storage-multiinstance.js";
+export * from "./custom-index.js";
+export * from "./query-planner.js";
+export * from "./plugin-helpers.js";
+export * from "./plugins/utils/index.js";
+export * from "./hooks.js";
+export * from "./query-cache.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/**\r\n * this is the main entry-point\r\n * for when the you call \"import from 'rxdb'\".\r\n */\r\n\r\nexport * from './plugin.ts';\r\nexport * from './rx-database.ts';\r\nexport * from './rx-error.ts';\r\nexport * from './rx-database-internal-store.ts';\r\nexport * from './overwritable.ts';\r\nexport * from './rx-collection.ts';\r\nexport * from './rx-collection-helper.ts';\r\nexport * from './rx-document.ts';\r\nexport * from './rx-change-event.ts';\r\nexport * from './rx-document-prototype-merge.ts';\r\nexport * from './rx-query.ts';\r\nexport * from './rx-query-single-result.ts';\r\nexport * from './rx-query-helper.ts';\r\nexport * from './rx-schema.ts';\r\nexport * from './rx-schema-helper.ts';\r\nexport * from './rx-storage-helper.ts';\r\nexport * from './replication-protocol/index.ts';\r\nexport * from './rx-storage-multiinstance.ts';\r\nexport * from './custom-index.ts';\r\nexport * from './query-planner.ts';\r\nexport * from './plugin-helpers.ts';\r\nexport * from './plugins/utils/index.ts';\r\nexport * from './hooks.ts';\r\nexport * from './query-cache.ts';\r\nexport type * from './types/index.d.ts';\r\n"],"mappings":"AAAA;AACA;AACA;AACA;;AAEA,cAAc,aAAa;AAC3B,cAAc,kBAAkB;AAChC,cAAc,eAAe;AAC7B,cAAc,iCAAiC;AAC/C,cAAc,mBAAmB;AACjC,cAAc,oBAAoB;AAClC,cAAc,2BAA2B;AACzC,cAAc,kBAAkB;AAChC,cAAc,sBAAsB;AACpC,cAAc,kCAAkC;AAChD,cAAc,eAAe;AAC7B,cAAc,6BAA6B;AAC3C,cAAc,sBAAsB;AACpC,cAAc,gBAAgB;AAC9B,cAAc,uBAAuB;AACrC,cAAc,wBAAwB;AACtC,cAAc,iCAAiC;AAC/C,cAAc,+BAA+B;AAC7C,cAAc,mBAAmB;AACjC,cAAc,oBAAoB;AAClC,cAAc,qBAAqB;AACnC,cAAc,0BAA0B;AACxC,cAAc,YAAY;AAC1B,cAAc,kBAAkB","ignoreList":[]}

package/dist/esm/overwritable.js

@@ -0,0 +1,33 @@
+/**
+ * functions that can or should be overwritten by plugins
+ * IMPORTANT: Do not import any big stuff from RxDB here!
+ * An 'overwritable' can be used inside WebWorkers for RxStorage only,
+ * and we do not want to have the full RxDB lib bundled in them.
+ */
+
+export var overwritable = {
+  /**
+   * if this method is overwritten with one
+   * that returns true, we do additional checks
+   * which help the developer but have bad performance
+   */
+  isDevMode() {
+    return false;
+  },
+  /**
+   * Deep freezes and object when in dev-mode.
+   * Deep-Freezing has the same performance as deep-cloning, so we only do that in dev-mode.
+   * Also, we can ensure the readonly state via typescript
+   * @link https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+   */
+  deepFreezeWhenDevMode(obj) {
+    return obj;
+  },
+  /**
+   * overwritten to map error-codes to text-messages
+   */
+  tunnelErrorMessage(message) {
+    return "\n        RxDB Error-Code: " + message + ".\n        Hint: Error messages are not included in RxDB core to reduce build size.\n        To show the full error messages and to ensure that you do not make any mistakes when using RxDB,\n        use the dev-mode plugin when you are in development mode: https://rxdb.info/dev-mode.html?console=error\n        ";
+  }
+};
+//# sourceMappingURL=overwritable.js.map

package/dist/esm/overwritable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overwritable.js","names":["overwritable","isDevMode","deepFreezeWhenDevMode","obj","tunnelErrorMessage","message"],"sources":["../../src/overwritable.ts"],"sourcesContent":["/**\r\n * functions that can or should be overwritten by plugins\r\n * IMPORTANT: Do not import any big stuff from RxDB here!\r\n * An 'overwritable' can be used inside WebWorkers for RxStorage only,\r\n * and we do not want to have the full RxDB lib bundled in them.\r\n */\r\n\r\nimport type { DeepReadonly } from './types/util.d.ts';\r\n\r\nexport const overwritable = {\r\n    /**\r\n     * if this method is overwritten with one\r\n     * that returns true, we do additional checks\r\n     * which help the developer but have bad performance\r\n     */\r\n    isDevMode(): boolean {\r\n        return false;\r\n    },\r\n\r\n    /**\r\n     * Deep freezes and object when in dev-mode.\r\n     * Deep-Freezing has the same performance as deep-cloning, so we only do that in dev-mode.\r\n     * Also, we can ensure the readonly state via typescript\r\n     * @link https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze\r\n     */\r\n    deepFreezeWhenDevMode<T>(obj: T): DeepReadonly<T> {\r\n        return obj as any;\r\n    },\r\n\r\n    /**\r\n     * overwritten to map error-codes to text-messages\r\n     */\r\n    tunnelErrorMessage(message: string): string {\r\n        return `\r\n        RxDB Error-Code: ${message}.\r\n        Hint: Error messages are not included in RxDB core to reduce build size.\r\n        To show the full error messages and to ensure that you do not make any mistakes when using RxDB,\r\n        use the dev-mode plugin when you are in development mode: https://rxdb.info/dev-mode.html?console=error\r\n        `;\r\n    }\r\n};\r\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;;AAIA,OAAO,IAAMA,YAAY,GAAG;EACxB;AACJ;AACA;AACA;AACA;EACIC,SAASA,CAAA,EAAY;IACjB,OAAO,KAAK;EAChB,CAAC;EAED;AACJ;AACA;AACA;AACA;AACA;EACIC,qBAAqBA,CAAIC,GAAM,EAAmB;IAC9C,OAAOA,GAAG;EACd,CAAC;EAED;AACJ;AACA;EACIC,kBAAkBA,CAACC,OAAe,EAAU;IACxC,uCACmBA,OAAO;EAK9B;AACJ,CAAC","ignoreList":[]}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module", "sideEffects": false }