@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugins/replication-mongodb/index.js

@@ -0,0 +1,197 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import { ensureNotFalsy, flatClone } from "../../plugins/utils/index.js";
+import { RxDBLeaderElectionPlugin } from "../leader-election/index.js";
+import { RxReplicationState, startReplicationOnLeaderShip } from "../replication/index.js";
+import { addRxPlugin } from "../../index.js";
+import { Subject } from 'rxjs';
+import { MongoClient } from 'mongodb';
+import { MONGO_OPTIONS_DRIVER_INFO } from "../storage-mongodb/mongodb-helper.js";
+import { iterateCheckpoint } from "./mongodb-checkpoint.js";
+import { mongodbDocToRxDB, rxdbDocToMongo, startChangeStream } from "./mongodb-helper.js";
+export * from "./mongodb-helper.js";
+export * from "./mongodb-checkpoint.js";
+export var RxMongoDBReplicationState = /*#__PURE__*/function (_RxReplicationState) {
+  function RxMongoDBReplicationState(mongoClient, mongoDatabase, mongoCollection, options, replicationIdentifier, collection, pull, push, live = true, retryTime = 1000 * 5, autoStart = true) {
+    var _this;
+    _this = _RxReplicationState.call(this, replicationIdentifier, collection, '_deleted', pull, push, live, retryTime, autoStart) || this;
+    _this.mongoClient = mongoClient;
+    _this.mongoDatabase = mongoDatabase;
+    _this.mongoCollection = mongoCollection;
+    _this.options = options;
+    _this.replicationIdentifier = replicationIdentifier;
+    _this.collection = collection;
+    _this.pull = pull;
+    _this.push = push;
+    _this.live = live;
+    _this.retryTime = retryTime;
+    _this.autoStart = autoStart;
+    return _this;
+  }
+  _inheritsLoose(RxMongoDBReplicationState, _RxReplicationState);
+  return RxMongoDBReplicationState;
+}(RxReplicationState);
+export function replicateMongoDB(options) {
+  addRxPlugin(RxDBLeaderElectionPlugin);
+  var primaryPath = options.collection.schema.primaryPath;
+  options.live = typeof options.live === 'undefined' ? true : options.live;
+  options.waitForLeadership = typeof options.waitForLeadership === 'undefined' ? true : options.waitForLeadership;
+  var pullStream$ = new Subject();
+  var mongoClient = new MongoClient(options.mongodb.connection, MONGO_OPTIONS_DRIVER_INFO);
+  var mongoDatabase = mongoClient.db(options.mongodb.databaseName);
+  var mongoCollection = mongoDatabase.collection(options.mongodb.collectionName);
+  var replicationPrimitivesPull;
+  if (options.pull) {
+    replicationPrimitivesPull = {
+      async handler(lastPulledCheckpoint, batchSize) {
+        var result = await iterateCheckpoint(primaryPath, mongoCollection, batchSize, lastPulledCheckpoint);
+        return {
+          documents: result.docs,
+          checkpoint: result.checkpoint
+        };
+      },
+      batchSize: ensureNotFalsy(options.pull).batchSize,
+      modifier: ensureNotFalsy(options.pull).modifier,
+      stream$: pullStream$.asObservable()
+    };
+  }
+  var replicationPrimitivesPush;
+  if (options.push) {
+    replicationPrimitivesPush = {
+      async handler(rows) {
+        var conflicts = [];
+        var session = mongoClient.startSession();
+        session.startTransaction(options.mongodb.pushTransactionOptions);
+        var ids = rows.map(row => row.newDocumentState[primaryPath]);
+        var currentDocsArray = await mongoCollection.find({
+          [primaryPath]: {
+            $in: ids
+          }
+        }, {
+          session
+        }).toArray();
+        var currentDocsMap = new Map();
+        currentDocsArray.forEach(doc => {
+          currentDocsMap.set(doc[primaryPath], doc);
+        });
+        var promises = [];
+        rows.forEach(row => {
+          var toMongoDoc = rxdbDocToMongo(row.newDocumentState);
+          var docId = row.newDocumentState[primaryPath];
+          var current = currentDocsMap.get(docId);
+          var remoteDocState = current ? mongodbDocToRxDB(primaryPath, current) : undefined;
+
+          /**
+           * We do not want to require a deleted-flag or any RxDB specific stuff on the RxDB side.
+           * So for deletes we have to hack around this.
+           */
+          var assumedMaster = row.assumedMasterState;
+          if (row.newDocumentState._deleted) {
+            if (remoteDocState) {
+              if (!assumedMaster) {
+                // remote exists but not assumed -> conflict
+                conflicts.push(remoteDocState);
+              } else if (assumedMaster._deleted) {
+                // remote exists but assumed as deleted -> conflict
+                conflicts.push(remoteDocState);
+              } else {
+                // remote exists and assumed to exist -> check for normal conflict or do the deletion-write
+                if (options.collection.conflictHandler.isEqual(remoteDocState, assumedMaster, 'mongodb-pull-equal-check-deleted') === false) {
+                  // conflict
+                  conflicts.push(remoteDocState);
+                } else {
+                  promises.push(mongoCollection.deleteOne({
+                    [primaryPath]: docId
+                  }, {
+                    session
+                  }));
+                }
+              }
+            } else {
+              if (!assumedMaster) {
+                // no remote and no assumed master -> insertion of deleted -> do nothing
+              } else if (assumedMaster._deleted) {
+                // no remote and assumed master also deleted -> insertion of deleted -> do nothing
+              }
+            }
+          } else {
+            /**
+             * Non-deleted are handled normally like in every other
+             * of the replication plugins.
+             */
+            if (remoteDocState && (!row.assumedMasterState || options.collection.conflictHandler.isEqual(remoteDocState, row.assumedMasterState, 'mongodb-pull-equal-check') === false)) {
+              // conflict
+              conflicts.push(remoteDocState);
+            } else {
+              if (current) {
+                if (row.newDocumentState._deleted) {
+                  promises.push(mongoCollection.deleteOne({
+                    [primaryPath]: docId
+                  }, {
+                    session
+                  }));
+                } else {
+                  promises.push(mongoCollection.updateOne({
+                    [primaryPath]: docId
+                  }, {
+                    $set: toMongoDoc
+                  }, {
+                    upsert: true,
+                    session
+                  }));
+                }
+              } else {
+                /**
+                 * No current but has assumed.
+                 * This means the server state was deleted
+                 * and we have a conflict.
+                 */
+                if (row.assumedMasterState) {
+                  var conflicting = flatClone(row.assumedMasterState);
+                  conflicting._deleted = true;
+                  conflicts.push(conflicting);
+                } else {
+                  if (row.newDocumentState._deleted) {
+                    // inserting deleted -> do nothing
+                  } else {
+                    promises.push(mongoCollection.insertOne(toMongoDoc, {
+                      session
+                    }));
+                  }
+                }
+              }
+            }
+          }
+        });
+        await Promise.all(promises);
+        await session.commitTransaction();
+        return conflicts;
+      },
+      batchSize: options.push.batchSize,
+      modifier: options.push.modifier
+    };
+  }
+  var replicationState = new RxMongoDBReplicationState(mongoClient, mongoDatabase, mongoCollection, options, options.replicationIdentifier, options.collection, replicationPrimitivesPull, replicationPrimitivesPush, options.live, options.retryTime, options.autoStart);
+
+  /**
+   * Subscribe to changes for the pull.stream$
+   */
+  if (options.live && options.pull) {
+    var startBefore = replicationState.start.bind(replicationState);
+    var cancelBefore = replicationState.cancel.bind(replicationState);
+    replicationState.start = async () => {
+      var changestream = await startChangeStream(mongoCollection, undefined, replicationState.subjects.error);
+      changestream.on('change', () => {
+        // TODO use the documents data of the change instead of emitting the RESYNC flag
+        pullStream$.next('RESYNC');
+      });
+      replicationState.cancel = async () => {
+        await changestream.close();
+        return cancelBefore();
+      };
+      return startBefore();
+    };
+  }
+  startReplicationOnLeaderShip(options.waitForLeadership, replicationState);
+  return replicationState;
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/plugins/replication-mongodb/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["ensureNotFalsy","flatClone","RxDBLeaderElectionPlugin","RxReplicationState","startReplicationOnLeaderShip","addRxPlugin","Subject","MongoClient","MONGO_OPTIONS_DRIVER_INFO","iterateCheckpoint","mongodbDocToRxDB","rxdbDocToMongo","startChangeStream","RxMongoDBReplicationState","_RxReplicationState","mongoClient","mongoDatabase","mongoCollection","options","replicationIdentifier","collection","pull","push","live","retryTime","autoStart","_this","call","_inheritsLoose","replicateMongoDB","primaryPath","schema","waitForLeadership","pullStream$","mongodb","connection","db","databaseName","collectionName","replicationPrimitivesPull","handler","lastPulledCheckpoint","batchSize","result","documents","docs","checkpoint","modifier","stream$","asObservable","replicationPrimitivesPush","rows","conflicts","session","startSession","startTransaction","pushTransactionOptions","ids","map","row","newDocumentState","currentDocsArray","find","$in","toArray","currentDocsMap","Map","forEach","doc","set","promises","toMongoDoc","docId","current","get","remoteDocState","undefined","assumedMaster","assumedMasterState","_deleted","conflictHandler","isEqual","deleteOne","updateOne","$set","upsert","conflicting","insertOne","Promise","all","commitTransaction","replicationState","startBefore","start","bind","cancelBefore","cancel","changestream","subjects","error","on","next","close"],"sources":["../../../../src/plugins/replication-mongodb/index.ts"],"sourcesContent":["import {\r\n    ensureNotFalsy,\r\n    flatClone\r\n} from '../../plugins/utils/index.ts';\r\n\r\nimport { RxDBLeaderElectionPlugin } from '../leader-election/index.ts';\r\nimport type {\r\n    RxCollection,\r\n    ReplicationPullOptions,\r\n    ReplicationPushOptions,\r\n    RxReplicationWriteToMasterRow,\r\n    RxReplicationPullStreamItem,\r\n    RxDocumentData\r\n} from '../../types/index.d.ts';\r\nimport {\r\n    RxReplicationState,\r\n    startReplicationOnLeaderShip\r\n} from '../replication/index.ts';\r\nimport {\r\n    addRxPlugin,\r\n    WithDeleted\r\n} from '../../index.ts';\r\n\r\nimport { Subject } from 'rxjs';\r\nimport type {\r\n    MongoDbCheckpointType,\r\n    SyncOptionsMongoDB\r\n} from './mongodb-types.ts';\r\n\r\nimport {\r\n    Db as MongoDatabase,\r\n    Collection as MongoCollection,\r\n    MongoClient,\r\n    ClientSession\r\n} from 'mongodb';\r\nimport { MONGO_OPTIONS_DRIVER_INFO } from '../storage-mongodb/mongodb-helper.ts';\r\nimport { iterateCheckpoint } from './mongodb-checkpoint.ts';\r\nimport { mongodbDocToRxDB, rxdbDocToMongo, startChangeStream } from './mongodb-helper.ts';\r\n\r\nexport * from './mongodb-helper.ts';\r\nexport * from './mongodb-checkpoint.ts';\r\nexport type * from './mongodb-types.ts';\r\n\r\nexport class RxMongoDBReplicationState<RxDocType> extends RxReplicationState<RxDocType, MongoDbCheckpointType> {\r\n\r\n    constructor(\r\n        public readonly mongoClient: MongoClient,\r\n        public readonly mongoDatabase: MongoDatabase,\r\n        public readonly mongoCollection: MongoCollection<RxDocumentData<RxDocType> | any>,\r\n        public readonly options: SyncOptionsMongoDB<RxDocType>,\r\n        public readonly replicationIdentifier: string,\r\n        public readonly collection: RxCollection<RxDocType, any, any>,\r\n        public readonly pull?: ReplicationPullOptions<RxDocType, MongoDbCheckpointType>,\r\n        public readonly push?: ReplicationPushOptions<RxDocType>,\r\n        public readonly live: boolean = true,\r\n        public retryTime: number = 1000 * 5,\r\n        public autoStart: boolean = true\r\n    ) {\r\n\r\n        super(\r\n            replicationIdentifier,\r\n            collection,\r\n            '_deleted',\r\n            pull,\r\n            push,\r\n            live,\r\n            retryTime,\r\n            autoStart\r\n        );\r\n    }\r\n}\r\n\r\nexport function replicateMongoDB<RxDocType>(options: SyncOptionsMongoDB<RxDocType>) {\r\n    addRxPlugin(RxDBLeaderElectionPlugin);\r\n    const primaryPath = options.collection.schema.primaryPath;\r\n    options.live = typeof options.live === 'undefined' ? true : options.live;\r\n    options.waitForLeadership = typeof options.waitForLeadership === 'undefined' ? true : options.waitForLeadership;\r\n    const pullStream$: Subject<RxReplicationPullStreamItem<RxDocType, MongoDbCheckpointType>> = new Subject();\r\n\r\n    const mongoClient = new MongoClient(options.mongodb.connection, MONGO_OPTIONS_DRIVER_INFO);\r\n    const mongoDatabase = mongoClient.db(options.mongodb.databaseName);\r\n    const mongoCollection = mongoDatabase.collection(options.mongodb.collectionName);\r\n\r\n    let replicationPrimitivesPull: ReplicationPullOptions<RxDocType, MongoDbCheckpointType> | undefined;\r\n    if (options.pull) {\r\n        replicationPrimitivesPull = {\r\n            async handler(\r\n                lastPulledCheckpoint: MongoDbCheckpointType | undefined,\r\n                batchSize: number\r\n            ) {\r\n                const result = await iterateCheckpoint<RxDocType>(primaryPath, mongoCollection, batchSize, lastPulledCheckpoint);\r\n                return {\r\n                    documents: result.docs,\r\n                    checkpoint: result.checkpoint\r\n                };\r\n            },\r\n            batchSize: ensureNotFalsy(options.pull).batchSize,\r\n            modifier: ensureNotFalsy(options.pull).modifier,\r\n            stream$: pullStream$.asObservable()\r\n        };\r\n    }\r\n\r\n    let replicationPrimitivesPush: ReplicationPushOptions<RxDocType> | undefined;\r\n    if (options.push) {\r\n        replicationPrimitivesPush = {\r\n            async handler(\r\n                rows: RxReplicationWriteToMasterRow<RxDocType>[]\r\n            ) {\r\n                const conflicts: WithDeleted<RxDocType>[] = [];\r\n                const session: ClientSession = mongoClient.startSession();\r\n                session.startTransaction(options.mongodb.pushTransactionOptions);\r\n                const ids = rows.map(row => (row.newDocumentState as any)[primaryPath]);\r\n                const currentDocsArray = await mongoCollection.find(\r\n                    { [primaryPath]: { $in: ids } },\r\n                    { session }\r\n                ).toArray();\r\n                const currentDocsMap = new Map<any, any>();\r\n                currentDocsArray.forEach((doc: any) => {\r\n                    currentDocsMap.set(doc[primaryPath], doc);\r\n                });\r\n                let promises: Promise<any>[] = [];\r\n                rows.forEach(row => {\r\n                    const toMongoDoc = rxdbDocToMongo(row.newDocumentState as any);\r\n                    const docId = (row.newDocumentState as any)[primaryPath];\r\n                    const current = currentDocsMap.get(docId);\r\n                    const remoteDocState: WithDeleted<RxDocType> | undefined = current ? mongodbDocToRxDB(primaryPath, current) : undefined;\r\n\r\n                    /**\r\n                     * We do not want to require a deleted-flag or any RxDB specific stuff on the RxDB side.\r\n                     * So for deletes we have to hack around this.\r\n                     */\r\n                    let assumedMaster = row.assumedMasterState;\r\n                    if (row.newDocumentState._deleted) {\r\n                        if (remoteDocState) {\r\n                            if (!assumedMaster) {\r\n                                // remote exists but not assumed -> conflict\r\n                                conflicts.push(remoteDocState);\r\n                            } else if (assumedMaster._deleted) {\r\n                                // remote exists but assumed as deleted -> conflict\r\n                                conflicts.push(remoteDocState);\r\n                            } else {\r\n                                // remote exists and assumed to exist -> check for normal conflict or do the deletion-write\r\n                                if (options.collection.conflictHandler.isEqual(remoteDocState, assumedMaster, 'mongodb-pull-equal-check-deleted') === false) {\r\n                                    // conflict\r\n                                    conflicts.push(remoteDocState);\r\n                                } else {\r\n                                    promises.push(\r\n                                        mongoCollection.deleteOne(\r\n                                            {\r\n                                                [primaryPath]: docId\r\n                                            },\r\n                                            {\r\n                                                session\r\n                                            }\r\n                                        )\r\n                                    );\r\n                                }\r\n\r\n                            }\r\n                        } else {\r\n                            if (!assumedMaster) {\r\n                                // no remote and no assumed master -> insertion of deleted -> do nothing\r\n                            } else if (assumedMaster._deleted) {\r\n                                // no remote and assumed master also deleted -> insertion of deleted -> do nothing\r\n                            }\r\n                        }\r\n                    } else {\r\n                        /**\r\n                         * Non-deleted are handled normally like in every other\r\n                         * of the replication plugins.\r\n                         */\r\n                        if (\r\n                            remoteDocState &&\r\n                            (\r\n                                !row.assumedMasterState ||\r\n                                options.collection.conflictHandler.isEqual(remoteDocState, row.assumedMasterState, 'mongodb-pull-equal-check') === false\r\n                            )\r\n                        ) {\r\n                            // conflict\r\n                            conflicts.push(remoteDocState);\r\n                        } else {\r\n                            if (current) {\r\n                                if (row.newDocumentState._deleted) {\r\n                                    promises.push(\r\n                                        mongoCollection.deleteOne(\r\n                                            {\r\n                                                [primaryPath]: docId\r\n                                            },\r\n                                            {\r\n                                                session\r\n                                            }\r\n                                        )\r\n                                    );\r\n                                } else {\r\n                                    promises.push(\r\n                                        mongoCollection.updateOne(\r\n                                            { [primaryPath]: docId },\r\n                                            { $set: toMongoDoc },\r\n                                            {\r\n                                                upsert: true,\r\n                                                session\r\n                                            }\r\n                                        )\r\n                                    );\r\n                                }\r\n                            } else {\r\n                                /**\r\n                                 * No current but has assumed.\r\n                                 * This means the server state was deleted\r\n                                 * and we have a conflict.\r\n                                 */\r\n                                if (row.assumedMasterState) {\r\n                                    const conflicting = flatClone(row.assumedMasterState);\r\n                                    conflicting._deleted = true;\r\n                                    conflicts.push(conflicting);\r\n                                } else {\r\n                                    if (row.newDocumentState._deleted) {\r\n                                        // inserting deleted -> do nothing\r\n                                    } else {\r\n                                        promises.push(\r\n                                            mongoCollection.insertOne(toMongoDoc, { session })\r\n                                        );\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                });\r\n                await Promise.all(promises);\r\n                await session.commitTransaction();\r\n                return conflicts;\r\n            },\r\n            batchSize: options.push.batchSize,\r\n            modifier: options.push.modifier\r\n        };\r\n    }\r\n\r\n\r\n    const replicationState = new RxMongoDBReplicationState<RxDocType>(\r\n        mongoClient,\r\n        mongoDatabase,\r\n        mongoCollection,\r\n        options,\r\n        options.replicationIdentifier,\r\n        options.collection,\r\n        replicationPrimitivesPull,\r\n        replicationPrimitivesPush,\r\n        options.live,\r\n        options.retryTime,\r\n        options.autoStart\r\n    );\r\n\r\n    /**\r\n     * Subscribe to changes for the pull.stream$\r\n     */\r\n    if (options.live && options.pull) {\r\n        const startBefore = replicationState.start.bind(replicationState);\r\n        const cancelBefore = replicationState.cancel.bind(replicationState);\r\n        replicationState.start = async () => {\r\n            const changestream = await startChangeStream(mongoCollection, undefined, replicationState.subjects.error);\r\n            changestream.on('change', () => {\r\n                // TODO use the documents data of the change instead of emitting the RESYNC flag\r\n                pullStream$.next('RESYNC');\r\n            });\r\n            replicationState.cancel = async () => {\r\n                await changestream.close();\r\n                return cancelBefore();\r\n            };\r\n            return startBefore();\r\n        };\r\n    }\r\n\r\n    startReplicationOnLeaderShip(options.waitForLeadership, replicationState);\r\n    return replicationState;\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/replication-mongodb/mongodb-checkpoint.js

@@ -0,0 +1,131 @@
+import { clone, ensureNotFalsy, lastOfArray } from "../utils/index.js";
+import { mongodbDocToRxDB } from "./mongodb-helper.js";
+export async function getCurrentResumeToken(mongoCollection) {
+  var changeStream = mongoCollection.watch();
+
+  // Trigger the initial batch so postBatchResumeToken is available
+  await changeStream.tryNext().catch(() => {});
+  var token = changeStream.resumeToken;
+  changeStream.close();
+  return token;
+}
+export async function getDocsSinceChangestreamCheckpoint(primaryPath, mongoCollection,
+/**
+ * MongoDB has no way to start the stream from 'timestamp zero',
+ * we always need a resumeToken
+ */
+resumeToken, limit) {
+  var resultByDocId = new Map();
+  var changeStream = mongoCollection.watch([], {
+    resumeAfter: resumeToken,
+    fullDocument: 'required',
+    fullDocumentBeforeChange: 'required'
+  });
+
+  /**
+   * We cannot use changeStream.resumeToken for the
+   * updated token because depending on the batchSize of mongoCollection.watch()
+   * it might have changes but not emitting a new token.
+   */
+  var nextToken = resumeToken;
+  return new Promise(async (res, rej) => {
+    changeStream.on('error', err => {
+      rej(err);
+    });
+    var _loop = async function () {
+      var change = await changeStream.tryNext();
+      if (change) {
+        nextToken = change._id;
+        var docId = change.documentKey._id;
+        if (change.operationType === 'delete') {
+          var beforeDocMongo = ensureNotFalsy(change.fullDocumentBeforeChange, 'change must have pre-deletion state');
+          var beforeDoc = mongodbDocToRxDB(primaryPath, beforeDocMongo);
+          beforeDoc._deleted = true;
+          resultByDocId.set(docId, Promise.resolve(beforeDoc));
+        } else if (change.operationType === 'insert' || change.operationType === 'update' || change.operationType === 'replace') {
+          resultByDocId.set(docId, mongoCollection.findOne({
+            _id: docId
+          }).then(doc => {
+            if (doc) {
+              return mongodbDocToRxDB(primaryPath, doc);
+            } else {
+              var docFromChange = ensureNotFalsy(change.fullDocument, 'change must have change.fullDocument');
+              var ret = mongodbDocToRxDB(primaryPath, docFromChange);
+              ret._deleted = true;
+              return ret;
+            }
+          }));
+        }
+      } else {
+        return 1; // break
+      }
+    };
+    while (resultByDocId.size < limit) {
+      if (await _loop()) break;
+    }
+    changeStream.close();
+    var docs = await Promise.all(Array.from(resultByDocId.values()));
+    res({
+      docs,
+      nextToken: nextToken
+    });
+  });
+}
+export async function getDocsSinceDocumentCheckpoint(primaryPath, mongoCollection, limit, checkpointId) {
+  var query = checkpointId ? {
+    [primaryPath]: {
+      $gt: checkpointId
+    }
+  } : {};
+  var docs = await mongoCollection.find(query).sort({
+    [primaryPath]: 1
+  }).limit(limit).toArray();
+  return docs.map(d => mongodbDocToRxDB(primaryPath, d));
+}
+export async function iterateCheckpoint(primaryPath, mongoCollection, limit, checkpoint) {
+  if (!checkpoint) {
+    var token = await getCurrentResumeToken(mongoCollection);
+    checkpoint = {
+      iterate: 'docs-by-id',
+      changestreamResumeToken: token
+    };
+  } else {
+    checkpoint = clone(checkpoint);
+  }
+  var docs = [];
+  if (checkpoint.iterate === 'docs-by-id') {
+    docs = await getDocsSinceDocumentCheckpoint(primaryPath, mongoCollection, limit, checkpoint.docId);
+    var last = lastOfArray(docs);
+    if (last) {
+      checkpoint.docId = last[primaryPath];
+    }
+  } else {
+    var result = await getDocsSinceChangestreamCheckpoint(primaryPath, mongoCollection, checkpoint.changestreamResumeToken, limit);
+    docs = result.docs;
+    checkpoint.changestreamResumeToken = result.nextToken;
+  }
+
+  /**
+   * If we have to toggle from docs-by-id to changestream iteration
+   * mode, the docs array might not be full while we still have some docs left.
+   */
+  if (checkpoint.iterate === 'docs-by-id' && docs.length < limit) {
+    var ids = new Set();
+    docs.forEach(d => ids.add(d[primaryPath]));
+    var fillUp = await getDocsSinceChangestreamCheckpoint(primaryPath, mongoCollection, checkpoint.changestreamResumeToken, limit);
+    checkpoint.iterate = 'changestream';
+    checkpoint.changestreamResumeToken = fillUp.nextToken;
+    fillUp.docs.forEach(doc => {
+      var id = doc[primaryPath];
+      if (ids.has(id)) {
+        docs = docs.filter(d => d[primaryPath] !== id);
+      }
+      docs.push(doc);
+    });
+  }
+  return {
+    docs,
+    checkpoint
+  };
+}
+//# sourceMappingURL=mongodb-checkpoint.js.map

package/dist/esm/plugins/replication-mongodb/mongodb-checkpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb-checkpoint.js","names":["clone","ensureNotFalsy","lastOfArray","mongodbDocToRxDB","getCurrentResumeToken","mongoCollection","changeStream","watch","tryNext","catch","token","resumeToken","close","getDocsSinceChangestreamCheckpoint","primaryPath","limit","resultByDocId","Map","resumeAfter","fullDocument","fullDocumentBeforeChange","nextToken","Promise","res","rej","on","err","_loop","change","_id","docId","documentKey","operationType","beforeDocMongo","beforeDoc","_deleted","set","resolve","findOne","then","doc","docFromChange","ret","size","docs","all","Array","from","values","getDocsSinceDocumentCheckpoint","checkpointId","query","$gt","find","sort","toArray","map","d","iterateCheckpoint","checkpoint","iterate","changestreamResumeToken","last","result","length","ids","Set","forEach","add","fillUp","id","has","filter","push"],"sources":["../../../../src/plugins/replication-mongodb/mongodb-checkpoint.ts"],"sourcesContent":["import { WithDeleted } from '../../types/rx-storage';\r\nimport { clone, ensureNotFalsy, lastOfArray } from '../utils/index.ts';\r\nimport { mongodbDocToRxDB } from './mongodb-helper.ts';\r\nimport type {\r\n    MongoDBChangeStreamResumeToken,\r\n    MongoDBCheckpointIterationState,\r\n    MongoDbCheckpointType,\r\n} from './mongodb-types';\r\nimport {\r\n    Collection as MongoCollection\r\n} from 'mongodb';\r\n\r\n\r\nexport async function getCurrentResumeToken(\r\n    mongoCollection: MongoCollection\r\n): Promise<MongoDBChangeStreamResumeToken> {\r\n    const changeStream = mongoCollection.watch();\r\n\r\n    // Trigger the initial batch so postBatchResumeToken is available\r\n    await changeStream.tryNext().catch(() => { });\r\n\r\n    const token = changeStream.resumeToken;\r\n    changeStream.close();\r\n    return token as any;\r\n}\r\n\r\nexport async function getDocsSinceChangestreamCheckpoint<MongoDocType>(\r\n    primaryPath: string,\r\n    mongoCollection: MongoCollection,\r\n    /**\r\n     * MongoDB has no way to start the stream from 'timestamp zero',\r\n     * we always need a resumeToken\r\n     */\r\n    resumeToken: MongoDBChangeStreamResumeToken,\r\n    limit: number\r\n): Promise<{ docs: WithDeleted<MongoDocType>[], nextToken: MongoDBChangeStreamResumeToken }> {\r\n    const resultByDocId = new Map<string, Promise<WithDeleted<MongoDocType>>>();\r\n    const changeStream = mongoCollection.watch(\r\n        [],\r\n        {\r\n            resumeAfter: resumeToken,\r\n            fullDocument: 'required',\r\n            fullDocumentBeforeChange: 'required',\r\n        }\r\n    );\r\n\r\n\r\n    /**\r\n     * We cannot use changeStream.resumeToken for the\r\n     * updated token because depending on the batchSize of mongoCollection.watch()\r\n     * it might have changes but not emitting a new token.\r\n     */\r\n    let nextToken = resumeToken;\r\n\r\n    return new Promise(async (res, rej) => {\r\n        changeStream.on('error', (err: any) => {\r\n            rej(err);\r\n        });\r\n\r\n        while (resultByDocId.size < limit) {\r\n            const change = await changeStream.tryNext();\r\n            if (change) {\r\n                nextToken = change._id as any;\r\n                const docId = (change as any).documentKey._id;\r\n\r\n                if (change.operationType === 'delete') {\r\n                    const beforeDocMongo = ensureNotFalsy(\r\n                        change.fullDocumentBeforeChange,\r\n                        'change must have pre-deletion state'\r\n                    );\r\n                    const beforeDoc = mongodbDocToRxDB(primaryPath, beforeDocMongo as any);\r\n                    beforeDoc._deleted = true;\r\n                    resultByDocId.set(docId, Promise.resolve(beforeDoc as any));\r\n                } else if (\r\n                    change.operationType === 'insert' ||\r\n                    change.operationType === 'update' ||\r\n                    change.operationType === 'replace'\r\n                ) {\r\n                    resultByDocId.set(docId, mongoCollection.findOne({ _id: docId }).then((doc: any) => {\r\n                        if (doc) {\r\n                            return mongodbDocToRxDB(primaryPath, doc);\r\n                        } else {\r\n                            const docFromChange = ensureNotFalsy(\r\n                                change.fullDocument as any,\r\n                                'change must have change.fullDocument'\r\n                            );\r\n                            const ret = mongodbDocToRxDB(primaryPath, docFromChange);\r\n                            ret._deleted = true;\r\n                            return ret;\r\n                        }\r\n                    }));\r\n                }\r\n            } else {\r\n                break;\r\n            }\r\n        }\r\n\r\n        changeStream.close();\r\n\r\n        const docs = await Promise.all(Array.from(resultByDocId.values()));\r\n        res({ docs, nextToken: nextToken as any });\r\n    });\r\n}\r\n\r\nexport async function getDocsSinceDocumentCheckpoint<MongoDocType>(\r\n    primaryPath: string,\r\n    mongoCollection: MongoCollection,\r\n    limit: number,\r\n    checkpointId?: string\r\n): Promise<WithDeleted<MongoDocType>[]> {\r\n    const query = checkpointId\r\n        ? { [primaryPath]: { $gt: checkpointId } }\r\n        : {};\r\n\r\n    const docs = await mongoCollection\r\n        .find(query as any)\r\n        .sort({ [primaryPath]: 1 })\r\n        .limit(limit)\r\n        .toArray();\r\n\r\n    return docs.map((d: any) => mongodbDocToRxDB(primaryPath, d as any));\r\n}\r\n\r\n\r\nexport async function iterateCheckpoint<MongoDocType>(\r\n    primaryPath: string,\r\n    mongoCollection: MongoCollection,\r\n    limit: number,\r\n    checkpoint?: MongoDbCheckpointType,\r\n): Promise<MongoDBCheckpointIterationState<MongoDocType>> {\r\n    if (!checkpoint) {\r\n        const token = await getCurrentResumeToken(mongoCollection);\r\n        checkpoint = {\r\n            iterate: 'docs-by-id',\r\n            changestreamResumeToken: token\r\n        }\r\n    } else {\r\n        checkpoint = clone(checkpoint);\r\n    }\r\n\r\n    let docs: WithDeleted<MongoDocType>[] = [];\r\n    if (checkpoint.iterate === 'docs-by-id') {\r\n        docs = await getDocsSinceDocumentCheckpoint<MongoDocType>(primaryPath, mongoCollection, limit, checkpoint.docId);\r\n        const last = lastOfArray(docs);\r\n        if (last) {\r\n            checkpoint.docId = (last as any)[primaryPath];\r\n        }\r\n    } else {\r\n        const result = await getDocsSinceChangestreamCheckpoint<MongoDocType>(primaryPath, mongoCollection, checkpoint.changestreamResumeToken, limit);\r\n        docs = result.docs;\r\n        checkpoint.changestreamResumeToken = result.nextToken;\r\n    }\r\n\r\n    /**\r\n     * If we have to toggle from docs-by-id to changestream iteration\r\n     * mode, the docs array might not be full while we still have some docs left.\r\n     */\r\n    if (checkpoint.iterate === 'docs-by-id' && docs.length < limit) {\r\n        const ids = new Set<string>();\r\n        docs.forEach(d => ids.add((d as any)[primaryPath]));\r\n        const fillUp = await getDocsSinceChangestreamCheckpoint<MongoDocType>(\r\n            primaryPath,\r\n            mongoCollection,\r\n            checkpoint.changestreamResumeToken,\r\n            limit\r\n        );\r\n\r\n        checkpoint.iterate = 'changestream';\r\n        checkpoint.changestreamResumeToken = fillUp.nextToken;\r\n\r\n        fillUp.docs.forEach(doc => {\r\n            const id = (doc as any)[primaryPath];\r\n            if (ids.has(id)) {\r\n                docs = docs.filter(d => (d as any)[primaryPath] !== id);\r\n            }\r\n            docs.push(doc);\r\n        });\r\n    }\r\n\r\n    return {\r\n        docs,\r\n        checkpoint\r\n    };\r\n}\r\n"],"mappings":"AACA,SAASA,KAAK,EAAEC,cAAc,EAAEC,WAAW,QAAQ,mBAAmB;AACtE,SAASC,gBAAgB,QAAQ,qBAAqB;AAWtD,OAAO,eAAeC,qBAAqBA,CACvCC,eAAgC,EACO;EACvC,IAAMC,YAAY,GAAGD,eAAe,CAACE,KAAK,CAAC,CAAC;;EAE5C;EACA,MAAMD,YAAY,CAACE,OAAO,CAAC,CAAC,CAACC,KAAK,CAAC,MAAM,CAAE,CAAC,CAAC;EAE7C,IAAMC,KAAK,GAAGJ,YAAY,CAACK,WAAW;EACtCL,YAAY,CAACM,KAAK,CAAC,CAAC;EACpB,OAAOF,KAAK;AAChB;AAEA,OAAO,eAAeG,kCAAkCA,CACpDC,WAAmB,EACnBT,eAAgC;AAChC;AACJ;AACA;AACA;AACIM,WAA2C,EAC3CI,KAAa,EAC4E;EACzF,IAAMC,aAAa,GAAG,IAAIC,GAAG,CAA6C,CAAC;EAC3E,IAAMX,YAAY,GAAGD,eAAe,CAACE,KAAK,CACtC,EAAE,EACF;IACIW,WAAW,EAAEP,WAAW;IACxBQ,YAAY,EAAE,UAAU;IACxBC,wBAAwB,EAAE;EAC9B,CACJ,CAAC;;EAGD;AACJ;AACA;AACA;AACA;EACI,IAAIC,SAAS,GAAGV,WAAW;EAE3B,OAAO,IAAIW,OAAO,CAAC,OAAOC,GAAG,EAAEC,GAAG,KAAK;IACnClB,YAAY,CAACmB,EAAE,CAAC,OAAO,EAAGC,GAAQ,IAAK;MACnCF,GAAG,CAACE,GAAG,CAAC;IACZ,CAAC,CAAC;IAAC,IAAAC,KAAA,kBAAAA,CAAA,EAEgC;MAC/B,IAAMC,MAAM,GAAG,MAAMtB,YAAY,CAACE,OAAO,CAAC,CAAC;MAC3C,IAAIoB,MAAM,EAAE;QACRP,SAAS,GAAGO,MAAM,CAACC,GAAU;QAC7B,IAAMC,KAAK,GAAIF,MAAM,CAASG,WAAW,CAACF,GAAG;QAE7C,IAAID,MAAM,CAACI,aAAa,KAAK,QAAQ,EAAE;UACnC,IAAMC,cAAc,GAAGhC,cAAc,CACjC2B,MAAM,CAACR,wBAAwB,EAC/B,qCACJ,CAAC;UACD,IAAMc,SAAS,GAAG/B,gBAAgB,CAACW,WAAW,EAAEmB,cAAqB,CAAC;UACtEC,SAAS,CAACC,QAAQ,GAAG,IAAI;UACzBnB,aAAa,CAACoB,GAAG,CAACN,KAAK,EAAER,OAAO,CAACe,OAAO,CAACH,SAAgB,CAAC,CAAC;QAC/D,CAAC,MAAM,IACHN,MAAM,CAACI,aAAa,KAAK,QAAQ,IACjCJ,MAAM,CAACI,aAAa,KAAK,QAAQ,IACjCJ,MAAM,CAACI,aAAa,KAAK,SAAS,EACpC;UACEhB,aAAa,CAACoB,GAAG,CAACN,KAAK,EAAEzB,eAAe,CAACiC,OAAO,CAAC;YAAET,GAAG,EAAEC;UAAM,CAAC,CAAC,CAACS,IAAI,CAAEC,GAAQ,IAAK;YAChF,IAAIA,GAAG,EAAE;cACL,OAAOrC,gBAAgB,CAACW,WAAW,EAAE0B,GAAG,CAAC;YAC7C,CAAC,MAAM;cACH,IAAMC,aAAa,GAAGxC,cAAc,CAChC2B,MAAM,CAACT,YAAY,EACnB,sCACJ,CAAC;cACD,IAAMuB,GAAG,GAAGvC,gBAAgB,CAACW,WAAW,EAAE2B,aAAa,CAAC;cACxDC,GAAG,CAACP,QAAQ,GAAG,IAAI;cACnB,OAAOO,GAAG;YACd;UACJ,CAAC,CAAC,CAAC;QACP;MACJ,CAAC,MAAM;QAAA;MAEP;IACJ,CAAC;IApCD,OAAO1B,aAAa,CAAC2B,IAAI,GAAG5B,KAAK;MAAA,UAAAY,KAAA,IAkCzB;IAAM;IAIdrB,YAAY,CAACM,KAAK,CAAC,CAAC;IAEpB,IAAMgC,IAAI,GAAG,MAAMtB,OAAO,CAACuB,GAAG,CAACC,KAAK,CAACC,IAAI,CAAC/B,aAAa,CAACgC,MAAM,CAAC,CAAC,CAAC,CAAC;IAClEzB,GAAG,CAAC;MAAEqB,IAAI;MAAEvB,SAAS,EAAEA;IAAiB,CAAC,CAAC;EAC9C,CAAC,CAAC;AACN;AAEA,OAAO,eAAe4B,8BAA8BA,CAChDnC,WAAmB,EACnBT,eAAgC,EAChCU,KAAa,EACbmC,YAAqB,EACe;EACpC,IAAMC,KAAK,GAAGD,YAAY,GACpB;IAAE,CAACpC,WAAW,GAAG;MAAEsC,GAAG,EAAEF;IAAa;EAAE,CAAC,GACxC,CAAC,CAAC;EAER,IAAMN,IAAI,GAAG,MAAMvC,eAAe,CAC7BgD,IAAI,CAACF,KAAY,CAAC,CAClBG,IAAI,CAAC;IAAE,CAACxC,WAAW,GAAG;EAAE,CAAC,CAAC,CAC1BC,KAAK,CAACA,KAAK,CAAC,CACZwC,OAAO,CAAC,CAAC;EAEd,OAAOX,IAAI,CAACY,GAAG,CAAEC,CAAM,IAAKtD,gBAAgB,CAACW,WAAW,EAAE2C,CAAQ,CAAC,CAAC;AACxE;AAGA,OAAO,eAAeC,iBAAiBA,CACnC5C,WAAmB,EACnBT,eAAgC,EAChCU,KAAa,EACb4C,UAAkC,EACoB;EACtD,IAAI,CAACA,UAAU,EAAE;IACb,IAAMjD,KAAK,GAAG,MAAMN,qBAAqB,CAACC,eAAe,CAAC;IAC1DsD,UAAU,GAAG;MACTC,OAAO,EAAE,YAAY;MACrBC,uBAAuB,EAAEnD;IAC7B,CAAC;EACL,CAAC,MAAM;IACHiD,UAAU,GAAG3D,KAAK,CAAC2D,UAAU,CAAC;EAClC;EAEA,IAAIf,IAAiC,GAAG,EAAE;EAC1C,IAAIe,UAAU,CAACC,OAAO,KAAK,YAAY,EAAE;IACrChB,IAAI,GAAG,MAAMK,8BAA8B,CAAenC,WAAW,EAAET,eAAe,EAAEU,KAAK,EAAE4C,UAAU,CAAC7B,KAAK,CAAC;IAChH,IAAMgC,IAAI,GAAG5D,WAAW,CAAC0C,IAAI,CAAC;IAC9B,IAAIkB,IAAI,EAAE;MACNH,UAAU,CAAC7B,KAAK,GAAIgC,IAAI,CAAShD,WAAW,CAAC;IACjD;EACJ,CAAC,MAAM;IACH,IAAMiD,MAAM,GAAG,MAAMlD,kCAAkC,CAAeC,WAAW,EAAET,eAAe,EAAEsD,UAAU,CAACE,uBAAuB,EAAE9C,KAAK,CAAC;IAC9I6B,IAAI,GAAGmB,MAAM,CAACnB,IAAI;IAClBe,UAAU,CAACE,uBAAuB,GAAGE,MAAM,CAAC1C,SAAS;EACzD;;EAEA;AACJ;AACA;AACA;EACI,IAAIsC,UAAU,CAACC,OAAO,KAAK,YAAY,IAAIhB,IAAI,CAACoB,MAAM,GAAGjD,KAAK,EAAE;IAC5D,IAAMkD,GAAG,GAAG,IAAIC,GAAG,CAAS,CAAC;IAC7BtB,IAAI,CAACuB,OAAO,CAACV,CAAC,IAAIQ,GAAG,CAACG,GAAG,CAAEX,CAAC,CAAS3C,WAAW,CAAC,CAAC,CAAC;IACnD,IAAMuD,MAAM,GAAG,MAAMxD,kCAAkC,CACnDC,WAAW,EACXT,eAAe,EACfsD,UAAU,CAACE,uBAAuB,EAClC9C,KACJ,CAAC;IAED4C,UAAU,CAACC,OAAO,GAAG,cAAc;IACnCD,UAAU,CAACE,uBAAuB,GAAGQ,MAAM,CAAChD,SAAS;IAErDgD,MAAM,CAACzB,IAAI,CAACuB,OAAO,CAAC3B,GAAG,IAAI;MACvB,IAAM8B,EAAE,GAAI9B,GAAG,CAAS1B,WAAW,CAAC;MACpC,IAAImD,GAAG,CAACM,GAAG,CAACD,EAAE,CAAC,EAAE;QACb1B,IAAI,GAAGA,IAAI,CAAC4B,MAAM,CAACf,CAAC,IAAKA,CAAC,CAAS3C,WAAW,CAAC,KAAKwD,EAAE,CAAC;MAC3D;MACA1B,IAAI,CAAC6B,IAAI,CAACjC,GAAG,CAAC;IAClB,CAAC,CAAC;EACN;EAEA,OAAO;IACHI,IAAI;IACJe;EACJ,CAAC;AACL","ignoreList":[]}

package/dist/esm/plugins/replication-mongodb/mongodb-helper.js

@@ -0,0 +1,45 @@
+import { newRxError } from "../../rx-error.js";
+import { errorToPlainJson, flatClone, toArray } from "../utils/index.js";
+export async function startChangeStream(mongoCollection, resumeToken, errorSubject) {
+  var changeStream = mongoCollection.watch([], resumeToken ? {
+    resumeAfter: resumeToken
+  } : {});
+  if (errorSubject) {
+    changeStream.on('error', err => {
+      var emitError = newRxError('RC_STREAM', {
+        errors: toArray(err).map(er => errorToPlainJson(er))
+      });
+      errorSubject.next(emitError);
+    });
+  }
+  return changeStream;
+}
+export function mongodbDocToRxDB(primaryPath, doc) {
+  if (primaryPath === '_id' && typeof doc._id !== 'string') {
+    throw newRxError('MG1', {
+      document: doc
+    });
+  }
+  var useDoc = flatClone(doc);
+  useDoc._deleted = false;
+  if (primaryPath === '_id') {
+    return useDoc;
+  } else {
+    delete useDoc._id;
+    return useDoc;
+  }
+}
+
+/**
+ * MongoDB operations like mongoCollection.updateOne() will mutate the input!
+ * So we have to flat-clone first here.
+ * Also we do not want to store RxDB-specific metadata in the mongodb database.
+ */
+export function rxdbDocToMongo(doc) {
+  var ret = flatClone(doc);
+  delete ret._deleted;
+  delete ret._meta;
+  delete ret._attachments;
+  return ret;
+}
+//# sourceMappingURL=mongodb-helper.js.map

package/dist/esm/plugins/replication-mongodb/mongodb-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb-helper.js","names":["newRxError","errorToPlainJson","flatClone","toArray","startChangeStream","mongoCollection","resumeToken","errorSubject","changeStream","watch","resumeAfter","on","err","emitError","errors","map","er","next","mongodbDocToRxDB","primaryPath","doc","_id","document","useDoc","_deleted","rxdbDocToMongo","ret","_meta","_attachments"],"sources":["../../../../src/plugins/replication-mongodb/mongodb-helper.ts"],"sourcesContent":["import { Subject } from 'rxjs';\r\nimport { RxError, RxTypeError, newRxError } from '../../rx-error.ts';\r\nimport {\r\n    errorToPlainJson,\r\n    flatClone,\r\n    toArray\r\n} from '../utils/index.ts';\r\nimport type {\r\n    MongoDBChangeStreamResumeToken\r\n} from './mongodb-types';\r\nimport {\r\n    Collection as MongoCollection,\r\n    ChangeStream,\r\n    WithId\r\n} from 'mongodb';\r\nimport type { RxDocumentData, WithDeleted } from '../../types/rx-storage';\r\n\r\nexport async function startChangeStream(\r\n    mongoCollection: MongoCollection<any>,\r\n    resumeToken?: MongoDBChangeStreamResumeToken,\r\n    errorSubject?: Subject<RxError | RxTypeError>\r\n): Promise<ChangeStream> {\r\n    const changeStream = mongoCollection.watch([], resumeToken ? { resumeAfter: resumeToken } : {\r\n\r\n    });\r\n\r\n    if (errorSubject) {\r\n        changeStream.on('error', (err: any) => {\r\n            const emitError = newRxError('RC_STREAM', {\r\n                errors: toArray(err).map(er => errorToPlainJson(er))\r\n            });\r\n            errorSubject.next(emitError);\r\n        });\r\n    }\r\n    return changeStream;\r\n}\r\n\r\n\r\nexport function mongodbDocToRxDB<DocType>(primaryPath: string, doc: WithId<DocType>): WithDeleted<DocType> {\r\n    if (primaryPath === '_id' && typeof doc._id !== 'string') {\r\n        throw newRxError('MG1', {\r\n            document: doc\r\n        });\r\n    }\r\n\r\n    const useDoc: any = flatClone(doc);\r\n    useDoc._deleted = false;\r\n\r\n    if (primaryPath === '_id') {\r\n        return useDoc;\r\n    } else {\r\n        delete useDoc._id;\r\n        return useDoc;\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * MongoDB operations like mongoCollection.updateOne() will mutate the input!\r\n * So we have to flat-clone first here.\r\n * Also we do not want to store RxDB-specific metadata in the mongodb database.\r\n */\r\nexport function rxdbDocToMongo<DocType>(doc: RxDocumentData<DocType>): DocType {\r\n    const ret: any = flatClone(doc);\r\n    delete ret._deleted;\r\n    delete ret._meta;\r\n    delete ret._attachments;\r\n    return ret;\r\n}\r\n"],"mappings":"AACA,SAA+BA,UAAU,QAAQ,mBAAmB;AACpE,SACIC,gBAAgB,EAChBC,SAAS,EACTC,OAAO,QACJ,mBAAmB;AAW1B,OAAO,eAAeC,iBAAiBA,CACnCC,eAAqC,EACrCC,WAA4C,EAC5CC,YAA6C,EACxB;EACrB,IAAMC,YAAY,GAAGH,eAAe,CAACI,KAAK,CAAC,EAAE,EAAEH,WAAW,GAAG;IAAEI,WAAW,EAAEJ;EAAY,CAAC,GAAG,CAE5F,CAAC,CAAC;EAEF,IAAIC,YAAY,EAAE;IACdC,YAAY,CAACG,EAAE,CAAC,OAAO,EAAGC,GAAQ,IAAK;MACnC,IAAMC,SAAS,GAAGb,UAAU,CAAC,WAAW,EAAE;QACtCc,MAAM,EAAEX,OAAO,CAACS,GAAG,CAAC,CAACG,GAAG,CAACC,EAAE,IAAIf,gBAAgB,CAACe,EAAE,CAAC;MACvD,CAAC,CAAC;MACFT,YAAY,CAACU,IAAI,CAACJ,SAAS,CAAC;IAChC,CAAC,CAAC;EACN;EACA,OAAOL,YAAY;AACvB;AAGA,OAAO,SAASU,gBAAgBA,CAAUC,WAAmB,EAAEC,GAAoB,EAAwB;EACvG,IAAID,WAAW,KAAK,KAAK,IAAI,OAAOC,GAAG,CAACC,GAAG,KAAK,QAAQ,EAAE;IACtD,MAAMrB,UAAU,CAAC,KAAK,EAAE;MACpBsB,QAAQ,EAAEF;IACd,CAAC,CAAC;EACN;EAEA,IAAMG,MAAW,GAAGrB,SAAS,CAACkB,GAAG,CAAC;EAClCG,MAAM,CAACC,QAAQ,GAAG,KAAK;EAEvB,IAAIL,WAAW,KAAK,KAAK,EAAE;IACvB,OAAOI,MAAM;EACjB,CAAC,MAAM;IACH,OAAOA,MAAM,CAACF,GAAG;IACjB,OAAOE,MAAM;EACjB;AACJ;;AAGA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,cAAcA,CAAUL,GAA4B,EAAW;EAC3E,IAAMM,GAAQ,GAAGxB,SAAS,CAACkB,GAAG,CAAC;EAC/B,OAAOM,GAAG,CAACF,QAAQ;EACnB,OAAOE,GAAG,CAACC,KAAK;EAChB,OAAOD,GAAG,CAACE,YAAY;EACvB,OAAOF,GAAG;AACd","ignoreList":[]}

package/dist/esm/plugins/replication-mongodb/mongodb-types.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=mongodb-types.js.map

package/dist/esm/plugins/replication-mongodb/mongodb-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb-types.js","names":[],"sources":["../../../../src/plugins/replication-mongodb/mongodb-types.ts"],"sourcesContent":["import { TransactionOptions, WithId } from 'mongodb';\r\nimport type {\r\n    ReplicationOptions,\r\n    ReplicationPullOptions,\r\n    ReplicationPushOptions,\r\n    WithDeleted\r\n} from '../../types';\r\nimport type {\r\n    MongoDBConnectionString\r\n} from '../storage-mongodb/mongodb-types';\r\n\r\nexport type MongoDBChangeStreamResumeToken = {\r\n    _data: string;\r\n};\r\n\r\n\r\nexport type MongoDbCheckpointType = {\r\n    /**\r\n     * MongoDB has no wait to iterate over events\r\n     * from the beginning of time.\r\n     * Therefore we first iterate over the documents by their\r\n     * _id field and if that reached an end, we iterate from then on\r\n     * over the changestream resume token.\r\n     */\r\n    iterate: 'changestream' | 'docs-by-id';\r\n    changestreamResumeToken: MongoDBChangeStreamResumeToken;\r\n    docId?: string;\r\n}\r\n\r\nexport type MongoDBCheckpointIterationState<MongoDocType> = {\r\n    docs: WithDeleted<MongoDocType>[];\r\n    checkpoint: MongoDbCheckpointType;\r\n};\r\n\r\nexport type MongoDbConnectionConfig = {\r\n    connection: MongoDBConnectionString;\r\n    databaseName: string;\r\n    collectionName: string;\r\n    pushTransactionOptions?: TransactionOptions;\r\n};\r\n\r\nexport type SyncOptionsMongoDB<RxDocType> = Omit<\r\n    ReplicationOptions<RxDocType, any>,\r\n    'pull' | 'push' | 'deletedField'\r\n> & {\r\n    mongodb: MongoDbConnectionConfig;\r\n    pull?: Omit<ReplicationPullOptions<RxDocType, MongoDbCheckpointType>, 'handler' | 'stream$'> & {\r\n    };\r\n    push?: Omit<ReplicationPushOptions<RxDocType>, 'handler'>;\r\n};\r\n"],"mappings":"","ignoreList":[]}