@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/replication-protocol/downstream.js

@@ -0,0 +1,334 @@
+import { firstValueFrom, filter, mergeMap } from 'rxjs';
+import { newRxError } from "../rx-error.js";
+import { getWrittenDocumentsFromBulkWriteResponse, stackCheckpoints } from "../rx-storage-helper.js";
+import { createRevision, ensureNotFalsy, flatClone, getDefaultRevision, getHeightOfRevision, now, PROMISE_RESOLVE_VOID } from "../plugins/utils/index.js";
+import { getLastCheckpointDoc, setCheckpoint } from "./checkpoint.js";
+import { stripAttachmentsDataFromMetaWriteRows, writeDocToDocState } from "./helper.js";
+import { getAssumedMasterState, getMetaWriteRow } from "./meta-instance.js";
+
+/**
+ * Writes all documents from the master to the fork.
+ * The downstream has two operation modes
+ * - Sync by iterating over the checkpoints via downstreamResyncOnce()
+ * - Sync by listening to the changestream via downstreamProcessChanges()
+ * We need this to be able to do initial syncs
+ * and still can have fast event based sync when the client is not offline.
+ */
+export async function startReplicationDownstream(state) {
+  if (state.input.initialCheckpoint && state.input.initialCheckpoint.downstream) {
+    var checkpointDoc = await getLastCheckpointDoc(state, 'down');
+    if (!checkpointDoc) {
+      await setCheckpoint(state, 'down', state.input.initialCheckpoint.downstream);
+    }
+  }
+  var identifierHash = await state.input.hashFunction(state.input.identifier);
+  var replicationHandler = state.input.replicationHandler;
+
+  // used to detect which tasks etc can in it at which order.
+  var timer = 0;
+  var openTasks = [];
+  function addNewTask(task) {
+    state.stats.down.addNewTask = state.stats.down.addNewTask + 1;
+    var taskWithTime = {
+      time: timer++,
+      task
+    };
+    openTasks.push(taskWithTime);
+    state.streamQueue.down = state.streamQueue.down.then(() => {
+      var useTasks = [];
+      while (openTasks.length > 0) {
+        state.events.active.down.next(true);
+        var innerTaskWithTime = ensureNotFalsy(openTasks.shift());
+
+        /**
+         * If the task came in before the last time we started the pull
+         * from the master, then we can drop the task.
+         */
+        if (innerTaskWithTime.time < lastTimeMasterChangesRequested) {
+          continue;
+        }
+        if (innerTaskWithTime.task === 'RESYNC') {
+          if (useTasks.length === 0) {
+            useTasks.push(innerTaskWithTime.task);
+            break;
+          } else {
+            break;
+          }
+        }
+        useTasks.push(innerTaskWithTime.task);
+      }
+      if (useTasks.length === 0) {
+        return;
+      }
+      if (useTasks[0] === 'RESYNC') {
+        return downstreamResyncOnce();
+      } else {
+        return downstreamProcessChanges(useTasks);
+      }
+    }).then(() => {
+      state.events.active.down.next(false);
+      if (!state.firstSyncDone.down.getValue() && !state.events.canceled.getValue()) {
+        state.firstSyncDone.down.next(true);
+      }
+    });
+  }
+  addNewTask('RESYNC');
+
+  /**
+   * If a write on the master happens, we have to trigger the downstream.
+   * Only do this if not canceled yet, otherwise firstValueFrom errors
+   * when running on a completed observable.
+   */
+  if (!state.events.canceled.getValue()) {
+    var sub = replicationHandler.masterChangeStream$.pipe(mergeMap(async ev => {
+      /**
+       * While a push is running, we have to delay all incoming
+       * events from the server to not mix up the replication state.
+       */
+      await firstValueFrom(state.events.active.up.pipe(filter(s => !s)));
+      return ev;
+    })).subscribe(task => {
+      state.stats.down.masterChangeStreamEmit = state.stats.down.masterChangeStreamEmit + 1;
+      addNewTask(task);
+    });
+    // unsubscribe when replication is canceled
+    firstValueFrom(state.events.canceled.pipe(filter(canceled => !!canceled))).then(() => sub.unsubscribe());
+  }
+
+  /**
+   * For faster performance, we directly start each write
+   * and then await all writes at the end.
+   */
+  var lastTimeMasterChangesRequested = -1;
+  async function downstreamResyncOnce() {
+    state.stats.down.downstreamResyncOnce = state.stats.down.downstreamResyncOnce + 1;
+    if (state.events.canceled.getValue()) {
+      return;
+    }
+    state.checkpointQueue = state.checkpointQueue.then(() => getLastCheckpointDoc(state, 'down'));
+    var lastCheckpoint = await state.checkpointQueue;
+    var promises = [];
+    while (!state.events.canceled.getValue()) {
+      lastTimeMasterChangesRequested = timer++;
+      var downResult = await replicationHandler.masterChangesSince(lastCheckpoint, state.input.pullBatchSize);
+      if (downResult.documents.length === 0) {
+        break;
+      }
+      lastCheckpoint = stackCheckpoints([lastCheckpoint, downResult.checkpoint]);
+      promises.push(persistFromMaster(downResult.documents, lastCheckpoint));
+
+      /**
+       * By definition we stop pull when the pulled documents
+       * do not fill up the pullBatchSize because we
+       * can assume that the remote has no more documents.
+       */
+      if (downResult.documents.length < state.input.pullBatchSize) {
+        break;
+      }
+    }
+    await Promise.all(promises);
+  }
+  function downstreamProcessChanges(tasks) {
+    state.stats.down.downstreamProcessChanges = state.stats.down.downstreamProcessChanges + 1;
+    var docsOfAllTasks = [];
+    var lastCheckpoint = null;
+    tasks.forEach(task => {
+      if (task === 'RESYNC') {
+        throw new Error('SNH');
+      }
+      docsOfAllTasks = docsOfAllTasks.concat(task.documents);
+      lastCheckpoint = stackCheckpoints([lastCheckpoint, task.checkpoint]);
+    });
+    return persistFromMaster(docsOfAllTasks, ensureNotFalsy(lastCheckpoint));
+  }
+
+  /**
+   * It can happen that the calls to masterChangesSince() or the changeStream()
+   * are way faster than how fast the documents can be persisted.
+   * Therefore we merge all incoming downResults into the nonPersistedFromMaster object
+   * and process them together if possible.
+   * This often bundles up single writes and improves performance
+   * by processing the documents in bulks.
+   */
+  var persistenceQueue = PROMISE_RESOLVE_VOID;
+  var nonPersistedFromMaster = {
+    docs: {}
+  };
+  function persistFromMaster(docs, checkpoint) {
+    var primaryPath = state.primaryPath;
+    state.stats.down.persistFromMaster = state.stats.down.persistFromMaster + 1;
+
+    /**
+     * Add the new docs to the non-persistent list
+     */
+    docs.forEach(docData => {
+      var docId = docData[primaryPath];
+      nonPersistedFromMaster.docs[docId] = docData;
+    });
+    nonPersistedFromMaster.checkpoint = checkpoint;
+
+    /**
+     * Run in the queue
+     * with all open documents from nonPersistedFromMaster.
+     */
+    persistenceQueue = persistenceQueue.then(() => {
+      var downDocsById = nonPersistedFromMaster.docs;
+      nonPersistedFromMaster.docs = {};
+      var useCheckpoint = nonPersistedFromMaster.checkpoint;
+      var docIds = Object.keys(downDocsById);
+      if (state.events.canceled.getValue() || docIds.length === 0) {
+        return PROMISE_RESOLVE_VOID;
+      }
+      var writeRowsToFork = [];
+      var writeRowsToForkById = {};
+      var writeRowsToMeta = {};
+      var useMetaWriteRows = [];
+      return Promise.all([state.input.forkInstance.findDocumentsById(docIds, true), getAssumedMasterState(state, docIds)]).then(([currentForkStateList, assumedMasterState]) => {
+        var currentForkState = new Map();
+        currentForkStateList.forEach(doc => currentForkState.set(doc[primaryPath], doc));
+        return Promise.all(docIds.map(async docId => {
+          var forkStateFullDoc = currentForkState.get(docId);
+          var forkStateDocData = forkStateFullDoc ? writeDocToDocState(forkStateFullDoc, state.hasAttachments, false) : undefined;
+          var masterState = downDocsById[docId];
+          var assumedMaster = assumedMasterState[docId];
+          if (assumedMaster && forkStateFullDoc && assumedMaster.metaDocument.isResolvedConflict === forkStateFullDoc._rev) {
+            /**
+             * The current fork state represents a resolved conflict
+             * that first must be sent to the master in the upstream.
+             * All conflicts are resolved by the upstream.
+             */
+            // return PROMISE_RESOLVE_VOID;
+            await state.streamQueue.up;
+          }
+          var isAssumedMasterEqualToForkState = !assumedMaster || !forkStateDocData ? false : state.input.conflictHandler.isEqual(assumedMaster.docData, forkStateDocData, 'downstream-check-if-equal-0');
+          if (!isAssumedMasterEqualToForkState && assumedMaster && assumedMaster.docData._rev && forkStateFullDoc && forkStateFullDoc._meta[state.input.identifier] && getHeightOfRevision(forkStateFullDoc._rev) === forkStateFullDoc._meta[state.input.identifier]) {
+            isAssumedMasterEqualToForkState = true;
+          }
+          if ((forkStateFullDoc && assumedMaster && isAssumedMasterEqualToForkState === false || forkStateFullDoc && !assumedMaster) && !state.skipStoringPullMeta && !(forkStateFullDoc._meta.o && forkStateFullDoc._meta.o.hash === identifierHash && forkStateFullDoc._meta.o._rev === getHeightOfRevision(forkStateFullDoc._rev))) {
+            /**
+             * We have a non-upstream-replicated
+             * local write to the fork.
+             * This means either we have to upstream the local
+             * doc data first, or it means that the fork state was
+             * synced from the master but the process exited before
+             * the metadata was written.
+             * @link https://github.com/pubkey/rxdb/pull/7804
+             */
+            return PROMISE_RESOLVE_VOID;
+          }
+          var areStatesExactlyEqual = !forkStateDocData ? false : state.input.conflictHandler.isEqual(masterState, forkStateDocData, 'downstream-check-if-equal-1');
+          if (forkStateDocData && areStatesExactlyEqual) {
+            /**
+             * Document states are exactly equal.
+             * This can happen when the replication is shut down
+             * unexpected like when the user goes offline.
+             *
+             * Only when the assumedMaster is different from the forkState,
+             * we have to patch the document in the meta instance.
+             */
+            if (!assumedMaster || isAssumedMasterEqualToForkState === false) {
+              useMetaWriteRows.push(await getMetaWriteRow(state, forkStateDocData, assumedMaster ? assumedMaster.metaDocument : undefined));
+            }
+            return PROMISE_RESOLVE_VOID;
+          }
+
+          /**
+           * All other master states need to be written to the forkInstance
+           * and metaInstance.
+           */
+          var newForkState = Object.assign({}, masterState, forkStateFullDoc ? {
+            _meta: flatClone(forkStateFullDoc._meta),
+            _attachments: state.hasAttachments && masterState._attachments ? masterState._attachments : {},
+            _rev: getDefaultRevision()
+          } : {
+            _meta: {
+              lwt: now()
+            },
+            _rev: getDefaultRevision(),
+            _attachments: state.hasAttachments && masterState._attachments ? masterState._attachments : {}
+          });
+          /**
+           * If the remote works with revisions,
+           * we store the height of the next fork-state revision
+           * inside of the documents meta data.
+           * By doing so we can filter it out in the upstream
+           * and detect the document as being equal to master or not.
+           * This is used for example in the CouchDB replication plugin.
+           */
+          if (masterState._rev) {
+            var nextRevisionHeight = !forkStateFullDoc ? 1 : getHeightOfRevision(forkStateFullDoc._rev) + 1;
+            newForkState._meta[state.input.identifier] = nextRevisionHeight;
+            if (state.input.keepMeta) {
+              newForkState._rev = masterState._rev;
+            }
+          }
+          if (state.input.keepMeta && masterState._meta) {
+            newForkState._meta = masterState._meta;
+          }
+          newForkState._meta.o = {
+            _rev: !forkStateFullDoc ? 1 : getHeightOfRevision(forkStateFullDoc._rev) + 1,
+            hash: identifierHash
+          };
+          var forkWriteRow = {
+            previous: forkStateFullDoc,
+            document: newForkState
+          };
+          forkWriteRow.document._rev = forkWriteRow.document._rev ? forkWriteRow.document._rev : createRevision(identifierHash, forkWriteRow.previous);
+          writeRowsToFork.push(forkWriteRow);
+          writeRowsToForkById[docId] = forkWriteRow;
+          writeRowsToMeta[docId] = await getMetaWriteRow(state, masterState, assumedMaster ? assumedMaster.metaDocument : undefined);
+        }));
+      }).then(async () => {
+        if (writeRowsToFork.length > 0) {
+          return state.input.forkInstance.bulkWrite(writeRowsToFork, await state.downstreamBulkWriteFlag).then(forkWriteResult => {
+            var success = getWrittenDocumentsFromBulkWriteResponse(state.primaryPath, writeRowsToFork, forkWriteResult);
+            success.forEach(doc => {
+              var docId = doc[primaryPath];
+              state.events.processed.down.next(writeRowsToForkById[docId]);
+              useMetaWriteRows.push(writeRowsToMeta[docId]);
+            });
+            var mustThrow;
+            forkWriteResult.error.forEach(error => {
+              /**
+               * We do not have to care about downstream conflict errors here
+               * because on conflict, it will be solved locally and result in another write.
+               */
+              if (error.status === 409) {
+                return;
+              }
+              // other non-conflict errors must be handled
+              var throwMe = newRxError('RC_PULL', {
+                writeError: error
+              });
+              state.events.error.next(throwMe);
+              mustThrow = throwMe;
+            });
+            if (mustThrow) {
+              throw mustThrow;
+            }
+          });
+        }
+      }).then(() => {
+        if (!state.skipStoringPullMeta && useMetaWriteRows.length > 0) {
+          return state.input.metaInstance.bulkWrite(stripAttachmentsDataFromMetaWriteRows(state, useMetaWriteRows), 'replication-down-write-meta').then(metaWriteResult => {
+            metaWriteResult.error.forEach(writeError => {
+              state.events.error.next(newRxError('RC_PULL', {
+                id: writeError.documentId,
+                writeError
+              }));
+            });
+          });
+        }
+      }).then(() => {
+        /**
+         * For better performance we do not await checkpoint writes,
+         * but to ensure order on parallel checkpoint writes,
+         * we have to use a queue.
+         */
+        setCheckpoint(state, 'down', useCheckpoint);
+      });
+    }).catch(unhandledError => state.events.error.next(unhandledError));
+    return persistenceQueue;
+  }
+}
+//# sourceMappingURL=downstream.js.map

