@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/replication-protocol/upstream.js

@@ -0,0 +1,384 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startReplicationUpstream = startReplicationUpstream;
+var _rxjs = require("rxjs");
+var _rxStorageHelper = require("../rx-storage-helper.js");
+var _index = require("../plugins/utils/index.js");
+var _checkpoint = require("./checkpoint.js");
+var _conflicts = require("./conflicts.js");
+var _helper = require("./helper.js");
+var _metaInstance = require("./meta-instance.js");
+var _index2 = require("../plugins/attachments/index.js");
+var _rxError = require("../rx-error.js");
+/**
+ * Writes all document changes from the fork to the master.
+ * The upstream runs on two modes:
+ * - For initial replication, a checkpoint-iteration is used
+ * - For ongoing local writes, we just subscribe to the changeStream of the fork.
+ *   In contrast to the master, the fork can be assumed to never loose connection,
+ *   so we do not have to prepare for missed out events.
+ */
+async function startReplicationUpstream(state) {
+  if (state.input.initialCheckpoint && state.input.initialCheckpoint.upstream) {
+    var checkpointDoc = await (0, _checkpoint.getLastCheckpointDoc)(state, 'up');
+    if (!checkpointDoc) {
+      await (0, _checkpoint.setCheckpoint)(state, 'up', state.input.initialCheckpoint.upstream);
+    }
+  }
+  var replicationHandler = state.input.replicationHandler;
+  state.streamQueue.up = state.streamQueue.up.then(() => {
+    return upstreamInitialSync().then(() => {
+      return processTasks();
+    });
+  });
+
+  // used to detect which tasks etc can in it at which order.
+  var timer = 0;
+  var initialSyncStartTime = -1;
+  var openTasks = [];
+  var persistenceQueue = _index.PROMISE_RESOLVE_FALSE;
+  var nonPersistedFromMaster = {
+    docs: {}
+  };
+  var sub = state.input.forkInstance.changeStream().subscribe(eventBulk => {
+    if (state.events.paused.getValue()) {
+      return;
+    }
+    state.stats.up.forkChangeStreamEmit = state.stats.up.forkChangeStreamEmit + 1;
+    openTasks.push({
+      task: eventBulk,
+      time: timer++
+    });
+    if (!state.events.active.up.getValue()) {
+      state.events.active.up.next(true);
+    }
+    if (state.input.waitBeforePersist) {
+      return state.input.waitBeforePersist().then(() => processTasks());
+    } else {
+      return processTasks();
+    }
+  });
+  var subResync = replicationHandler.masterChangeStream$.pipe((0, _rxjs.filter)(ev => ev === 'RESYNC')).subscribe(() => {
+    openTasks.push({
+      task: 'RESYNC',
+      time: timer++
+    });
+    processTasks();
+  });
+
+  // unsubscribe when replication is canceled
+  (0, _rxjs.firstValueFrom)(state.events.canceled.pipe((0, _rxjs.filter)(canceled => !!canceled))).then(() => {
+    sub.unsubscribe();
+    subResync.unsubscribe();
+  });
+  async function upstreamInitialSync() {
+    state.stats.up.upstreamInitialSync = state.stats.up.upstreamInitialSync + 1;
+    if (state.events.canceled.getValue()) {
+      return;
+    }
+    state.checkpointQueue = state.checkpointQueue.then(() => (0, _checkpoint.getLastCheckpointDoc)(state, 'up'));
+    var lastCheckpoint = await state.checkpointQueue;
+    var promises = new Set();
+    var _loop = async function () {
+      initialSyncStartTime = timer++;
+
+      /**
+       * Throttle the calls to
+       * forkInstance.getChangedDocumentsSince() so that
+       * if the pushing to the remote is slower compared to the
+       * pulling out of forkInstance, we do not block the UI too much
+       * and have a big memory spike with all forkInstance documents.
+       */
+      if (promises.size > 3) {
+        await Promise.race(Array.from(promises));
+      }
+      var upResult = await (0, _rxStorageHelper.getChangedDocumentsSince)(state.input.forkInstance, state.input.pushBatchSize, lastCheckpoint);
+      if (upResult.documents.length === 0) {
+        return 1; // break
+      }
+      lastCheckpoint = (0, _rxStorageHelper.stackCheckpoints)([lastCheckpoint, upResult.checkpoint]);
+      var promise = persistToMaster(upResult.documents, (0, _index.ensureNotFalsy)(lastCheckpoint));
+      promises.add(promise);
+      promise.catch().then(() => promises.delete(promise));
+    };
+    while (!state.events.canceled.getValue()) {
+      if (await _loop()) break;
+    }
+
+    /**
+     * If we had conflicts during the initial sync,
+     * it means that we likely have new writes to the fork
+     * and so we have to run the initial sync again to upstream these new writes.
+     */
+    var resolvedPromises = await Promise.all(promises);
+    var hadConflicts = resolvedPromises.find(r => !!r);
+    if (hadConflicts) {
+      await upstreamInitialSync();
+    } else if (!state.firstSyncDone.up.getValue() && !state.events.canceled.getValue()) {
+      state.firstSyncDone.up.next(true);
+    }
+  }
+
+  /**
+   * Takes all open tasks an processes them at once.
+   */
+  function processTasks() {
+    if (state.events.canceled.getValue() || openTasks.length === 0) {
+      state.events.active.up.next(false);
+      return;
+    }
+    state.stats.up.processTasks = state.stats.up.processTasks + 1;
+    state.events.active.up.next(true);
+    state.streamQueue.up = state.streamQueue.up.then(async () => {
+      /**
+       * Merge/filter all open tasks
+       */
+      var docs = [];
+      var checkpoint;
+      while (openTasks.length > 0) {
+        var taskWithTime = (0, _index.ensureNotFalsy)(openTasks.shift());
+        /**
+         * If the task came in before the last time the initial sync fetching
+         * has run, we can ignore the task because the initial sync already processed
+         * these documents.
+         */
+        if (taskWithTime.time < initialSyncStartTime) {
+          continue;
+        }
+        if (taskWithTime.task === 'RESYNC') {
+          state.events.active.up.next(false);
+          await upstreamInitialSync();
+          return;
+        }
+
+        /**
+         * If the task came from the downstream, we can ignore these documents
+         * because we know they are replicated already.
+         * But even if they can be ignored, we later have to call persistToMaster()
+         * to have the correct checkpoint set.
+         */
+        if (taskWithTime.task.context !== (await state.downstreamBulkWriteFlag)) {
+          docs = docs.concat(taskWithTime.task.events.map(r => {
+            return r.documentData;
+          }));
+        }
+        checkpoint = (0, _rxStorageHelper.stackCheckpoints)([checkpoint, taskWithTime.task.checkpoint]);
+      }
+      await persistToMaster(docs, checkpoint);
+
+      // might have got more tasks while running persistToMaster()
+      if (openTasks.length === 0) {
+        state.events.active.up.next(false);
+      } else {
+        return processTasks();
+      }
+    });
+  }
+
+  /**
+   * Returns true if had conflicts,
+   * false if not.
+   */
+  function persistToMaster(docs, checkpoint) {
+    state.stats.up.persistToMaster = state.stats.up.persistToMaster + 1;
+
+    /**
+     * Add the new docs to the non-persistent list
+     */
+    docs.forEach(docData => {
+      var docId = docData[state.primaryPath];
+      nonPersistedFromMaster.docs[docId] = docData;
+    });
+    nonPersistedFromMaster.checkpoint = checkpoint;
+    persistenceQueue = persistenceQueue.then(async () => {
+      if (state.events.canceled.getValue()) {
+        return false;
+      }
+      var upDocsById = nonPersistedFromMaster.docs;
+      nonPersistedFromMaster.docs = {};
+      var useCheckpoint = nonPersistedFromMaster.checkpoint;
+      var docIds = Object.keys(upDocsById);
+      /**
+       * Even if we do not have anything to push,
+       * we still have to store the up-checkpoint.
+       * This ensures that when many documents have been pulled
+       * from the remote (that do not have to be pushed again),
+       * we continue at the correct position and do not have to load
+       * these documents from the storage again when the replication is restarted.
+       */
+      function rememberCheckpointBeforeReturn() {
+        return (0, _checkpoint.setCheckpoint)(state, 'up', useCheckpoint);
+      }
+      ;
+      if (docIds.length === 0) {
+        rememberCheckpointBeforeReturn();
+        return false;
+      }
+      var assumedMasterState = await (0, _metaInstance.getAssumedMasterState)(state, docIds);
+      var writeRowsToMaster = {};
+      var writeRowsToMasterIds = [];
+      var writeRowsToMeta = {};
+      var forkStateById = {};
+      await Promise.all(docIds.map(async docId => {
+        var fullDocData = upDocsById[docId];
+        forkStateById[docId] = fullDocData;
+        var docData = (0, _helper.writeDocToDocState)(fullDocData, state.hasAttachments, !!state.input.keepMeta);
+        var assumedMasterDoc = assumedMasterState[docId];
+
+        /**
+         * If the master state is equal to the
+         * fork state, we can assume that the document state is already
+         * replicated.
+         */
+        if (assumedMasterDoc &&
+        // if the isResolvedConflict is correct, we do not have to compare the documents.
+        assumedMasterDoc.metaDocument.isResolvedConflict !== fullDocData._rev && state.input.conflictHandler.isEqual(assumedMasterDoc.docData, docData, 'upstream-check-if-equal') || (
+        /**
+         * If the master works with _rev fields,
+         * we use that to check if our current doc state
+         * is different from the assumedMasterDoc.
+         */
+
+        assumedMasterDoc && assumedMasterDoc.docData._rev && (0, _index.getHeightOfRevision)(fullDocData._rev) === fullDocData._meta[state.input.identifier])) {
+          return;
+        }
+        writeRowsToMasterIds.push(docId);
+        writeRowsToMaster[docId] = {
+          assumedMasterState: assumedMasterDoc ? assumedMasterDoc.docData : undefined,
+          newDocumentState: docData
+        };
+        writeRowsToMeta[docId] = await (0, _metaInstance.getMetaWriteRow)(state, docData, assumedMasterDoc ? assumedMasterDoc.metaDocument : undefined);
+      }));
+      if (writeRowsToMasterIds.length === 0) {
+        rememberCheckpointBeforeReturn();
+        return false;
+      }
+      var writeRowsArray = Object.values(writeRowsToMaster);
+      var conflictIds = new Set();
+      var conflictsById = {};
+
+      /**
+       * To always respect the push.batchSize,
+       * we have to split the write rows into batches
+       * to ensure that replicationHandler.masterWrite() is never
+       * called with more documents than what the batchSize limits.
+       */
+      var writeBatches = (0, _index.batchArray)(writeRowsArray, state.input.pushBatchSize);
+      await Promise.all(writeBatches.map(async writeBatch => {
+        // enhance docs with attachments
+        if (state.hasAttachments) {
+          await Promise.all(writeBatch.map(async row => {
+            row.newDocumentState = await (0, _index2.fillWriteDataForAttachmentsChange)(state.primaryPath, state.input.forkInstance, (0, _index.clone)(row.newDocumentState), row.assumedMasterState);
+          }));
+        }
+        var masterWriteResult = await replicationHandler.masterWrite(writeBatch);
+        masterWriteResult.forEach(conflictDoc => {
+          var id = conflictDoc[state.primaryPath];
+          conflictIds.add(id);
+          conflictsById[id] = conflictDoc;
+        });
+      }));
+      var useWriteRowsToMeta = [];
+      writeRowsToMasterIds.forEach(docId => {
+        if (!conflictIds.has(docId)) {
+          state.events.processed.up.next(writeRowsToMaster[docId]);
+          useWriteRowsToMeta.push(writeRowsToMeta[docId]);
+        }
+      });
+      if (state.events.canceled.getValue()) {
+        return false;
+      }
+      if (!state.skipStoringPullMeta && useWriteRowsToMeta.length > 0) {
+        await state.input.metaInstance.bulkWrite((0, _helper.stripAttachmentsDataFromMetaWriteRows)(state, useWriteRowsToMeta), 'replication-up-write-meta');
+        // TODO what happens when we have conflicts here?
+      }
+
+      /**
+       * Resolve conflicts by writing a new document
+       * state to the fork instance and the 'real' master state
+       * to the meta instance.
+       * Non-409 errors will be detected by resolveConflictError()
+       */
+      var hadConflictWrites = false;
+      if (conflictIds.size > 0) {
+        state.stats.up.persistToMasterHadConflicts = state.stats.up.persistToMasterHadConflicts + 1;
+        var conflictWriteFork = [];
+        var conflictWriteMeta = {};
+        await Promise.all(Object.entries(conflictsById).map(([docId, realMasterState]) => {
+          var writeToMasterRow = writeRowsToMaster[docId];
+          var input = {
+            newDocumentState: writeToMasterRow.newDocumentState,
+            assumedMasterState: writeToMasterRow.assumedMasterState,
+            realMasterState
+          };
+          return (0, _conflicts.resolveConflictError)(state, input, forkStateById[docId]).then(async resolved => {
+            if (resolved) {
+              state.events.resolvedConflicts.next({
+                input,
+                output: resolved
+              });
+              conflictWriteFork.push({
+                previous: forkStateById[docId],
+                document: resolved
+              });
+              var assumedMasterDoc = assumedMasterState[docId];
+              conflictWriteMeta[docId] = await (0, _metaInstance.getMetaWriteRow)(state, (0, _index.ensureNotFalsy)(realMasterState), assumedMasterDoc ? assumedMasterDoc.metaDocument : undefined, resolved._rev);
+            }
+          });
+        }));
+        if (conflictWriteFork.length > 0) {
+          hadConflictWrites = true;
+          state.stats.up.persistToMasterConflictWrites = state.stats.up.persistToMasterConflictWrites + 1;
+          var forkWriteResult = await state.input.forkInstance.bulkWrite(conflictWriteFork, 'replication-up-write-conflict');
+          var mustThrow;
+          forkWriteResult.error.forEach(error => {
+            /**
+             * Conflict-Errors in the forkWriteResult must not be handled
+             * because they have been caused by a write to the forkInstance
+             * in between which will anyway trigger a new upstream cycle
+             * that will then resolved the conflict again.
+             */
+            if (error.status === 409) {
+              return;
+            }
+            // other non-conflict errors must be handled
+            var throwMe = (0, _rxError.newRxError)('RC_PUSH', {
+              writeError: error
+            });
+            state.events.error.next(throwMe);
+            mustThrow = throwMe;
+          });
+          if (mustThrow) {
+            throw mustThrow;
+          }
+          var useMetaWrites = [];
+          var success = (0, _rxStorageHelper.getWrittenDocumentsFromBulkWriteResponse)(state.primaryPath, conflictWriteFork, forkWriteResult);
+          success.forEach(docData => {
+            var docId = docData[state.primaryPath];
+            useMetaWrites.push(conflictWriteMeta[docId]);
+          });
+          if (useMetaWrites.length > 0) {
+            await state.input.metaInstance.bulkWrite((0, _helper.stripAttachmentsDataFromMetaWriteRows)(state, useMetaWrites), 'replication-up-write-conflict-meta');
+          }
+          // TODO what to do with conflicts while writing to the metaInstance?
+        }
+      }
+
+      /**
+       * For better performance we do not await checkpoint writes,
+       * but to ensure order on parallel checkpoint writes,
+       * we have to use a queue.
+       */
+      rememberCheckpointBeforeReturn();
+      return hadConflictWrites;
+    }).catch(unhandledError => {
+      state.events.error.next(unhandledError);
+      return false;
+    });
+    return persistenceQueue;
+  }
+}
+//# sourceMappingURL=upstream.js.map