package/dist/esm/replication-protocol/downstream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"downstream.js","names":["firstValueFrom","filter","mergeMap","newRxError","getWrittenDocumentsFromBulkWriteResponse","stackCheckpoints","createRevision","ensureNotFalsy","flatClone","getDefaultRevision","getHeightOfRevision","now","PROMISE_RESOLVE_VOID","getLastCheckpointDoc","setCheckpoint","stripAttachmentsDataFromMetaWriteRows","writeDocToDocState","getAssumedMasterState","getMetaWriteRow","startReplicationDownstream","state","input","initialCheckpoint","downstream","checkpointDoc","identifierHash","hashFunction","identifier","replicationHandler","timer","openTasks","addNewTask","task","stats","down","taskWithTime","time","push","streamQueue","then","useTasks","length","events","active","next","innerTaskWithTime","shift","lastTimeMasterChangesRequested","downstreamResyncOnce","downstreamProcessChanges","firstSyncDone","getValue","canceled","sub","masterChangeStream$","pipe","ev","up","s","subscribe","masterChangeStreamEmit","unsubscribe","checkpointQueue","lastCheckpoint","promises","downResult","masterChangesSince","pullBatchSize","documents","checkpoint","persistFromMaster","Promise","all","tasks","docsOfAllTasks","forEach","Error","concat","persistenceQueue","nonPersistedFromMaster","docs","primaryPath","docData","docId","downDocsById","useCheckpoint","docIds","Object","keys","writeRowsToFork","writeRowsToForkById","writeRowsToMeta","useMetaWriteRows","forkInstance","findDocumentsById","currentForkStateList","assumedMasterState","currentForkState","Map","doc","set","map","forkStateFullDoc","get","forkStateDocData","hasAttachments","undefined","masterState","assumedMaster","metaDocument","isResolvedConflict","_rev","isAssumedMasterEqualToForkState","conflictHandler","isEqual","_meta","skipStoringPullMeta","o","hash","areStatesExactlyEqual","newForkState","assign","_attachments","lwt","nextRevisionHeight","keepMeta","forkWriteRow","previous","document","bulkWrite","downstreamBulkWriteFlag","forkWriteResult","success","processed","mustThrow","error","status","throwMe","writeError","metaInstance","metaWriteResult","id","documentId","catch","unhandledError"],"sources":["../../../src/replication-protocol/downstream.ts"],"sourcesContent":["import {\r\n    firstValueFrom,\r\n    filter,\r\n    mergeMap\r\n} from 'rxjs';\r\nimport { newRxError } from '../rx-error.ts';\r\nimport { getWrittenDocumentsFromBulkWriteResponse, stackCheckpoints } from '../rx-storage-helper.ts';\r\nimport type {\r\n    RxStorageInstanceReplicationState,\r\n    BulkWriteRow,\r\n    BulkWriteRowById,\r\n    RxStorageReplicationMeta,\r\n    RxDocumentData,\r\n    ById,\r\n    WithDeleted,\r\n    DocumentsWithCheckpoint,\r\n    WithDeletedAndAttachments,\r\n    RxError\r\n} from '../types/index.d.ts';\r\nimport {\r\n    createRevision,\r\n    ensureNotFalsy,\r\n    flatClone,\r\n    getDefaultRevision,\r\n    getHeightOfRevision,\r\n    now,\r\n    PROMISE_RESOLVE_VOID\r\n} from '../plugins/utils/index.ts';\r\nimport {\r\n    getLastCheckpointDoc,\r\n    setCheckpoint\r\n} from './checkpoint.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\n\r\n/**\r\n * Writes all documents from the master to the fork.\r\n * The downstream has two operation modes\r\n * - Sync by iterating over the checkpoints via downstreamResyncOnce()\r\n * - Sync by listening to the changestream via downstreamProcessChanges()\r\n * We need this to be able to do initial syncs\r\n * and still can have fast event based sync when the client is not offline.\r\n */\r\nexport async function startReplicationDownstream<RxDocType, CheckpointType = any>(\r\n    state: RxStorageInstanceReplicationState<RxDocType>\r\n) {\r\n    if (\r\n        state.input.initialCheckpoint &&\r\n        state.input.initialCheckpoint.downstream\r\n    ) {\r\n        const checkpointDoc = await getLastCheckpointDoc(state, 'down');\r\n        if (!checkpointDoc) {\r\n            await setCheckpoint(\r\n                state,\r\n                'down',\r\n                state.input.initialCheckpoint.downstream\r\n            );\r\n        }\r\n    }\r\n\r\n    const identifierHash = await state.input.hashFunction(state.input.identifier);\r\n    const replicationHandler = state.input.replicationHandler;\r\n\r\n    // used to detect which tasks etc can in it at which order.\r\n    let timer = 0;\r\n\r\n\r\n    type Task = DocumentsWithCheckpoint<RxDocType, any> | 'RESYNC';\r\n    type TaskWithTime = {\r\n        time: number;\r\n        task: Task;\r\n    };\r\n    const openTasks: TaskWithTime[] = [];\r\n\r\n\r\n    function addNewTask(task: Task): void {\r\n        state.stats.down.addNewTask = state.stats.down.addNewTask + 1;\r\n        const taskWithTime = {\r\n            time: timer++,\r\n            task\r\n        };\r\n        openTasks.push(taskWithTime);\r\n        state.streamQueue.down = state.streamQueue.down\r\n            .then(() => {\r\n                const useTasks: Task[] = [];\r\n                while (openTasks.length > 0) {\r\n                    state.events.active.down.next(true);\r\n                    const innerTaskWithTime = ensureNotFalsy(openTasks.shift());\r\n\r\n                    /**\r\n                     * If the task came in before the last time we started the pull\r\n                     * from the master, then we can drop the task.\r\n                     */\r\n                    if (innerTaskWithTime.time < lastTimeMasterChangesRequested) {\r\n                        continue;\r\n                    }\r\n\r\n                    if (innerTaskWithTime.task === 'RESYNC') {\r\n                        if (useTasks.length === 0) {\r\n                            useTasks.push(innerTaskWithTime.task);\r\n                            break;\r\n                        } else {\r\n                            break;\r\n                        }\r\n                    }\r\n\r\n                    useTasks.push(innerTaskWithTime.task);\r\n                }\r\n                if (useTasks.length === 0) {\r\n                    return;\r\n                }\r\n\r\n                if (useTasks[0] === 'RESYNC') {\r\n                    return downstreamResyncOnce();\r\n                } else {\r\n                    return downstreamProcessChanges(useTasks);\r\n                }\r\n            }).then(() => {\r\n                state.events.active.down.next(false);\r\n                if (\r\n                    !state.firstSyncDone.down.getValue() &&\r\n                    !state.events.canceled.getValue()\r\n                ) {\r\n                    state.firstSyncDone.down.next(true);\r\n                }\r\n            });\r\n    }\r\n    addNewTask('RESYNC');\r\n\r\n    /**\r\n     * If a write on the master happens, we have to trigger the downstream.\r\n     * Only do this if not canceled yet, otherwise firstValueFrom errors\r\n     * when running on a completed observable.\r\n     */\r\n    if (!state.events.canceled.getValue()) {\r\n        const sub = replicationHandler\r\n            .masterChangeStream$\r\n            .pipe(\r\n                mergeMap(async (ev: any) => {\r\n                    /**\r\n                     * While a push is running, we have to delay all incoming\r\n                     * events from the server to not mix up the replication state.\r\n                     */\r\n                    await firstValueFrom(\r\n                        state.events.active.up.pipe(filter((s: boolean) => !s))\r\n                    );\r\n                    return ev;\r\n                })\r\n            )\r\n            .subscribe((task: Task) => {\r\n                state.stats.down.masterChangeStreamEmit = state.stats.down.masterChangeStreamEmit + 1;\r\n                addNewTask(task);\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(() => sub.unsubscribe());\r\n    }\r\n\r\n\r\n    /**\r\n     * For faster performance, we directly start each write\r\n     * and then await all writes at the end.\r\n     */\r\n    let lastTimeMasterChangesRequested: number = -1;\r\n    async function downstreamResyncOnce() {\r\n        state.stats.down.downstreamResyncOnce = state.stats.down.downstreamResyncOnce + 1;\r\n        if (state.events.canceled.getValue()) {\r\n            return;\r\n        }\r\n\r\n        state.checkpointQueue = state.checkpointQueue.then(() => getLastCheckpointDoc(state, 'down'));\r\n        let lastCheckpoint: CheckpointType = await state.checkpointQueue;\r\n\r\n\r\n        const promises: Promise<any>[] = [];\r\n        while (!state.events.canceled.getValue()) {\r\n            lastTimeMasterChangesRequested = timer++;\r\n            const downResult = await replicationHandler.masterChangesSince(\r\n                lastCheckpoint,\r\n                state.input.pullBatchSize\r\n            );\r\n\r\n            if (downResult.documents.length === 0) {\r\n                break;\r\n            }\r\n\r\n            lastCheckpoint = stackCheckpoints([lastCheckpoint, downResult.checkpoint]);\r\n\r\n            promises.push(\r\n                persistFromMaster(\r\n                    downResult.documents,\r\n                    lastCheckpoint\r\n                )\r\n            );\r\n\r\n            /**\r\n             * By definition we stop pull when the pulled documents\r\n             * do not fill up the pullBatchSize because we\r\n             * can assume that the remote has no more documents.\r\n             */\r\n            if (downResult.documents.length < state.input.pullBatchSize) {\r\n                break;\r\n            }\r\n\r\n        }\r\n        await Promise.all(promises);\r\n    }\r\n\r\n\r\n    function downstreamProcessChanges(tasks: Task[]) {\r\n        state.stats.down.downstreamProcessChanges = state.stats.down.downstreamProcessChanges + 1;\r\n        let docsOfAllTasks: WithDeleted<RxDocType>[] = [];\r\n        let lastCheckpoint: CheckpointType | undefined = null as any;\r\n\r\n        tasks.forEach(task => {\r\n            if (task === 'RESYNC') {\r\n                throw new Error('SNH');\r\n            }\r\n            docsOfAllTasks = docsOfAllTasks.concat(task.documents);\r\n            lastCheckpoint = stackCheckpoints([lastCheckpoint, task.checkpoint]);\r\n        });\r\n        return persistFromMaster(\r\n            docsOfAllTasks,\r\n            ensureNotFalsy(lastCheckpoint)\r\n        );\r\n    }\r\n\r\n\r\n    /**\r\n     * It can happen that the calls to masterChangesSince() or the changeStream()\r\n     * are way faster than how fast the documents can be persisted.\r\n     * Therefore we merge all incoming downResults into the nonPersistedFromMaster object\r\n     * and process them together if possible.\r\n     * This often bundles up single writes and improves performance\r\n     * by processing the documents in bulks.\r\n     */\r\n    let persistenceQueue = PROMISE_RESOLVE_VOID;\r\n    const nonPersistedFromMaster: {\r\n        checkpoint?: CheckpointType;\r\n        docs: ById<WithDeleted<RxDocType>>;\r\n    } = {\r\n        docs: {}\r\n    };\r\n\r\n    function persistFromMaster(\r\n        docs: WithDeleted<RxDocType>[],\r\n        checkpoint: CheckpointType\r\n    ): Promise<void> {\r\n        const primaryPath = state.primaryPath;\r\n        state.stats.down.persistFromMaster = state.stats.down.persistFromMaster + 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)[primaryPath];\r\n            nonPersistedFromMaster.docs[docId] = docData;\r\n        });\r\n        nonPersistedFromMaster.checkpoint = checkpoint;\r\n\r\n        /**\r\n         * Run in the queue\r\n         * with all open documents from nonPersistedFromMaster.\r\n         */\r\n        persistenceQueue = persistenceQueue.then(() => {\r\n            const downDocsById: ById<WithDeletedAndAttachments<RxDocType>> = nonPersistedFromMaster.docs;\r\n            nonPersistedFromMaster.docs = {};\r\n            const useCheckpoint = nonPersistedFromMaster.checkpoint;\r\n            const docIds = Object.keys(downDocsById);\r\n\r\n            if (\r\n                state.events.canceled.getValue() ||\r\n                docIds.length === 0\r\n            ) {\r\n                return PROMISE_RESOLVE_VOID;\r\n            }\r\n\r\n            const writeRowsToFork: BulkWriteRow<RxDocType>[] = [];\r\n            const writeRowsToForkById: ById<BulkWriteRow<RxDocType>> = {};\r\n            const writeRowsToMeta: BulkWriteRowById<RxStorageReplicationMeta<RxDocType, CheckpointType>> = {};\r\n            const useMetaWriteRows: BulkWriteRow<RxStorageReplicationMeta<RxDocType, CheckpointType>>[] = [];\r\n\r\n            return Promise.all([\r\n                state.input.forkInstance.findDocumentsById(docIds, true),\r\n                getAssumedMasterState(\r\n                    state,\r\n                    docIds\r\n                )\r\n            ]).then(([\r\n                currentForkStateList,\r\n                assumedMasterState\r\n            ]) => {\r\n                const currentForkState = new Map<string, RxDocumentData<RxDocType>>();\r\n                currentForkStateList.forEach(doc => currentForkState.set((doc as any)[primaryPath], doc));\r\n                return Promise.all(\r\n                    docIds.map(async (docId) => {\r\n                        const forkStateFullDoc: RxDocumentData<RxDocType> | undefined = currentForkState.get(docId);\r\n                        const forkStateDocData: WithDeletedAndAttachments<RxDocType> | undefined = forkStateFullDoc\r\n                            ? writeDocToDocState(forkStateFullDoc, state.hasAttachments, false)\r\n                            : undefined\r\n                            ;\r\n                        const masterState = downDocsById[docId];\r\n                        const assumedMaster = assumedMasterState[docId];\r\n\r\n                        if (\r\n                            assumedMaster &&\r\n                            forkStateFullDoc &&\r\n                            assumedMaster.metaDocument.isResolvedConflict === forkStateFullDoc._rev\r\n                        ) {\r\n                            /**\r\n                             * The current fork state represents a resolved conflict\r\n                             * that first must be sent to the master in the upstream.\r\n                             * All conflicts are resolved by the upstream.\r\n                             */\r\n                            // return PROMISE_RESOLVE_VOID;\r\n                            await state.streamQueue.up;\r\n                        }\r\n\r\n                        let isAssumedMasterEqualToForkState = !assumedMaster || !forkStateDocData ?\r\n                            false :\r\n                            state.input.conflictHandler.isEqual(\r\n                                assumedMaster.docData,\r\n                                forkStateDocData,\r\n                                'downstream-check-if-equal-0'\r\n                            );\r\n                        if (\r\n                            !isAssumedMasterEqualToForkState &&\r\n                            (\r\n                                assumedMaster &&\r\n                                (assumedMaster.docData as any)._rev &&\r\n                                forkStateFullDoc &&\r\n                                forkStateFullDoc._meta[state.input.identifier] &&\r\n                                getHeightOfRevision(forkStateFullDoc._rev) === forkStateFullDoc._meta[state.input.identifier]\r\n                            )\r\n                        ) {\r\n                            isAssumedMasterEqualToForkState = true;\r\n                        }\r\n\r\n                        if (\r\n                            (\r\n                                (\r\n                                    forkStateFullDoc &&\r\n                                    assumedMaster &&\r\n                                    isAssumedMasterEqualToForkState === false\r\n                                )\r\n                                ||\r\n                                (\r\n                                    forkStateFullDoc && !assumedMaster\r\n                                )\r\n                            ) && !state.skipStoringPullMeta\r\n                            &&\r\n                            !(\r\n                                forkStateFullDoc._meta.o &&\r\n                                (\r\n                                    forkStateFullDoc._meta.o.hash === identifierHash &&\r\n                                    forkStateFullDoc._meta.o._rev === getHeightOfRevision(forkStateFullDoc._rev)\r\n                                )\r\n                            )\r\n                        ) {\r\n\r\n                            /**\r\n                             * We have a non-upstream-replicated\r\n                             * local write to the fork.\r\n                             * This means either we have to upstream the local\r\n                             * doc data first, or it means that the fork state was\r\n                             * synced from the master but the process exited before\r\n                             * the metadata was written.\r\n                             * @link https://github.com/pubkey/rxdb/pull/7804\r\n                             */\r\n                            return PROMISE_RESOLVE_VOID;\r\n                        }\r\n\r\n                        const areStatesExactlyEqual = !forkStateDocData\r\n                            ? false\r\n                            : state.input.conflictHandler.isEqual(\r\n                                masterState,\r\n                                forkStateDocData,\r\n                                'downstream-check-if-equal-1'\r\n                            );\r\n                        if (\r\n                            forkStateDocData &&\r\n                            areStatesExactlyEqual\r\n                        ) {\r\n                            /**\r\n                             * Document states are exactly equal.\r\n                             * This can happen when the replication is shut down\r\n                             * unexpected like when the user goes offline.\r\n                             *\r\n                             * Only when the assumedMaster is different from the forkState,\r\n                             * we have to patch the document in the meta instance.\r\n                             */\r\n                            if (\r\n                                !assumedMaster ||\r\n                                isAssumedMasterEqualToForkState === false\r\n                            ) {\r\n                                useMetaWriteRows.push(\r\n                                    await getMetaWriteRow(\r\n                                        state,\r\n                                        forkStateDocData,\r\n                                        assumedMaster ? assumedMaster.metaDocument : undefined\r\n                                    )\r\n                                );\r\n                            }\r\n                            return PROMISE_RESOLVE_VOID;\r\n                        }\r\n\r\n                        /**\r\n                         * All other master states need to be written to the forkInstance\r\n                         * and metaInstance.\r\n                         */\r\n                        const newForkState = Object.assign(\r\n                            {},\r\n                            masterState,\r\n                            forkStateFullDoc ? {\r\n                                _meta: flatClone(forkStateFullDoc._meta),\r\n                                _attachments: state.hasAttachments && masterState._attachments ? masterState._attachments : {},\r\n                                _rev: getDefaultRevision()\r\n                            } : {\r\n                                _meta: {\r\n                                    lwt: now()\r\n                                },\r\n                                _rev: getDefaultRevision(),\r\n                                _attachments: state.hasAttachments && masterState._attachments ? masterState._attachments : {}\r\n                            }\r\n                        );\r\n                        /**\r\n                         * If the remote works with revisions,\r\n                         * we store the height of the next fork-state revision\r\n                         * inside of the documents meta data.\r\n                         * By doing so we can filter it out in the upstream\r\n                         * and detect the document as being equal to master or not.\r\n                         * This is used for example in the CouchDB replication plugin.\r\n                         */\r\n                        if ((masterState as any)._rev) {\r\n                            const nextRevisionHeight = !forkStateFullDoc ? 1 : getHeightOfRevision(forkStateFullDoc._rev) + 1;\r\n                            newForkState._meta[state.input.identifier] = nextRevisionHeight;\r\n                            if (state.input.keepMeta) {\r\n                                newForkState._rev = (masterState as any)._rev;\r\n                            }\r\n                        }\r\n                        if (\r\n                            state.input.keepMeta &&\r\n                            (masterState as any)._meta\r\n                        ) {\r\n                            newForkState._meta = (masterState as any)._meta;\r\n                        }\r\n\r\n\r\n\r\n                        newForkState._meta.o = {\r\n                            _rev: !forkStateFullDoc ? 1 : getHeightOfRevision(forkStateFullDoc._rev) + 1,\r\n                            hash: identifierHash\r\n                        };\r\n\r\n                        const forkWriteRow = {\r\n                            previous: forkStateFullDoc,\r\n                            document: newForkState\r\n                        };\r\n\r\n                        forkWriteRow.document._rev = forkWriteRow.document._rev ? forkWriteRow.document._rev : createRevision(\r\n                            identifierHash,\r\n                            forkWriteRow.previous\r\n                        );\r\n\r\n                        writeRowsToFork.push(forkWriteRow);\r\n                        writeRowsToForkById[docId] = forkWriteRow;\r\n                        writeRowsToMeta[docId] = await getMetaWriteRow(\r\n                            state,\r\n                            masterState,\r\n                            assumedMaster ? assumedMaster.metaDocument : undefined\r\n                        );\r\n                    })\r\n                );\r\n            }).then(async () => {\r\n                if (writeRowsToFork.length > 0) {\r\n                    return state.input.forkInstance.bulkWrite(\r\n                        writeRowsToFork,\r\n                        await state.downstreamBulkWriteFlag\r\n                    ).then((forkWriteResult) => {\r\n                        const success = getWrittenDocumentsFromBulkWriteResponse(\r\n                            state.primaryPath,\r\n                            writeRowsToFork,\r\n                            forkWriteResult\r\n                        );\r\n                        success.forEach(doc => {\r\n                            const docId = (doc as any)[primaryPath];\r\n                            state.events.processed.down.next(writeRowsToForkById[docId]);\r\n                            useMetaWriteRows.push(writeRowsToMeta[docId]);\r\n                        });\r\n                        let mustThrow: RxError | undefined;\r\n                        forkWriteResult.error.forEach(error => {\r\n                            /**\r\n                             * We do not have to care about downstream conflict errors here\r\n                             * because on conflict, it will be solved locally and result in another write.\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_PULL', {\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                }\r\n            }).then(() => {\r\n                if (!state.skipStoringPullMeta && useMetaWriteRows.length > 0) {\r\n                    return state.input.metaInstance.bulkWrite(\r\n                        stripAttachmentsDataFromMetaWriteRows(state, useMetaWriteRows),\r\n                        'replication-down-write-meta'\r\n                    ).then(metaWriteResult => {\r\n                        metaWriteResult.error\r\n                            .forEach(writeError => {\r\n                                state.events.error.next(newRxError('RC_PULL', {\r\n                                    id: writeError.documentId,\r\n                                    writeError\r\n                                }));\r\n                            });\r\n                    });\r\n                }\r\n            }).then(() => {\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                setCheckpoint(\r\n                    state,\r\n                    'down',\r\n                    useCheckpoint\r\n                );\r\n            });\r\n        }).catch(unhandledError => state.events.error.next(unhandledError));\r\n        return persistenceQueue;\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/replication-protocol/helper.js

@@ -0,0 +1,49 @@
+import { clone, createRevision, flatClone, getDefaultRevision, now } from "../plugins/utils/index.js";
+import { stripAttachmentsDataFromDocument } from "../rx-storage-helper.js";
+export function docStateToWriteDoc(databaseInstanceToken, hasAttachments, keepMeta, docState, previous) {
+  var docData = Object.assign({}, docState, {
+    _attachments: hasAttachments && docState._attachments ? docState._attachments : {},
+    _meta: keepMeta ? docState._meta : Object.assign({}, previous ? previous._meta : {}, {
+      lwt: now()
+    }),
+    _rev: keepMeta ? docState._rev : getDefaultRevision()
+  });
+  if (!docData._rev) {
+    docData._rev = createRevision(databaseInstanceToken, previous);
+  }
+  return docData;
+}
+export function writeDocToDocState(writeDoc, keepAttachments, keepMeta) {
+  var ret = flatClone(writeDoc);
+  if (!keepAttachments) {
+    delete ret._attachments;
+  }
+  if (!keepMeta) {
+    delete ret._meta;
+    delete ret._rev;
+  }
+  return ret;
+}
+export function stripAttachmentsDataFromMetaWriteRows(state, rows) {
+  if (!state.hasAttachments) {
+    return rows;
+  }
+  return rows.map(row => {
+    var document = clone(row.document);
+    document.docData = stripAttachmentsDataFromDocument(document.docData);
+    return {
+      document,
+      previous: row.previous
+    };
+  });
+}
+export function getUnderlyingPersistentStorage(instance) {
+  while (true) {
+    if (instance.underlyingPersistentStorage) {
+      instance = instance.underlyingPersistentStorage;
+    } else {
+      return instance;
+    }
+  }
+}
+//# sourceMappingURL=helper.js.map

package/dist/esm/replication-protocol/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","names":["clone","createRevision","flatClone","getDefaultRevision","now","stripAttachmentsDataFromDocument","docStateToWriteDoc","databaseInstanceToken","hasAttachments","keepMeta","docState","previous","docData","Object","assign","_attachments","_meta","lwt","_rev","writeDocToDocState","writeDoc","keepAttachments","ret","stripAttachmentsDataFromMetaWriteRows","state","rows","map","row","document","getUnderlyingPersistentStorage","instance","underlyingPersistentStorage"],"sources":["../../../src/replication-protocol/helper.ts"],"sourcesContent":["import type {\r\n    BulkWriteRow,\r\n    RxDocumentData,\r\n    RxDocumentWriteData,\r\n    RxStorageInstance,\r\n    RxStorageInstanceReplicationState,\r\n    RxStorageReplicationMeta,\r\n    WithDeletedAndAttachments\r\n} from '../types/index.d.ts';\r\nimport {\r\n    clone,\r\n    createRevision,\r\n    flatClone,\r\n    getDefaultRevision,\r\n    now\r\n} from '../plugins/utils/index.ts';\r\nimport { stripAttachmentsDataFromDocument } from '../rx-storage-helper.ts';\r\n\r\nexport function docStateToWriteDoc<RxDocType>(\r\n    databaseInstanceToken: string,\r\n    hasAttachments: boolean,\r\n    keepMeta: boolean,\r\n    docState: WithDeletedAndAttachments<RxDocType>,\r\n    previous?: RxDocumentData<RxDocType>\r\n): RxDocumentWriteData<RxDocType> {\r\n    const docData: RxDocumentWriteData<RxDocType> = Object.assign(\r\n        {},\r\n        docState,\r\n        {\r\n            _attachments: hasAttachments && docState._attachments ? docState._attachments : {},\r\n            _meta: keepMeta ? (docState as any)._meta : Object.assign(\r\n                {},\r\n                previous ? previous._meta : {},\r\n                {\r\n                    lwt: now()\r\n                }\r\n            ),\r\n            _rev: keepMeta ? (docState as any)._rev : getDefaultRevision()\r\n        }\r\n    );\r\n    if (!docData._rev) {\r\n        docData._rev = createRevision(\r\n            databaseInstanceToken,\r\n            previous\r\n        );\r\n    }\r\n\r\n    return docData;\r\n}\r\n\r\nexport function writeDocToDocState<RxDocType>(\r\n    writeDoc: RxDocumentData<RxDocType>,\r\n    keepAttachments: boolean,\r\n    keepMeta: boolean\r\n): WithDeletedAndAttachments<RxDocType> {\r\n    const ret = flatClone(writeDoc);\r\n\r\n    if (!keepAttachments) {\r\n        delete (ret as any)._attachments;\r\n    }\r\n    if (!keepMeta) {\r\n        delete (ret as any)._meta;\r\n        delete (ret as any)._rev;\r\n    }\r\n    return ret;\r\n}\r\n\r\n\r\nexport function stripAttachmentsDataFromMetaWriteRows<RxDocType>(\r\n    state: RxStorageInstanceReplicationState<any>,\r\n    rows: BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>[]\r\n): BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>[] {\r\n    if (!state.hasAttachments) {\r\n        return rows;\r\n    }\r\n    return rows.map(row => {\r\n        const document = clone(row.document);\r\n        document.docData = stripAttachmentsDataFromDocument(document.docData);\r\n        return {\r\n            document,\r\n            previous: row.previous\r\n        };\r\n    });\r\n}\r\n\r\nexport function getUnderlyingPersistentStorage<RxDocType>(\r\n    instance: RxStorageInstance<RxDocType, any, any, any>\r\n): RxStorageInstance<RxDocType, any, any, any> {\r\n    while (true) {\r\n        if (instance.underlyingPersistentStorage) {\r\n            instance = instance.underlyingPersistentStorage;\r\n        } else {\r\n            return instance;\r\n        }\r\n    }\r\n}\r\n"],"mappings":"AASA,SACIA,KAAK,EACLC,cAAc,EACdC,SAAS,EACTC,kBAAkB,EAClBC,GAAG,QACA,2BAA2B;AAClC,SAASC,gCAAgC,QAAQ,yBAAyB;AAE1E,OAAO,SAASC,kBAAkBA,CAC9BC,qBAA6B,EAC7BC,cAAuB,EACvBC,QAAiB,EACjBC,QAA8C,EAC9CC,QAAoC,EACN;EAC9B,IAAMC,OAAuC,GAAGC,MAAM,CAACC,MAAM,CACzD,CAAC,CAAC,EACFJ,QAAQ,EACR;IACIK,YAAY,EAAEP,cAAc,IAAIE,QAAQ,CAACK,YAAY,GAAGL,QAAQ,CAACK,YAAY,GAAG,CAAC,CAAC;IAClFC,KAAK,EAAEP,QAAQ,GAAIC,QAAQ,CAASM,KAAK,GAAGH,MAAM,CAACC,MAAM,CACrD,CAAC,CAAC,EACFH,QAAQ,GAAGA,QAAQ,CAACK,KAAK,GAAG,CAAC,CAAC,EAC9B;MACIC,GAAG,EAAEb,GAAG,CAAC;IACb,CACJ,CAAC;IACDc,IAAI,EAAET,QAAQ,GAAIC,QAAQ,CAASQ,IAAI,GAAGf,kBAAkB,CAAC;EACjE,CACJ,CAAC;EACD,IAAI,CAACS,OAAO,CAACM,IAAI,EAAE;IACfN,OAAO,CAACM,IAAI,GAAGjB,cAAc,CACzBM,qBAAqB,EACrBI,QACJ,CAAC;EACL;EAEA,OAAOC,OAAO;AAClB;AAEA,OAAO,SAASO,kBAAkBA,CAC9BC,QAAmC,EACnCC,eAAwB,EACxBZ,QAAiB,EACmB;EACpC,IAAMa,GAAG,GAAGpB,SAAS,CAACkB,QAAQ,CAAC;EAE/B,IAAI,CAACC,eAAe,EAAE;IAClB,OAAQC,GAAG,CAASP,YAAY;EACpC;EACA,IAAI,CAACN,QAAQ,EAAE;IACX,OAAQa,GAAG,CAASN,KAAK;IACzB,OAAQM,GAAG,CAASJ,IAAI;EAC5B;EACA,OAAOI,GAAG;AACd;AAGA,OAAO,SAASC,qCAAqCA,CACjDC,KAA6C,EAC7CC,IAA8D,EACN;EACxD,IAAI,CAACD,KAAK,CAAChB,cAAc,EAAE;IACvB,OAAOiB,IAAI;EACf;EACA,OAAOA,IAAI,CAACC,GAAG,CAACC,GAAG,IAAI;IACnB,IAAMC,QAAQ,GAAG5B,KAAK,CAAC2B,GAAG,CAACC,QAAQ,CAAC;IACpCA,QAAQ,CAAChB,OAAO,GAAGP,gCAAgC,CAACuB,QAAQ,CAAChB,OAAO,CAAC;IACrE,OAAO;MACHgB,QAAQ;MACRjB,QAAQ,EAAEgB,GAAG,CAAChB;IAClB,CAAC;EACL,CAAC,CAAC;AACN;AAEA,OAAO,SAASkB,8BAA8BA,CAC1CC,QAAqD,EACV;EAC3C,OAAO,IAAI,EAAE;IACT,IAAIA,QAAQ,CAACC,2BAA2B,EAAE;MACtCD,QAAQ,GAAGA,QAAQ,CAACC,2BAA2B;IACnD,CAAC,MAAM;MACH,OAAOD,QAAQ;IACnB;EACJ;AACJ","ignoreList":[]}