package/dist/cjs/replication-protocol/upstream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstream.js","names":["_rxjs","require","_rxStorageHelper","_index","_checkpoint","_conflicts","_helper","_metaInstance","_index2","_rxError","startReplicationUpstream","state","input","initialCheckpoint","upstream","checkpointDoc","getLastCheckpointDoc","setCheckpoint","replicationHandler","streamQueue","up","then","upstreamInitialSync","processTasks","timer","initialSyncStartTime","openTasks","persistenceQueue","PROMISE_RESOLVE_FALSE","nonPersistedFromMaster","docs","sub","forkInstance","changeStream","subscribe","eventBulk","events","paused","getValue","stats","forkChangeStreamEmit","push","task","time","active","next","waitBeforePersist","subResync","masterChangeStream$","pipe","filter","ev","firstValueFrom","canceled","unsubscribe","checkpointQueue","lastCheckpoint","promises","Set","_loop","size","Promise","race","Array","from","upResult","getChangedDocumentsSince","pushBatchSize","documents","length","stackCheckpoints","checkpoint","promise","persistToMaster","ensureNotFalsy","add","catch","delete","resolvedPromises","all","hadConflicts","find","r","firstSyncDone","taskWithTime","shift","context","downstreamBulkWriteFlag","concat","map","documentData","forEach","docData","docId","primaryPath","upDocsById","useCheckpoint","docIds","Object","keys","rememberCheckpointBeforeReturn","assumedMasterState","getAssumedMasterState","writeRowsToMaster","writeRowsToMasterIds","writeRowsToMeta","forkStateById","fullDocData","writeDocToDocState","hasAttachments","keepMeta","assumedMasterDoc","metaDocument","isResolvedConflict","_rev","conflictHandler","isEqual","getHeightOfRevision","_meta","identifier","undefined","newDocumentState","getMetaWriteRow","writeRowsArray","values","conflictIds","conflictsById","writeBatches","batchArray","writeBatch","row","fillWriteDataForAttachmentsChange","clone","masterWriteResult","masterWrite","conflictDoc","id","useWriteRowsToMeta","has","processed","skipStoringPullMeta","metaInstance","bulkWrite","stripAttachmentsDataFromMetaWriteRows","hadConflictWrites","persistToMasterHadConflicts","conflictWriteFork","conflictWriteMeta","entries","realMasterState","writeToMasterRow","resolveConflictError","resolved","resolvedConflicts","output","previous","document","persistToMasterConflictWrites","forkWriteResult","mustThrow","error","status","throwMe","newRxError","writeError","useMetaWrites","success","getWrittenDocumentsFromBulkWriteResponse","unhandledError"],"sources":["../../../src/replication-protocol/upstream.ts"],"sourcesContent":["import { firstValueFrom, filter } from 'rxjs';\r\nimport {\r\n    getChangedDocumentsSince,\r\n    getWrittenDocumentsFromBulkWriteResponse,\r\n    stackCheckpoints\r\n} from '../rx-storage-helper.ts';\r\nimport type {\r\n    BulkWriteRow,\r\n    BulkWriteRowById,\r\n    ById,\r\n    EventBulk,\r\n    RxDocumentData,\r\n    RxError,\r\n    RxReplicationWriteToMasterRow,\r\n    RxStorageChangeEvent,\r\n    RxStorageInstanceReplicationState,\r\n    RxStorageReplicationMeta,\r\n    WithDeleted\r\n} from '../types/index.d.ts';\r\nimport {\r\n    batchArray,\r\n    clone,\r\n    ensureNotFalsy,\r\n    getHeightOfRevision,\r\n    PROMISE_RESOLVE_FALSE\r\n} from '../plugins/utils/index.ts';\r\nimport {\r\n    getLastCheckpointDoc,\r\n    setCheckpoint\r\n} from './checkpoint.ts';\r\nimport {\r\n    resolveConflictError\r\n} from './conflicts.ts';\r\nimport {\r\n    stripAttachmentsDataFromMetaWriteRows,\r\n    writeDocToDocState\r\n} from './helper.ts';\r\nimport {\r\n    getAssumedMasterState,\r\n    getMetaWriteRow\r\n} from './meta-instance.ts';\r\nimport { fillWriteDataForAttachmentsChange } from '../plugins/attachments/index.ts';\r\nimport { newRxError } from '../rx-error.ts';\r\n\r\n/**\r\n * Writes all document changes from the fork to the master.\r\n * The upstream runs on two modes:\r\n * - For initial replication, a checkpoint-iteration is used\r\n * - For ongoing local writes, we just subscribe to the changeStream of the fork.\r\n *   In contrast to the master, the fork can be assumed to never loose connection,\r\n *   so we do not have to prepare for missed out events.\r\n */\r\nexport async function startReplicationUpstream<RxDocType, CheckpointType>(\r\n    state: RxStorageInstanceReplicationState<RxDocType>\r\n) {\r\n    if (\r\n        state.input.initialCheckpoint &&\r\n        state.input.initialCheckpoint.upstream\r\n    ) {\r\n        const checkpointDoc = await getLastCheckpointDoc(state, 'up');\r\n        if (!checkpointDoc) {\r\n            await setCheckpoint(\r\n                state,\r\n                'up',\r\n                state.input.initialCheckpoint.upstream\r\n            );\r\n        }\r\n    }\r\n\r\n    const replicationHandler = state.input.replicationHandler;\r\n    state.streamQueue.up = state.streamQueue.up.then(() => {\r\n        return upstreamInitialSync().then(() => {\r\n            return processTasks();\r\n        });\r\n    });\r\n\r\n    // used to detect which tasks etc can in it at which order.\r\n    let timer = 0;\r\n    let initialSyncStartTime = -1;\r\n\r\n    type Task = EventBulk<RxStorageChangeEvent<RxDocType>, any> | 'RESYNC';\r\n    type TaskWithTime = {\r\n        task: Task;\r\n        time: number;\r\n    };\r\n    const openTasks: TaskWithTime[] = [];\r\n    let persistenceQueue: Promise<boolean> = PROMISE_RESOLVE_FALSE;\r\n    const nonPersistedFromMaster: {\r\n        checkpoint?: CheckpointType;\r\n        docs: ById<RxDocumentData<RxDocType>>;\r\n    } = {\r\n        docs: {}\r\n    };\r\n\r\n    const sub = state.input.forkInstance.changeStream()\r\n        .subscribe((eventBulk: EventBulk<RxStorageChangeEvent<RxDocType>, any>) => {\r\n            if (state.events.paused.getValue()) {\r\n                return;\r\n            }\r\n\r\n\r\n            state.stats.up.forkChangeStreamEmit = state.stats.up.forkChangeStreamEmit + 1;\r\n            openTasks.push({\r\n                task: eventBulk,\r\n                time: timer++\r\n            });\r\n            if (!state.events.active.up.getValue()) {\r\n                state.events.active.up.next(true);\r\n            }\r\n            if (state.input.waitBeforePersist) {\r\n                return state.input.waitBeforePersist()\r\n                    .then(() => processTasks());\r\n            } else {\r\n                return processTasks();\r\n            }\r\n        });\r\n    const subResync = replicationHandler\r\n        .masterChangeStream$\r\n        .pipe(\r\n            filter((ev: any) => ev === 'RESYNC')\r\n        )\r\n        .subscribe(() => {\r\n            openTasks.push({\r\n                task: 'RESYNC',\r\n                time: timer++\r\n            });\r\n            processTasks();\r\n        });\r\n\r\n    // unsubscribe when replication is canceled\r\n    firstValueFrom(\r\n        state.events.canceled.pipe(\r\n            filter((canceled: boolean) => !!canceled)\r\n        )\r\n    ).then(() => {\r\n        sub.unsubscribe();\r\n        subResync.unsubscribe();\r\n    });\r\n\r\n\r\n    async function upstreamInitialSync() {\r\n        state.stats.up.upstreamInitialSync = state.stats.up.upstreamInitialSync + 1;\r\n        if (state.events.canceled.getValue()) {\r\n            return;\r\n        }\r\n\r\n        state.checkpointQueue = state.checkpointQueue.then(() => getLastCheckpointDoc(state, 'up'));\r\n        let lastCheckpoint: CheckpointType = await state.checkpointQueue;\r\n\r\n        const promises: Set<Promise<any>> = new Set();\r\n\r\n        while (!state.events.canceled.getValue()) {\r\n            initialSyncStartTime = timer++;\r\n\r\n            /**\r\n             * Throttle the calls to\r\n             * forkInstance.getChangedDocumentsSince() so that\r\n             * if the pushing to the remote is slower compared to the\r\n             * pulling out of forkInstance, we do not block the UI too much\r\n             * and have a big memory spike with all forkInstance documents.\r\n             */\r\n            if (promises.size > 3) {\r\n                await Promise.race(Array.from(promises));\r\n            }\r\n            const upResult = await getChangedDocumentsSince(\r\n                state.input.forkInstance,\r\n                state.input.pushBatchSize,\r\n                lastCheckpoint\r\n            );\r\n            if (upResult.documents.length === 0) {\r\n                break;\r\n            }\r\n\r\n            lastCheckpoint = stackCheckpoints([lastCheckpoint, upResult.checkpoint]);\r\n\r\n            const promise = persistToMaster(\r\n                upResult.documents,\r\n                ensureNotFalsy(lastCheckpoint)\r\n            );\r\n            promises.add(promise);\r\n            promise.catch().then(() => promises.delete(promise));\r\n        }\r\n\r\n        /**\r\n         * If we had conflicts during the initial sync,\r\n         * it means that we likely have new writes to the fork\r\n         * and so we have to run the initial sync again to upstream these new writes.\r\n         */\r\n        const resolvedPromises = await Promise.all(promises);\r\n        const hadConflicts = resolvedPromises.find(r => !!r);\r\n        if (hadConflicts) {\r\n            await upstreamInitialSync();\r\n        } else if (\r\n            !state.firstSyncDone.up.getValue() &&\r\n            !state.events.canceled.getValue()\r\n        ) {\r\n            state.firstSyncDone.up.next(true);\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Takes all open tasks an processes them at once.\r\n     */\r\n    function processTasks() {\r\n        if (\r\n            state.events.canceled.getValue() ||\r\n            openTasks.length === 0\r\n        ) {\r\n            state.events.active.up.next(false);\r\n            return;\r\n        }\r\n        state.stats.up.processTasks = state.stats.up.processTasks + 1;\r\n        state.events.active.up.next(true);\r\n        state.streamQueue.up = state.streamQueue.up.then(async () => {\r\n            /**\r\n             * Merge/filter all open tasks\r\n             */\r\n            let docs: RxDocumentData<RxDocType>[] = [];\r\n            let checkpoint: CheckpointType | undefined;\r\n            while (openTasks.length > 0) {\r\n                const taskWithTime = ensureNotFalsy(openTasks.shift());\r\n                /**\r\n                 * If the task came in before the last time the initial sync fetching\r\n                 * has run, we can ignore the task because the initial sync already processed\r\n                 * these documents.\r\n                 */\r\n                if (taskWithTime.time < initialSyncStartTime) {\r\n                    continue;\r\n                }\r\n\r\n                if (taskWithTime.task === 'RESYNC') {\r\n                    state.events.active.up.next(false);\r\n                    await upstreamInitialSync();\r\n                    return;\r\n                }\r\n\r\n                /**\r\n                 * If the task came from the downstream, we can ignore these documents\r\n                 * because we know they are replicated already.\r\n                 * But even if they can be ignored, we later have to call persistToMaster()\r\n                 * to have the correct checkpoint set.\r\n                 */\r\n                if (taskWithTime.task.context !== await state.downstreamBulkWriteFlag) {\r\n                    docs = docs.concat(taskWithTime.task.events.map(r => {\r\n                        return r.documentData as any;\r\n                    }));\r\n                }\r\n                checkpoint = stackCheckpoints([checkpoint, taskWithTime.task.checkpoint]);\r\n            }\r\n\r\n            await persistToMaster(\r\n                docs,\r\n                checkpoint as any\r\n            );\r\n\r\n            // might have got more tasks while running persistToMaster()\r\n            if (openTasks.length === 0) {\r\n                state.events.active.up.next(false);\r\n            } else {\r\n                return processTasks();\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Returns true if had conflicts,\r\n     * false if not.\r\n     */\r\n    function persistToMaster(\r\n        docs: RxDocumentData<RxDocType>[],\r\n        checkpoint: CheckpointType\r\n    ): Promise<boolean> {\r\n        state.stats.up.persistToMaster = state.stats.up.persistToMaster + 1;\r\n\r\n        /**\r\n         * Add the new docs to the non-persistent list\r\n         */\r\n        docs.forEach(docData => {\r\n            const docId: string = (docData as any)[state.primaryPath];\r\n            nonPersistedFromMaster.docs[docId] = docData;\r\n        });\r\n        nonPersistedFromMaster.checkpoint = checkpoint;\r\n\r\n        persistenceQueue = persistenceQueue.then(async () => {\r\n            if (state.events.canceled.getValue()) {\r\n                return false;\r\n            }\r\n\r\n            const upDocsById: ById<RxDocumentData<RxDocType>> = nonPersistedFromMaster.docs;\r\n            nonPersistedFromMaster.docs = {};\r\n            const useCheckpoint = nonPersistedFromMaster.checkpoint;\r\n            const docIds = Object.keys(upDocsById);\r\n            /**\r\n             * Even if we do not have anything to push,\r\n             * we still have to store the up-checkpoint.\r\n             * This ensures that when many documents have been pulled\r\n             * from the remote (that do not have to be pushed again),\r\n             * we continue at the correct position and do not have to load\r\n             * these documents from the storage again when the replication is restarted.\r\n             */\r\n            function rememberCheckpointBeforeReturn() {\r\n                return setCheckpoint(\r\n                    state,\r\n                    'up',\r\n                    useCheckpoint\r\n                );\r\n            };\r\n\r\n\r\n            if (docIds.length === 0) {\r\n                rememberCheckpointBeforeReturn();\r\n                return false;\r\n            }\r\n\r\n            const assumedMasterState = await getAssumedMasterState(\r\n                state,\r\n                docIds\r\n            );\r\n\r\n            const writeRowsToMaster: ById<RxReplicationWriteToMasterRow<RxDocType>> = {};\r\n            const writeRowsToMasterIds: string[] = [];\r\n            const writeRowsToMeta: BulkWriteRowById<RxStorageReplicationMeta<RxDocType, any>> = {};\r\n            const forkStateById: ById<RxDocumentData<RxDocType>> = {};\r\n\r\n            await Promise.all(\r\n                docIds.map(async (docId) => {\r\n                    const fullDocData: RxDocumentData<RxDocType> = upDocsById[docId];\r\n                    forkStateById[docId] = fullDocData;\r\n                    const docData: WithDeleted<RxDocType> = writeDocToDocState(fullDocData, state.hasAttachments, !!state.input.keepMeta);\r\n                    const assumedMasterDoc = assumedMasterState[docId];\r\n\r\n                    /**\r\n                     * If the master state is equal to the\r\n                     * fork state, we can assume that the document state is already\r\n                     * replicated.\r\n                     */\r\n                    if (\r\n                        (\r\n                            assumedMasterDoc &&\r\n                            // if the isResolvedConflict is correct, we do not have to compare the documents.\r\n                            assumedMasterDoc.metaDocument.isResolvedConflict !== fullDocData._rev\r\n                            &&\r\n                            (\r\n                                state.input.conflictHandler.isEqual(\r\n                                    assumedMasterDoc.docData,\r\n                                    docData,\r\n                                    'upstream-check-if-equal'\r\n                                )\r\n                            )\r\n                        )\r\n                        ||\r\n                        /**\r\n                         * If the master works with _rev fields,\r\n                         * we use that to check if our current doc state\r\n                         * is different from the assumedMasterDoc.\r\n                         */\r\n                        (\r\n                            assumedMasterDoc &&\r\n                            (assumedMasterDoc.docData as any)._rev &&\r\n                            getHeightOfRevision(fullDocData._rev) === fullDocData._meta[state.input.identifier]\r\n                        )\r\n                    ) {\r\n                        return;\r\n                    }\r\n\r\n                    writeRowsToMasterIds.push(docId);\r\n\r\n                    writeRowsToMaster[docId] = {\r\n                        assumedMasterState: assumedMasterDoc ? assumedMasterDoc.docData : undefined,\r\n                        newDocumentState: docData\r\n                    };\r\n                    writeRowsToMeta[docId] = await getMetaWriteRow(\r\n                        state,\r\n                        docData,\r\n                        assumedMasterDoc ? assumedMasterDoc.metaDocument : undefined\r\n                    );\r\n                })\r\n            );\r\n\r\n            if (writeRowsToMasterIds.length === 0) {\r\n                rememberCheckpointBeforeReturn();\r\n                return false;\r\n            }\r\n\r\n\r\n            const writeRowsArray = Object.values(writeRowsToMaster);\r\n            const conflictIds: Set<string> = new Set();\r\n            const conflictsById: ById<WithDeleted<RxDocType>> = {};\r\n\r\n            /**\r\n             * To always respect the push.batchSize,\r\n             * we have to split the write rows into batches\r\n             * to ensure that replicationHandler.masterWrite() is never\r\n             * called with more documents than what the batchSize limits.\r\n             */\r\n            const writeBatches = batchArray(writeRowsArray, state.input.pushBatchSize);\r\n            await Promise.all(\r\n                writeBatches.map(async (writeBatch) => {\r\n\r\n                    // enhance docs with attachments\r\n                    if (state.hasAttachments) {\r\n                        await Promise.all(\r\n                            writeBatch.map(async (row) => {\r\n                                row.newDocumentState = await fillWriteDataForAttachmentsChange(\r\n                                    state.primaryPath,\r\n                                    state.input.forkInstance,\r\n                                    clone(row.newDocumentState),\r\n                                    row.assumedMasterState\r\n                                );\r\n                            })\r\n                        );\r\n                    }\r\n                    const masterWriteResult = await replicationHandler.masterWrite(writeBatch);\r\n                    masterWriteResult.forEach(conflictDoc => {\r\n                        const id = (conflictDoc as any)[state.primaryPath];\r\n                        conflictIds.add(id);\r\n                        conflictsById[id] = conflictDoc;\r\n                    });\r\n                })\r\n            );\r\n\r\n            const useWriteRowsToMeta: BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>[] = [];\r\n\r\n            writeRowsToMasterIds.forEach(docId => {\r\n                if (!conflictIds.has(docId)) {\r\n                    state.events.processed.up.next(writeRowsToMaster[docId]);\r\n                    useWriteRowsToMeta.push(writeRowsToMeta[docId]);\r\n                }\r\n            });\r\n\r\n            if (state.events.canceled.getValue()) {\r\n                return false;\r\n            }\r\n\r\n            if (!state.skipStoringPullMeta && useWriteRowsToMeta.length > 0) {\r\n                await state.input.metaInstance.bulkWrite(\r\n                    stripAttachmentsDataFromMetaWriteRows(state, useWriteRowsToMeta),\r\n                    'replication-up-write-meta'\r\n                );\r\n                // TODO what happens when we have conflicts here?\r\n            }\r\n\r\n            /**\r\n             * Resolve conflicts by writing a new document\r\n             * state to the fork instance and the 'real' master state\r\n             * to the meta instance.\r\n             * Non-409 errors will be detected by resolveConflictError()\r\n             */\r\n            let hadConflictWrites = false;\r\n            if (conflictIds.size > 0) {\r\n                state.stats.up.persistToMasterHadConflicts = state.stats.up.persistToMasterHadConflicts + 1;\r\n                const conflictWriteFork: BulkWriteRow<RxDocType>[] = [];\r\n                const conflictWriteMeta: BulkWriteRowById<RxStorageReplicationMeta<RxDocType, any>> = {};\r\n                await Promise.all(\r\n                    Object\r\n                        .entries(conflictsById)\r\n                        .map(([docId, realMasterState]) => {\r\n                            const writeToMasterRow = writeRowsToMaster[docId];\r\n                            const input = {\r\n                                newDocumentState: writeToMasterRow.newDocumentState,\r\n                                assumedMasterState: writeToMasterRow.assumedMasterState,\r\n                                realMasterState\r\n                            };\r\n                            return resolveConflictError(\r\n                                state,\r\n                                input,\r\n                                forkStateById[docId]\r\n                            ).then(async (resolved) => {\r\n                                if (resolved) {\r\n                                    state.events.resolvedConflicts.next({\r\n                                        input,\r\n                                        output: resolved\r\n                                    });\r\n                                    conflictWriteFork.push({\r\n                                        previous: forkStateById[docId],\r\n                                        document: resolved\r\n                                    });\r\n                                    const assumedMasterDoc = assumedMasterState[docId];\r\n                                    conflictWriteMeta[docId] = await getMetaWriteRow(\r\n                                        state,\r\n                                        ensureNotFalsy(realMasterState),\r\n                                        assumedMasterDoc ? assumedMasterDoc.metaDocument : undefined,\r\n                                        resolved._rev\r\n                                    );\r\n                                }\r\n                            });\r\n                        })\r\n                );\r\n\r\n                if (conflictWriteFork.length > 0) {\r\n                    hadConflictWrites = true;\r\n\r\n                    state.stats.up.persistToMasterConflictWrites = state.stats.up.persistToMasterConflictWrites + 1;\r\n                    const forkWriteResult = await state.input.forkInstance.bulkWrite(\r\n                        conflictWriteFork,\r\n                        'replication-up-write-conflict'\r\n                    );\r\n\r\n                    let mustThrow: RxError | undefined;\r\n                    forkWriteResult.error.forEach(error => {\r\n                        /**\r\n                         * Conflict-Errors in the forkWriteResult must not be handled\r\n                         * because they have been caused by a write to the forkInstance\r\n                         * in between which will anyway trigger a new upstream cycle\r\n                         * that will then resolved the conflict again.\r\n                         */\r\n                        if (error.status === 409) {\r\n                            return;\r\n                        }\r\n                        // other non-conflict errors must be handled\r\n                        const throwMe = newRxError('RC_PUSH', {\r\n                            writeError: error\r\n                        });\r\n                        state.events.error.next(throwMe);\r\n                        mustThrow = throwMe;\r\n                    });\r\n                    if (mustThrow) {\r\n                        throw mustThrow;\r\n                    }\r\n\r\n                    const useMetaWrites: BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>[] = [];\r\n                    const success = getWrittenDocumentsFromBulkWriteResponse(\r\n                        state.primaryPath,\r\n                        conflictWriteFork,\r\n                        forkWriteResult\r\n                    );\r\n                    success\r\n                        .forEach(docData => {\r\n                            const docId = (docData as any)[state.primaryPath];\r\n                            useMetaWrites.push(\r\n                                conflictWriteMeta[docId]\r\n                            );\r\n                        });\r\n                    if (useMetaWrites.length > 0) {\r\n                        await state.input.metaInstance.bulkWrite(\r\n                            stripAttachmentsDataFromMetaWriteRows(state, useMetaWrites),\r\n                            'replication-up-write-conflict-meta'\r\n                        );\r\n                    }\r\n                    // TODO what to do with conflicts while writing to the metaInstance?\r\n                }\r\n            }\r\n\r\n            /**\r\n             * For better performance we do not await checkpoint writes,\r\n             * but to ensure order on parallel checkpoint writes,\r\n             * we have to use a queue.\r\n             */\r\n            rememberCheckpointBeforeReturn();\r\n\r\n            return hadConflictWrites;\r\n        }).catch(unhandledError => {\r\n            state.events.error.next(unhandledError);\r\n            return false;\r\n        });\r\n\r\n        return persistenceQueue;\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/rx-change-event.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenEvents = flattenEvents;
+exports.getDocumentDataOfRxChangeEvent = getDocumentDataOfRxChangeEvent;
+exports.rxChangeEventBulkToRxChangeEvents = rxChangeEventBulkToRxChangeEvents;
+exports.rxChangeEventToEventReduceChangeEvent = rxChangeEventToEventReduceChangeEvent;
+var _overwritable = require("./overwritable.js");
+var _index = require("./plugins/utils/index.js");
+/**
+ * RxChangeEvents a emitted when something in the database changes
+ * they can be grabbed by the observables of database, collection and document
+ */
+
+function getDocumentDataOfRxChangeEvent(rxChangeEvent) {
+  if (rxChangeEvent.documentData) {
+    return rxChangeEvent.documentData;
+  } else {
+    return rxChangeEvent.previousDocumentData;
+  }
+}
+
+/**
+ * Might return null which means an
+ * already deleted document got modified but still is deleted.
+ * These kind of events are not relevant for the event-reduce algorithm
+ * and must be filtered out.
+ */
+function rxChangeEventToEventReduceChangeEvent(rxChangeEvent) {
+  switch (rxChangeEvent.operation) {
+    case 'INSERT':
+      return {
+        operation: rxChangeEvent.operation,
+        id: rxChangeEvent.documentId,
+        doc: rxChangeEvent.documentData,
+        previous: null
+      };
+    case 'UPDATE':
+      return {
+        operation: rxChangeEvent.operation,
+        id: rxChangeEvent.documentId,
+        doc: _overwritable.overwritable.deepFreezeWhenDevMode(rxChangeEvent.documentData),
+        previous: rxChangeEvent.previousDocumentData ? rxChangeEvent.previousDocumentData : 'UNKNOWN'
+      };
+    case 'DELETE':
+      return {
+        operation: rxChangeEvent.operation,
+        id: rxChangeEvent.documentId,
+        doc: null,
+        previous: rxChangeEvent.previousDocumentData
+      };
+  }
+}
+
+/**
+ * Flattens the given events into a single array of events.
+ * Used mostly in tests.
+ */
+function flattenEvents(input) {
+  var output = [];
+  if (Array.isArray(input)) {
+    input.forEach(inputItem => {
+      var add = flattenEvents(inputItem);
+      output = output.concat(add);
+    });
+  } else {
+    if (input.id && input.events) {
+      // is bulk
+      input.events.forEach(ev => output.push(ev));
+    } else {
+      output.push(input);
+    }
+  }
+  var usedIds = new Set();
+  var nonDuplicate = [];
+  function getEventId(ev) {
+    return [ev.documentId, ev.documentData ? ev.documentData._rev : '', ev.previousDocumentData ? ev.previousDocumentData._rev : ''].join('|');
+  }
+  output.forEach(ev => {
+    var eventId = getEventId(ev);
+    if (!usedIds.has(eventId)) {
+      usedIds.add(eventId);
+      nonDuplicate.push(ev);
+    }
+  });
+  return nonDuplicate;
+}
+var EVENT_BULK_CACHE = new Map();
+function rxChangeEventBulkToRxChangeEvents(eventBulk) {
+  return (0, _index.getFromMapOrCreate)(EVENT_BULK_CACHE, eventBulk, () => {
+    var events = new Array(eventBulk.events.length);
+    var rawEvents = eventBulk.events;
+    var collectionName = eventBulk.collectionName;
+    var isLocal = eventBulk.isLocal;
+    var deepFreezeWhenDevMode = _overwritable.overwritable.deepFreezeWhenDevMode;
+    for (var index = 0; index < rawEvents.length; index++) {
+      var event = rawEvents[index];
+      events[index] = {
+        documentId: event.documentId,
+        collectionName,
+        isLocal,
+        operation: event.operation,
+        documentData: deepFreezeWhenDevMode(event.documentData),
+        previousDocumentData: deepFreezeWhenDevMode(event.previousDocumentData)
+      };
+    }
+    return events;
+  });
+}
+//# sourceMappingURL=rx-change-event.js.map

package/dist/cjs/rx-change-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-change-event.js","names":["_overwritable","require","_index","getDocumentDataOfRxChangeEvent","rxChangeEvent","documentData","previousDocumentData","rxChangeEventToEventReduceChangeEvent","operation","id","documentId","doc","previous","overwritable","deepFreezeWhenDevMode","flattenEvents","input","output","Array","isArray","forEach","inputItem","add","concat","events","ev","push","usedIds","Set","nonDuplicate","getEventId","_rev","join","eventId","has","EVENT_BULK_CACHE","Map","rxChangeEventBulkToRxChangeEvents","eventBulk","getFromMapOrCreate","length","rawEvents","collectionName","isLocal","index","event"],"sources":["../../src/rx-change-event.ts"],"sourcesContent":["/**\r\n * RxChangeEvents a emitted when something in the database changes\r\n * they can be grabbed by the observables of database, collection and document\r\n */\r\n\r\nimport type {\r\n    ChangeEvent as EventReduceChangeEvent,\r\n} from 'event-reduce-js';\r\nimport { overwritable } from './overwritable.ts';\r\n\r\nimport type {\r\n    EventBulk,\r\n    RxChangeEvent,\r\n    RxChangeEventBulk,\r\n    RxDocumentData,\r\n    RxStorageChangeEvent\r\n} from './types/index.d.ts';\r\nimport { getFromMapOrCreate } from './plugins/utils/index.ts';\r\n\r\nexport function getDocumentDataOfRxChangeEvent<T>(\r\n    rxChangeEvent: RxStorageChangeEvent<T>\r\n): RxDocumentData<T> {\r\n    if ((rxChangeEvent as any).documentData) {\r\n        return (rxChangeEvent as any).documentData;\r\n    } else {\r\n        return (rxChangeEvent as any).previousDocumentData;\r\n    }\r\n}\r\n\r\n/**\r\n * Might return null which means an\r\n * already deleted document got modified but still is deleted.\r\n * These kind of events are not relevant for the event-reduce algorithm\r\n * and must be filtered out.\r\n */\r\nexport function rxChangeEventToEventReduceChangeEvent<DocType>(\r\n    rxChangeEvent: RxStorageChangeEvent<DocType>\r\n): EventReduceChangeEvent<DocType> | null {\r\n    switch (rxChangeEvent.operation) {\r\n        case 'INSERT':\r\n            return {\r\n                operation: rxChangeEvent.operation,\r\n                id: rxChangeEvent.documentId,\r\n                doc: rxChangeEvent.documentData as any,\r\n                previous: null\r\n            };\r\n        case 'UPDATE':\r\n            return {\r\n                operation: rxChangeEvent.operation,\r\n                id: rxChangeEvent.documentId,\r\n                doc: overwritable.deepFreezeWhenDevMode(rxChangeEvent.documentData) as any,\r\n                previous: rxChangeEvent.previousDocumentData ? rxChangeEvent.previousDocumentData as any : 'UNKNOWN'\r\n            };\r\n        case 'DELETE':\r\n            return {\r\n                operation: rxChangeEvent.operation,\r\n                id: rxChangeEvent.documentId,\r\n                doc: null,\r\n                previous: rxChangeEvent.previousDocumentData as DocType\r\n            };\r\n    }\r\n}\r\n\r\n/**\r\n * Flattens the given events into a single array of events.\r\n * Used mostly in tests.\r\n */\r\nexport function flattenEvents<EventType>(\r\n    input: EventBulk<EventType, any> | EventBulk<EventType, any>[] | EventType | EventType[]\r\n): EventType[] {\r\n    let output: EventType[] = [];\r\n    if (Array.isArray(input)) {\r\n        input.forEach(inputItem => {\r\n            const add = flattenEvents(inputItem);\r\n            output = output.concat(add);\r\n        });\r\n    } else {\r\n        if ((input as any).id && (input as any).events) {\r\n            // is bulk\r\n            (input as EventBulk<EventType, any>)\r\n                .events\r\n                .forEach(ev => output.push(ev));\r\n        } else {\r\n            output.push(input as any);\r\n        }\r\n    }\r\n\r\n    const usedIds = new Set<string>();\r\n    const nonDuplicate: EventType[] = [];\r\n\r\n    function getEventId(ev: any): string {\r\n        return [\r\n            ev.documentId,\r\n            ev.documentData ? ev.documentData._rev : '',\r\n            ev.previousDocumentData ? ev.previousDocumentData._rev : ''\r\n        ].join('|');\r\n    }\r\n\r\n    output.forEach(ev => {\r\n        const eventId = getEventId(ev);\r\n        if (!usedIds.has(eventId)) {\r\n            usedIds.add(eventId);\r\n            nonDuplicate.push(ev);\r\n        }\r\n    });\r\n\r\n    return nonDuplicate;\r\n}\r\n\r\nconst EVENT_BULK_CACHE = new Map<RxChangeEventBulk<any>, RxChangeEvent<any>[]>();\r\nexport function rxChangeEventBulkToRxChangeEvents(\r\n    eventBulk: RxChangeEventBulk<any>\r\n) {\r\n    return getFromMapOrCreate(\r\n        EVENT_BULK_CACHE,\r\n        eventBulk,\r\n        () => {\r\n            const events: RxChangeEvent<any>[] = new Array(eventBulk.events.length);\r\n            const rawEvents = eventBulk.events;\r\n            const collectionName = eventBulk.collectionName;\r\n            const isLocal = eventBulk.isLocal;\r\n            const deepFreezeWhenDevMode = overwritable.deepFreezeWhenDevMode;\r\n            for (let index = 0; index < rawEvents.length; index++) {\r\n                const event = rawEvents[index];\r\n                events[index] = {\r\n                    documentId: event.documentId,\r\n                    collectionName,\r\n                    isLocal,\r\n                    operation: event.operation,\r\n                    documentData: deepFreezeWhenDevMode(event.documentData) as any,\r\n                    previousDocumentData: deepFreezeWhenDevMode(event.previousDocumentData) as any\r\n                };\r\n            }\r\n            return events;\r\n        }\r\n    );\r\n}\r\n"],"mappings":"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","ignoreList":[]}