@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/plugins/backup/index.js

@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  backupSingleDocument: true,
+  RxBackupState: true,
+  backup: true,
+  RxDBBackupPlugin: true
+};
+exports.RxDBBackupPlugin = exports.RxBackupState = void 0;
+exports.backup = backup;
+exports.backupSingleDocument = backupSingleDocument;
+var path = _interopRequireWildcard(require("node:path"));
+var _rxjs = require("rxjs");
+var _index = require("../../plugins/utils/index.js");
+var _fileUtil = require("./file-util.js");
+Object.keys(_fileUtil).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _fileUtil[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fileUtil[key];
+    }
+  });
+});
+var _rxStorageHelper = require("../../rx-storage-helper.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+/**
+ * Backups a single documents,
+ * returns the paths to all written files
+ */
+async function backupSingleDocument(rxDocument, options) {
+  var data = rxDocument.toJSON(true);
+  var writtenFiles = [];
+  var docFolder = (0, _fileUtil.documentFolder)(options, rxDocument.primary);
+  await (0, _fileUtil.clearFolder)(docFolder);
+  var fileLocation = path.join(docFolder, 'document.json');
+  await (0, _fileUtil.writeJsonToFile)(fileLocation, data);
+  writtenFiles.push(fileLocation);
+  if (options.attachments) {
+    var attachmentsFolder = path.join(docFolder, 'attachments');
+    (0, _fileUtil.ensureFolderExists)(attachmentsFolder);
+    var attachments = rxDocument.allAttachments();
+    await Promise.all(attachments.map(async attachment => {
+      var content = await attachment.getData();
+      var attachmentFileLocation = path.join(attachmentsFolder, attachment.id);
+      await (0, _fileUtil.writeToFile)(attachmentFileLocation, content);
+      writtenFiles.push(attachmentFileLocation);
+    }));
+  }
+  return writtenFiles;
+}
+var BACKUP_STATES_BY_DB = new WeakMap();
+function addToBackupStates(db, state) {
+  var ar = (0, _index.getFromMapOrCreate)(BACKUP_STATES_BY_DB, db, () => []);
+  ar.push(state);
+}
+var RxBackupState = exports.RxBackupState = /*#__PURE__*/function () {
+  function RxBackupState(database, options) {
+    this.isStopped = false;
+    this.subs = [];
+    this.persistRunning = _index.PROMISE_RESOLVE_VOID;
+    this.initialReplicationDone$ = new _rxjs.BehaviorSubject(false);
+    this.internalWriteEvents$ = new _rxjs.Subject();
+    this.writeEvents$ = this.internalWriteEvents$.asObservable();
+    this.database = database;
+    this.options = options;
+    if (!this.options.batchSize) {
+      this.options.batchSize = 10;
+    }
+    addToBackupStates(database, this);
+    (0, _fileUtil.prepareFolders)(database, options);
+  }
+
+  /**
+   * Persists all data from all collections,
+   * beginning from the oldest sequence checkpoint
+   * to the newest one.
+   * Do not call this while it is already running.
+   * Returns true if there are more documents to process
+   */
+  var _proto = RxBackupState.prototype;
+  _proto.persistOnce = function persistOnce() {
+    return this.persistRunning = this.persistRunning.then(() => this._persistOnce());
+  };
+  _proto._persistOnce = async function _persistOnce() {
+    var _this = this;
+    var meta = await (0, _fileUtil.getMeta)(this.options);
+    await Promise.all(Object.entries(this.database.collections).map(async ([collectionName, collection]) => {
+      var primaryKey = collection.schema.primaryPath;
+      var processedDocuments = new Set();
+      await this.database.requestIdlePromise();
+      if (!meta.collectionStates[collectionName]) {
+        meta.collectionStates[collectionName] = {};
+      }
+      var lastCheckpoint = meta.collectionStates[collectionName].checkpoint;
+      var hasMore = true;
+      var _loop = async function () {
+        await _this.database.requestIdlePromise();
+        var changesResult = await (0, _rxStorageHelper.getChangedDocumentsSince)(collection.storageInstance, _this.options.batchSize ? _this.options.batchSize : 0, lastCheckpoint);
+        lastCheckpoint = changesResult.documents.length > 0 ? changesResult.checkpoint : lastCheckpoint;
+        meta.collectionStates[collectionName].checkpoint = lastCheckpoint;
+        var docIds = changesResult.documents.map(doc => doc[primaryKey]).filter(id => {
+          if (processedDocuments.has(id)) {
+            return false;
+          } else {
+            processedDocuments.add(id);
+            return true;
+          }
+        }).filter((elem, pos, arr) => arr.indexOf(elem) === pos); // unique
+        await _this.database.requestIdlePromise();
+        var docs = await collection.findByIds(docIds).exec();
+        if (docs.size === 0) {
+          hasMore = false;
+          return 1; // continue
+        }
+        await Promise.all(Array.from(docs.values()).map(async doc => {
+          var writtenFiles = await backupSingleDocument(doc, _this.options);
+          _this.internalWriteEvents$.next({
+            collectionName: collection.name,
+            documentId: doc.primary,
+            files: writtenFiles,
+            deleted: false
+          });
+        }));
+        // handle deleted documents
+        await Promise.all(docIds.filter(docId => !docs.has(docId)).map(async docId => {
+          await (0, _fileUtil.deleteFolder)((0, _fileUtil.documentFolder)(_this.options, docId));
+          _this.internalWriteEvents$.next({
+            collectionName: collection.name,
+            documentId: docId,
+            files: [],
+            deleted: true
+          });
+        }));
+      };
+      while (hasMore && !this.isStopped) {
+        if (await _loop()) continue;
+      }
+      meta.collectionStates[collectionName].checkpoint = lastCheckpoint;
+      await (0, _fileUtil.setMeta)(this.options, meta);
+    }));
+    if (!this.initialReplicationDone$.getValue()) {
+      this.initialReplicationDone$.next(true);
+    }
+  };
+  _proto.watchForChanges = function watchForChanges() {
+    var collections = Object.values(this.database.collections);
+    collections.forEach(collection => {
+      var changes$ = collection.storageInstance.changeStream();
+      var sub = changes$.subscribe(() => {
+        this.persistOnce();
+      });
+      this.subs.push(sub);
+    });
+  }
+
+  /**
+   * Returns a promise that resolves when the initial backup is done
+   * and the filesystem is in sync with the database state
+   */;
+  _proto.awaitInitialBackup = function awaitInitialBackup() {
+    return (0, _rxjs.firstValueFrom)(this.initialReplicationDone$.pipe((0, _rxjs.filter)(v => !!v), (0, _rxjs.map)(() => true)));
+  };
+  _proto.cancel = function cancel() {
+    if (this.isStopped) {
+      return _index.PROMISE_RESOLVE_FALSE;
+    }
+    this.isStopped = true;
+    this.subs.forEach(sub => sub.unsubscribe());
+    return _index.PROMISE_RESOLVE_TRUE;
+  };
+  return RxBackupState;
+}();
+function backup(options) {
+  var backupState = new RxBackupState(this, options);
+  backupState.persistOnce();
+  if (options.live) {
+    backupState.watchForChanges();
+  }
+  return backupState;
+}
+var RxDBBackupPlugin = exports.RxDBBackupPlugin = {
+  name: 'backup',
+  rxdb: true,
+  prototypes: {
+    RxDatabase(proto) {
+      proto.backup = backup;
+    }
+  },
+  hooks: {
+    preCloseRxDatabase: {
+      after: function preCloseRxDatabase(db) {
+        var states = BACKUP_STATES_BY_DB.get(db);
+        if (states) {
+          states.forEach(state => state.cancel());
+        }
+      }
+    }
+  }
+};
+//# sourceMappingURL=index.js.map

package/dist/cjs/plugins/backup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["path","_interopRequireWildcard","require","_rxjs","_index","_fileUtil","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_rxStorageHelper","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","set","_t","getOwnPropertyDescriptor","backupSingleDocument","rxDocument","options","data","toJSON","writtenFiles","docFolder","documentFolder","primary","clearFolder","fileLocation","join","writeJsonToFile","push","attachments","attachmentsFolder","ensureFolderExists","allAttachments","Promise","all","map","attachment","content","getData","attachmentFileLocation","id","writeToFile","BACKUP_STATES_BY_DB","addToBackupStates","db","state","ar","getFromMapOrCreate","RxBackupState","database","isStopped","subs","persistRunning","PROMISE_RESOLVE_VOID","initialReplicationDone$","BehaviorSubject","internalWriteEvents$","Subject","writeEvents$","asObservable","batchSize","prepareFolders","_proto","persistOnce","then","_persistOnce","_this","meta","getMeta","entries","collections","collectionName","collection","primaryKey","schema","primaryPath","processedDocuments","Set","requestIdlePromise","collectionStates","lastCheckpoint","checkpoint","hasMore","_loop","changesResult","getChangedDocumentsSince","storageInstance","documents","length","docIds","doc","filter","add","elem","pos","arr","indexOf","docs","findByIds","exec","size","Array","from","values","next","name","documentId","files","deleted","docId","deleteFolder","setMeta","getValue","watchForChanges","changes$","changeStream","sub","subscribe","awaitInitialBackup","firstValueFrom","pipe","v","cancel","PROMISE_RESOLVE_FALSE","unsubscribe","PROMISE_RESOLVE_TRUE","backup","backupState","live","RxDBBackupPlugin","rxdb","prototypes","RxDatabase","proto","hooks","preCloseRxDatabase","after","states"],"sources":["../../../../src/plugins/backup/index.ts"],"sourcesContent":["import * as path from 'node:path';\r\nimport {\r\n    BehaviorSubject,\r\n    firstValueFrom,\r\n    Observable,\r\n    Subject,\r\n    Subscription\r\n} from 'rxjs';\r\nimport {\r\n    filter,\r\n    map\r\n} from 'rxjs';\r\nimport type {\r\n    BackupOptions,\r\n    RxBackupWriteEvent,\r\n    RxCollection,\r\n    RxDatabase,\r\n    RxDocument,\r\n    RxPlugin\r\n} from '../../types/index.d.ts';\r\nimport {\r\n    getFromMapOrCreate,\r\n    PROMISE_RESOLVE_FALSE,\r\n    PROMISE_RESOLVE_TRUE,\r\n    PROMISE_RESOLVE_VOID\r\n} from '../../plugins/utils/index.ts';\r\nimport {\r\n    clearFolder,\r\n    deleteFolder,\r\n    documentFolder,\r\n    ensureFolderExists,\r\n    getMeta,\r\n    prepareFolders,\r\n    setMeta,\r\n    writeJsonToFile,\r\n    writeToFile\r\n} from './file-util.ts';\r\nimport { getChangedDocumentsSince } from '../../rx-storage-helper.ts';\r\n\r\n\r\n/**\r\n * Backups a single documents,\r\n * returns the paths to all written files\r\n */\r\nexport async function backupSingleDocument(\r\n    rxDocument: RxDocument<any, any>,\r\n    options: BackupOptions\r\n): Promise<string[]> {\r\n    const data = rxDocument.toJSON(true);\r\n    const writtenFiles: string[] = [];\r\n\r\n    const docFolder = documentFolder(options, rxDocument.primary);\r\n    await clearFolder(docFolder);\r\n\r\n    const fileLocation = path.join(\r\n        docFolder,\r\n        'document.json'\r\n    );\r\n    await writeJsonToFile(fileLocation, data);\r\n    writtenFiles.push(fileLocation);\r\n\r\n    if (options.attachments) {\r\n        const attachmentsFolder = path.join(\r\n            docFolder,\r\n            'attachments'\r\n        );\r\n        ensureFolderExists(attachmentsFolder);\r\n        const attachments = (rxDocument as RxDocument).allAttachments();\r\n        await Promise.all(\r\n            attachments\r\n                .map(async (attachment) => {\r\n                    const content = await attachment.getData();\r\n                    const attachmentFileLocation = path.join(\r\n                        attachmentsFolder,\r\n                        attachment.id\r\n                    );\r\n                    await writeToFile(attachmentFileLocation, content);\r\n                    writtenFiles.push(attachmentFileLocation);\r\n                })\r\n        );\r\n    }\r\n\r\n    return writtenFiles;\r\n}\r\n\r\nconst BACKUP_STATES_BY_DB: WeakMap<RxDatabase, RxBackupState[]> = new WeakMap();\r\nfunction addToBackupStates(db: RxDatabase, state: RxBackupState) {\r\n    const ar = getFromMapOrCreate(\r\n        BACKUP_STATES_BY_DB,\r\n        db,\r\n        () => []\r\n    );\r\n    ar.push(state);\r\n}\r\n\r\nexport class RxBackupState {\r\n    public isStopped: boolean = false;\r\n    private subs: Subscription[] = [];\r\n    private persistRunning: Promise<void> = PROMISE_RESOLVE_VOID;\r\n    private initialReplicationDone$: BehaviorSubject<boolean> = new BehaviorSubject(false as any);\r\n\r\n    private readonly internalWriteEvents$: Subject<RxBackupWriteEvent> = new Subject();\r\n    public readonly writeEvents$: Observable<RxBackupWriteEvent> = this.internalWriteEvents$.asObservable();\r\n\r\n    constructor(\r\n        public readonly database: RxDatabase,\r\n        public readonly options: BackupOptions\r\n    ) {\r\n        if (!this.options.batchSize) {\r\n            this.options.batchSize = 10;\r\n        }\r\n        addToBackupStates(database, this);\r\n        prepareFolders(database, options);\r\n    }\r\n\r\n    /**\r\n     * Persists all data from all collections,\r\n     * beginning from the oldest sequence checkpoint\r\n     * to the newest one.\r\n     * Do not call this while it is already running.\r\n     * Returns true if there are more documents to process\r\n     */\r\n    public persistOnce() {\r\n        return this.persistRunning = this.persistRunning.then(() => this._persistOnce());\r\n    }\r\n\r\n    public async _persistOnce() {\r\n        const meta = await getMeta(this.options);\r\n\r\n        await Promise.all(\r\n            Object\r\n                .entries(this.database.collections)\r\n                .map(async ([collectionName, collection]) => {\r\n                    const primaryKey = collection.schema.primaryPath;\r\n                    const processedDocuments: Set<string> = new Set();\r\n\r\n                    await this.database.requestIdlePromise();\r\n\r\n                    if (!meta.collectionStates[collectionName]) {\r\n                        meta.collectionStates[collectionName] = {};\r\n                    }\r\n                    let lastCheckpoint = meta.collectionStates[collectionName].checkpoint;\r\n\r\n                    let hasMore = true;\r\n                    while (hasMore && !this.isStopped) {\r\n                        await this.database.requestIdlePromise();\r\n                        const changesResult = await getChangedDocumentsSince(\r\n                            collection.storageInstance,\r\n                            this.options.batchSize ? this.options.batchSize : 0,\r\n                            lastCheckpoint\r\n                        );\r\n                        lastCheckpoint = changesResult.documents.length > 0 ? changesResult.checkpoint : lastCheckpoint;\r\n                        meta.collectionStates[collectionName].checkpoint = lastCheckpoint;\r\n\r\n                        const docIds: string[] = changesResult.documents\r\n                            .map(doc => doc[primaryKey])\r\n                            .filter(id => {\r\n                                if (\r\n                                    processedDocuments.has(id)\r\n                                ) {\r\n                                    return false;\r\n                                } else {\r\n                                    processedDocuments.add(id);\r\n                                    return true;\r\n                                }\r\n                            })\r\n                            .filter((elem, pos, arr) => arr.indexOf(elem) === pos); // unique\r\n                        await this.database.requestIdlePromise();\r\n\r\n                        const docs: Map<string, RxDocument> = await collection.findByIds(docIds).exec();\r\n                        if (docs.size === 0) {\r\n                            hasMore = false;\r\n                            continue;\r\n                        }\r\n                        await Promise.all(\r\n                            Array\r\n                                .from(docs.values())\r\n                                .map(async (doc) => {\r\n                                    const writtenFiles = await backupSingleDocument(doc, this.options);\r\n                                    this.internalWriteEvents$.next({\r\n                                        collectionName: collection.name,\r\n                                        documentId: doc.primary,\r\n                                        files: writtenFiles,\r\n                                        deleted: false\r\n                                    });\r\n                                })\r\n                        );\r\n                        // handle deleted documents\r\n                        await Promise.all(\r\n                            docIds\r\n                                .filter(docId => !docs.has(docId))\r\n                                .map(async (docId) => {\r\n                                    await deleteFolder(documentFolder(this.options, docId));\r\n                                    this.internalWriteEvents$.next({\r\n                                        collectionName: collection.name,\r\n                                        documentId: docId,\r\n                                        files: [],\r\n                                        deleted: true\r\n                                    });\r\n                                })\r\n                        );\r\n                    }\r\n                    meta.collectionStates[collectionName].checkpoint = lastCheckpoint;\r\n                    await setMeta(this.options, meta);\r\n                })\r\n        );\r\n\r\n        if (!this.initialReplicationDone$.getValue()) {\r\n            this.initialReplicationDone$.next(true);\r\n        }\r\n    }\r\n\r\n    public watchForChanges() {\r\n        const collections: RxCollection[] = Object.values(this.database.collections);\r\n        collections.forEach(collection => {\r\n            const changes$ = collection.storageInstance.changeStream();\r\n            const sub = changes$.subscribe(() => {\r\n                this.persistOnce();\r\n            });\r\n            this.subs.push(sub);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Returns a promise that resolves when the initial backup is done\r\n     * and the filesystem is in sync with the database state\r\n     */\r\n    public awaitInitialBackup(): Promise<boolean> {\r\n        return firstValueFrom(\r\n            this.initialReplicationDone$.pipe(\r\n                filter((v: boolean) => !!v),\r\n                map(() => true)\r\n            )\r\n        );\r\n    }\r\n\r\n    cancel(): Promise<boolean> {\r\n        if (this.isStopped) {\r\n            return PROMISE_RESOLVE_FALSE;\r\n        }\r\n        this.isStopped = true;\r\n        this.subs.forEach(sub => sub.unsubscribe());\r\n        return PROMISE_RESOLVE_TRUE;\r\n    }\r\n}\r\n\r\n\r\nexport function backup(\r\n    this: RxDatabase,\r\n    options: BackupOptions\r\n): RxBackupState {\r\n    const backupState = new RxBackupState(this, options);\r\n    backupState.persistOnce();\r\n\r\n    if (options.live) {\r\n        backupState.watchForChanges();\r\n    }\r\n\r\n    return backupState;\r\n}\r\n\r\nexport * from './file-util.ts';\r\nexport const RxDBBackupPlugin: RxPlugin = {\r\n    name: 'backup',\r\n    rxdb: true,\r\n    prototypes: {\r\n        RxDatabase(proto: any) {\r\n            proto.backup = backup;\r\n        }\r\n    },\r\n    hooks: {\r\n        preCloseRxDatabase: {\r\n            after: function preCloseRxDatabase(db: RxDatabase) {\r\n                const states = BACKUP_STATES_BY_DB.get(db);\r\n                if (states) {\r\n                    states.forEach(state => state.cancel());\r\n                }\r\n            }\r\n        }\r\n    }\r\n};\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/cleanup/cleanup-helper.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_CLEANUP_POLICY = void 0;
+var DEFAULT_CLEANUP_POLICY = exports.DEFAULT_CLEANUP_POLICY = {
+  minimumDeletedTime: 1000 * 60 * 60 * 24 * 31,
+  // one month
+  minimumCollectionAge: 1000 * 60,
+  // 60 seconds
+  runEach: 1000 * 60 * 5,
+  // 5 minutes
+  awaitReplicationsInSync: true,
+  waitForLeadership: true
+};
+//# sourceMappingURL=cleanup-helper.js.map

package/dist/cjs/plugins/cleanup/cleanup-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup-helper.js","names":["DEFAULT_CLEANUP_POLICY","exports","minimumDeletedTime","minimumCollectionAge","runEach","awaitReplicationsInSync","waitForLeadership"],"sources":["../../../../src/plugins/cleanup/cleanup-helper.ts"],"sourcesContent":["import type {\r\n    RxCleanupPolicy\r\n} from '../../types/index.d.ts';\r\n\r\nexport const DEFAULT_CLEANUP_POLICY: RxCleanupPolicy = {\r\n    minimumDeletedTime: 1000 * 60 * 60 * 24 * 31, // one month\r\n    minimumCollectionAge: 1000 * 60, // 60 seconds\r\n    runEach: 1000 * 60 * 5, // 5 minutes\r\n    awaitReplicationsInSync: true,\r\n    waitForLeadership: true\r\n};\r\n"],"mappings":";;;;;;AAIO,IAAMA,sBAAuC,GAAAC,OAAA,CAAAD,sBAAA,GAAG;EACnDE,kBAAkB,EAAE,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;EAAE;EAC9CC,oBAAoB,EAAE,IAAI,GAAG,EAAE;EAAE;EACjCC,OAAO,EAAE,IAAI,GAAG,EAAE,GAAG,CAAC;EAAE;EACxBC,uBAAuB,EAAE,IAAI;EAC7BC,iBAAiB,EAAE;AACvB,CAAC","ignoreList":[]}

package/dist/cjs/plugins/cleanup/cleanup-state.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanupRxState = cleanupRxState;
+exports.runCleanupAfterWrite = runCleanupAfterWrite;
+exports.startCleanupForRxState = startCleanupForRxState;
+var _index = require("../../plugins/utils/index.js");
+var _index2 = require("../replication/index.js");
+var _cleanupHelper = require("./cleanup-helper.js");
+var _cleanup = require("./cleanup.js");
+var _rxjs = require("rxjs");
+var RXSTATE_CLEANUP_QUEUE = _index.PROMISE_RESOLVE_TRUE;
+async function startCleanupForRxState(state) {
+  var rxCollection = state.collection;
+  var rxDatabase = rxCollection.database;
+  var cleanupPolicy = Object.assign({}, _cleanupHelper.DEFAULT_CLEANUP_POLICY, rxDatabase.cleanupPolicy ? rxDatabase.cleanupPolicy : {});
+  await (0, _cleanup.initialCleanupWait)(rxCollection, cleanupPolicy);
+  if (rxCollection.closed) {
+    return;
+  }
+
+  // initially cleanup the state
+  await cleanupRxState(state, cleanupPolicy);
+
+  /**
+   * Afterwards we listen to writes
+   * and only re-run the cleanup if there was a write
+   * to the state.
+   */
+  await runCleanupAfterWrite(state, cleanupPolicy);
+}
+/**
+ * Runs the cleanup for a single RxState
+ */
+async function cleanupRxState(state, cleanupPolicy) {
+  var rxCollection = state.collection;
+  var rxDatabase = rxCollection.database;
+
+  // run cleanup() until it returns true
+  var isDone = false;
+  while (!isDone && !rxCollection.closed) {
+    if (cleanupPolicy.awaitReplicationsInSync) {
+      var replicationStates = _index2.REPLICATION_STATE_BY_COLLECTION.get(rxCollection);
+      if (replicationStates) {
+        await Promise.all(replicationStates.map(replicationState => {
+          if (!replicationState.isStopped()) {
+            return replicationState.awaitInSync();
+          }
+        }));
+      }
+    }
+    if (rxCollection.closed) {
+      return;
+    }
+    RXSTATE_CLEANUP_QUEUE = RXSTATE_CLEANUP_QUEUE.then(async () => {
+      if (rxCollection.closed) {
+        return true;
+      }
+      await rxDatabase.requestIdlePromise();
+      return state._cleanup();
+    });
+    isDone = await RXSTATE_CLEANUP_QUEUE;
+  }
+}
+async function runCleanupAfterWrite(state, cleanupPolicy) {
+  var rxCollection = state.collection;
+  while (!rxCollection.closed) {
+    /**
+     * We only start the timer if there was actually a write
+     * to the collection. Otherwise the cleanup would
+     * just run on intervals even if nothing has changed.
+     */
+    await (0, _rxjs.firstValueFrom)(rxCollection.eventBulks$).catch(() => {});
+    await rxCollection.promiseWait(cleanupPolicy.runEach);
+    if (rxCollection.closed) {
+      return;
+    }
+    await cleanupRxState(state, cleanupPolicy);
+  }
+}
+//# sourceMappingURL=cleanup-state.js.map

package/dist/cjs/plugins/cleanup/cleanup-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup-state.js","names":["_index","require","_index2","_cleanupHelper","_cleanup","_rxjs","RXSTATE_CLEANUP_QUEUE","PROMISE_RESOLVE_TRUE","startCleanupForRxState","state","rxCollection","collection","rxDatabase","database","cleanupPolicy","Object","assign","DEFAULT_CLEANUP_POLICY","initialCleanupWait","closed","cleanupRxState","runCleanupAfterWrite","isDone","awaitReplicationsInSync","replicationStates","REPLICATION_STATE_BY_COLLECTION","get","Promise","all","map","replicationState","isStopped","awaitInSync","then","requestIdlePromise","firstValueFrom","eventBulks$","catch","promiseWait","runEach"],"sources":["../../../../src/plugins/cleanup/cleanup-state.ts"],"sourcesContent":["import type { RxCleanupPolicy, RxState } from '../../types/index.d.ts';\r\nimport { PROMISE_RESOLVE_TRUE } from '../../plugins/utils/index.ts';\r\nimport { REPLICATION_STATE_BY_COLLECTION } from '../replication/index.ts';\r\nimport { DEFAULT_CLEANUP_POLICY } from './cleanup-helper.ts';\r\nimport { initialCleanupWait } from './cleanup.ts';\r\nimport { firstValueFrom } from 'rxjs';\r\n\r\nlet RXSTATE_CLEANUP_QUEUE: Promise<any> = PROMISE_RESOLVE_TRUE;\r\n\r\nexport async function startCleanupForRxState(state: RxState<unknown, unknown>) {\r\n    const rxCollection = state.collection;\r\n    const rxDatabase = rxCollection.database;\r\n    const cleanupPolicy = Object.assign(\r\n        {},\r\n        DEFAULT_CLEANUP_POLICY,\r\n        rxDatabase.cleanupPolicy ? rxDatabase.cleanupPolicy : {}\r\n    );\r\n\r\n    await initialCleanupWait(rxCollection, cleanupPolicy);\r\n    if (rxCollection.closed) {\r\n        return;\r\n    }\r\n\r\n    // initially cleanup the state\r\n    await cleanupRxState(state, cleanupPolicy);\r\n\r\n    /**\r\n     * Afterwards we listen to writes\r\n     * and only re-run the cleanup if there was a write\r\n     * to the state.\r\n     */\r\n    await runCleanupAfterWrite(state, cleanupPolicy);\r\n}\r\n/**\r\n * Runs the cleanup for a single RxState\r\n */\r\nexport async function cleanupRxState(\r\n    state: RxState<unknown, unknown>,\r\n    cleanupPolicy: RxCleanupPolicy\r\n) {\r\n    const rxCollection = state.collection;\r\n    const rxDatabase = rxCollection.database;\r\n\r\n    // run cleanup() until it returns true\r\n    let isDone = false;\r\n    while (!isDone && !rxCollection.closed) {\r\n        if (cleanupPolicy.awaitReplicationsInSync) {\r\n            const replicationStates = REPLICATION_STATE_BY_COLLECTION.get(rxCollection);\r\n            if (replicationStates) {\r\n                await Promise.all(\r\n                    replicationStates.map(replicationState => {\r\n                        if (!replicationState.isStopped()) {\r\n                            return replicationState.awaitInSync();\r\n                        }\r\n                    })\r\n                );\r\n            }\r\n        }\r\n        if (rxCollection.closed) {\r\n            return;\r\n        }\r\n        RXSTATE_CLEANUP_QUEUE = RXSTATE_CLEANUP_QUEUE\r\n            .then(async () => {\r\n                if (rxCollection.closed) {\r\n                    return true;\r\n                }\r\n                await rxDatabase.requestIdlePromise();\r\n                return state._cleanup();\r\n            });\r\n        isDone = await RXSTATE_CLEANUP_QUEUE;\r\n    }\r\n}\r\n\r\nexport async function runCleanupAfterWrite(\r\n    state: RxState<unknown, unknown>,\r\n    cleanupPolicy: RxCleanupPolicy\r\n) {\r\n    const rxCollection = state.collection;\r\n    while (!rxCollection.closed) {\r\n        /**\r\n         * We only start the timer if there was actually a write\r\n         * to the collection. Otherwise the cleanup would\r\n         * just run on intervals even if nothing has changed.\r\n         */\r\n        await firstValueFrom(rxCollection.eventBulks$).catch(() => { });\r\n        await rxCollection.promiseWait(cleanupPolicy.runEach);\r\n        if (rxCollection.closed) {\r\n            return;\r\n        }\r\n        await cleanupRxState(state, cleanupPolicy);\r\n    }\r\n}\r\n"],"mappings":";;;;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,cAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,KAAA,GAAAJ,OAAA;AAEA,IAAIK,qBAAmC,GAAGC,2BAAoB;AAEvD,eAAeC,sBAAsBA,CAACC,KAAgC,EAAE;EAC3E,IAAMC,YAAY,GAAGD,KAAK,CAACE,UAAU;EACrC,IAAMC,UAAU,GAAGF,YAAY,CAACG,QAAQ;EACxC,IAAMC,aAAa,GAAGC,MAAM,CAACC,MAAM,CAC/B,CAAC,CAAC,EACFC,qCAAsB,EACtBL,UAAU,CAACE,aAAa,GAAGF,UAAU,CAACE,aAAa,GAAG,CAAC,CAC3D,CAAC;EAED,MAAM,IAAAI,2BAAkB,EAACR,YAAY,EAAEI,aAAa,CAAC;EACrD,IAAIJ,YAAY,CAACS,MAAM,EAAE;IACrB;EACJ;;EAEA;EACA,MAAMC,cAAc,CAACX,KAAK,EAAEK,aAAa,CAAC;;EAE1C;AACJ;AACA;AACA;AACA;EACI,MAAMO,oBAAoB,CAACZ,KAAK,EAAEK,aAAa,CAAC;AACpD;AACA;AACA;AACA;AACO,eAAeM,cAAcA,CAChCX,KAAgC,EAChCK,aAA8B,EAChC;EACE,IAAMJ,YAAY,GAAGD,KAAK,CAACE,UAAU;EACrC,IAAMC,UAAU,GAAGF,YAAY,CAACG,QAAQ;;EAExC;EACA,IAAIS,MAAM,GAAG,KAAK;EAClB,OAAO,CAACA,MAAM,IAAI,CAACZ,YAAY,CAACS,MAAM,EAAE;IACpC,IAAIL,aAAa,CAACS,uBAAuB,EAAE;MACvC,IAAMC,iBAAiB,GAAGC,uCAA+B,CAACC,GAAG,CAAChB,YAAY,CAAC;MAC3E,IAAIc,iBAAiB,EAAE;QACnB,MAAMG,OAAO,CAACC,GAAG,CACbJ,iBAAiB,CAACK,GAAG,CAACC,gBAAgB,IAAI;UACtC,IAAI,CAACA,gBAAgB,CAACC,SAAS,CAAC,CAAC,EAAE;YAC/B,OAAOD,gBAAgB,CAACE,WAAW,CAAC,CAAC;UACzC;QACJ,CAAC,CACL,CAAC;MACL;IACJ;IACA,IAAItB,YAAY,CAACS,MAAM,EAAE;MACrB;IACJ;IACAb,qBAAqB,GAAGA,qBAAqB,CACxC2B,IAAI,CAAC,YAAY;MACd,IAAIvB,YAAY,CAACS,MAAM,EAAE;QACrB,OAAO,IAAI;MACf;MACA,MAAMP,UAAU,CAACsB,kBAAkB,CAAC,CAAC;MACrC,OAAOzB,KAAK,CAACL,QAAQ,CAAC,CAAC;IAC3B,CAAC,CAAC;IACNkB,MAAM,GAAG,MAAMhB,qBAAqB;EACxC;AACJ;AAEO,eAAee,oBAAoBA,CACtCZ,KAAgC,EAChCK,aAA8B,EAChC;EACE,IAAMJ,YAAY,GAAGD,KAAK,CAACE,UAAU;EACrC,OAAO,CAACD,YAAY,CAACS,MAAM,EAAE;IACzB;AACR;AACA;AACA;AACA;IACQ,MAAM,IAAAgB,oBAAc,EAACzB,YAAY,CAAC0B,WAAW,CAAC,CAACC,KAAK,CAAC,MAAM,CAAE,CAAC,CAAC;IAC/D,MAAM3B,YAAY,CAAC4B,WAAW,CAACxB,aAAa,CAACyB,OAAO,CAAC;IACrD,IAAI7B,YAAY,CAACS,MAAM,EAAE;MACrB;IACJ;IACA,MAAMC,cAAc,CAACX,KAAK,EAAEK,aAAa,CAAC;EAC9C;AACJ","ignoreList":[]}

package/dist/cjs/plugins/cleanup/cleanup.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanupRxCollection = cleanupRxCollection;
+exports.initialCleanupWait = initialCleanupWait;
+exports.runCleanupAfterDelete = runCleanupAfterDelete;
+exports.startCleanupForRxCollection = startCleanupForRxCollection;
+var _index = require("../../plugins/utils/index.js");
+var _index2 = require("../replication/index.js");
+var _cleanupHelper = require("./cleanup-helper.js");
+var _hooks = require("../../hooks.js");
+var _rxjs = require("rxjs");
+/**
+ * Even on multiple databases,
+ * the calls to RxStorage().cleanup()
+ * must never run in parallel.
+ * The cleanup is a background task which should
+ * not affect the performance of other, more important tasks.
+ */
+var RXSTORAGE_CLEANUP_QUEUE = _index.PROMISE_RESOLVE_TRUE;
+async function startCleanupForRxCollection(rxCollection) {
+  var rxDatabase = rxCollection.database;
+  var cleanupPolicy = Object.assign({}, _cleanupHelper.DEFAULT_CLEANUP_POLICY, rxDatabase.cleanupPolicy ? rxDatabase.cleanupPolicy : {});
+  await initialCleanupWait(rxCollection, cleanupPolicy);
+  if (rxCollection.closed) {
+    return;
+  }
+
+  // initially cleanup the collection
+  await cleanupRxCollection(rxCollection, cleanupPolicy);
+
+  /**
+   * Afterwards we listen to deletes
+   * and only re-run the cleanup after
+   * minimumDeletedTime is reached.
+   */
+  await runCleanupAfterDelete(rxCollection, cleanupPolicy);
+}
+async function initialCleanupWait(collection, cleanupPolicy) {
+  /**
+   * Wait until minimumDatabaseInstanceAge is reached
+   * or collection is closed.
+   */
+  await collection.promiseWait(cleanupPolicy.minimumCollectionAge);
+  if (collection.closed) {
+    return;
+  }
+  if (collection.database.multiInstance && cleanupPolicy.waitForLeadership) {
+    await collection.database.waitForLeadership();
+  }
+}
+
+/**
+ * Runs the cleanup for a single RxCollection
+ */
+async function cleanupRxCollection(rxCollection, cleanupPolicy) {
+  var rxDatabase = rxCollection.database;
+  var storageInstance = rxCollection.storageInstance;
+
+  // run cleanup() until it returns true
+  var isDone = false;
+  while (!isDone && !rxCollection.closed) {
+    if (cleanupPolicy.awaitReplicationsInSync) {
+      var replicationStates = (0, _index.getFromMapOrCreate)(_index2.REPLICATION_STATE_BY_COLLECTION, rxCollection, () => []);
+      await Promise.all(replicationStates.map(replicationState => {
+        if (!replicationState.isStopped()) {
+          return replicationState.awaitInSync();
+        }
+      }));
+    }
+    if (rxCollection.closed) {
+      return;
+    }
+    RXSTORAGE_CLEANUP_QUEUE = RXSTORAGE_CLEANUP_QUEUE.then(async () => {
+      if (rxCollection.closed) {
+        return true;
+      }
+      await rxDatabase.requestIdlePromise();
+      var allDone = [];
+      allDone.push(storageInstance.cleanup(cleanupPolicy.minimumDeletedTime));
+      var replicationStates = (0, _index.getFromMapOrCreate)(_index2.REPLICATION_STATE_BY_COLLECTION, rxCollection, () => []);
+      for (var replicationState of replicationStates) {
+        var meta = replicationState.metaInstance;
+        if (meta) {
+          allDone.push(meta.cleanup(cleanupPolicy.minimumDeletedTime));
+        }
+      }
+      var hasFalse = (await Promise.all(allDone)).find(v => !v);
+      return !hasFalse;
+    });
+    isDone = await RXSTORAGE_CLEANUP_QUEUE;
+  }
+  await (0, _hooks.runAsyncPluginHooks)('postCleanup', {
+    collectionName: rxCollection.name,
+    databaseName: rxDatabase.name
+  });
+}
+async function runCleanupAfterDelete(rxCollection, cleanupPolicy) {
+  while (!rxCollection.closed) {
+    /**
+     * In theory we should wait here until a document is deleted.
+     * But this would mean we have to search through all events ever processed.
+     * So instead we just wait for any write event and then we anyway throttle
+     * the calls with the promiseWait() below.
+     */
+    await (0, _rxjs.firstValueFrom)(rxCollection.eventBulks$).catch(() => {});
+    await rxCollection.promiseWait(cleanupPolicy.runEach);
+    if (rxCollection.closed) {
+      return;
+    }
+    await cleanupRxCollection(rxCollection, cleanupPolicy);
+  }
+}
+//# sourceMappingURL=cleanup.js.map

package/dist/cjs/plugins/cleanup/cleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.js","names":["_index","require","_index2","_cleanupHelper","_hooks","_rxjs","RXSTORAGE_CLEANUP_QUEUE","PROMISE_RESOLVE_TRUE","startCleanupForRxCollection","rxCollection","rxDatabase","database","cleanupPolicy","Object","assign","DEFAULT_CLEANUP_POLICY","initialCleanupWait","closed","cleanupRxCollection","runCleanupAfterDelete","collection","promiseWait","minimumCollectionAge","multiInstance","waitForLeadership","storageInstance","isDone","awaitReplicationsInSync","replicationStates","getFromMapOrCreate","REPLICATION_STATE_BY_COLLECTION","Promise","all","map","replicationState","isStopped","awaitInSync","then","requestIdlePromise","allDone","push","cleanup","minimumDeletedTime","meta","metaInstance","hasFalse","find","v","runAsyncPluginHooks","collectionName","name","databaseName","firstValueFrom","eventBulks$","catch","runEach"],"sources":["../../../../src/plugins/cleanup/cleanup.ts"],"sourcesContent":["import type { RxCleanupPolicy, RxCollection } from '../../types/index.d.ts';\r\nimport { PROMISE_RESOLVE_TRUE, getFromMapOrCreate } from '../../plugins/utils/index.ts';\r\nimport { REPLICATION_STATE_BY_COLLECTION } from '../replication/index.ts';\r\nimport { DEFAULT_CLEANUP_POLICY } from './cleanup-helper.ts';\r\nimport { runAsyncPluginHooks } from '../../hooks.ts';\r\nimport { filter, firstValueFrom } from 'rxjs';\r\n\r\n/**\r\n * Even on multiple databases,\r\n * the calls to RxStorage().cleanup()\r\n * must never run in parallel.\r\n * The cleanup is a background task which should\r\n * not affect the performance of other, more important tasks.\r\n */\r\nlet RXSTORAGE_CLEANUP_QUEUE: Promise<boolean> = PROMISE_RESOLVE_TRUE;\r\n\r\nexport async function startCleanupForRxCollection(\r\n    rxCollection: RxCollection\r\n) {\r\n    const rxDatabase = rxCollection.database;\r\n    const cleanupPolicy = Object.assign(\r\n        {},\r\n        DEFAULT_CLEANUP_POLICY,\r\n        rxDatabase.cleanupPolicy ? rxDatabase.cleanupPolicy : {}\r\n    );\r\n\r\n\r\n    await initialCleanupWait(rxCollection, cleanupPolicy);\r\n    if (rxCollection.closed) {\r\n        return;\r\n    }\r\n\r\n    // initially cleanup the collection\r\n    await cleanupRxCollection(rxCollection, cleanupPolicy);\r\n\r\n    /**\r\n     * Afterwards we listen to deletes\r\n     * and only re-run the cleanup after\r\n     * minimumDeletedTime is reached.\r\n     */\r\n    await runCleanupAfterDelete(rxCollection, cleanupPolicy);\r\n}\r\n\r\n\r\nexport async function initialCleanupWait(collection: RxCollection, cleanupPolicy: RxCleanupPolicy) {\r\n    /**\r\n     * Wait until minimumDatabaseInstanceAge is reached\r\n     * or collection is closed.\r\n     */\r\n    await collection.promiseWait(cleanupPolicy.minimumCollectionAge);\r\n    if (collection.closed) {\r\n        return;\r\n    }\r\n\r\n    if (collection.database.multiInstance && cleanupPolicy.waitForLeadership) {\r\n        await collection.database.waitForLeadership();\r\n    }\r\n}\r\n\r\n/**\r\n * Runs the cleanup for a single RxCollection\r\n */\r\nexport async function cleanupRxCollection(\r\n    rxCollection: RxCollection,\r\n    cleanupPolicy: RxCleanupPolicy\r\n) {\r\n    const rxDatabase = rxCollection.database;\r\n    const storageInstance = rxCollection.storageInstance;\r\n\r\n    // run cleanup() until it returns true\r\n    let isDone = false;\r\n    while (!isDone && !rxCollection.closed) {\r\n        if (cleanupPolicy.awaitReplicationsInSync) {\r\n            const replicationStates = getFromMapOrCreate(\r\n                REPLICATION_STATE_BY_COLLECTION,\r\n                rxCollection,\r\n                () => []\r\n            );\r\n            await Promise.all(\r\n                replicationStates.map(replicationState => {\r\n                    if (!replicationState.isStopped()) {\r\n                        return replicationState.awaitInSync();\r\n                    }\r\n                })\r\n            );\r\n        }\r\n        if (rxCollection.closed) {\r\n            return;\r\n        }\r\n        RXSTORAGE_CLEANUP_QUEUE = RXSTORAGE_CLEANUP_QUEUE\r\n            .then(async () => {\r\n                if (rxCollection.closed) {\r\n                    return true;\r\n                }\r\n                await rxDatabase.requestIdlePromise();\r\n                const allDone: Promise<boolean>[] = [];\r\n                allDone.push(storageInstance.cleanup(cleanupPolicy.minimumDeletedTime));\r\n                const replicationStates = getFromMapOrCreate(\r\n                    REPLICATION_STATE_BY_COLLECTION,\r\n                    rxCollection,\r\n                    () => []\r\n                );\r\n                for (const replicationState of replicationStates) {\r\n                    const meta = replicationState.metaInstance;\r\n                    if (meta) {\r\n                        allDone.push(meta.cleanup(cleanupPolicy.minimumDeletedTime));\r\n                    }\r\n                }\r\n\r\n                const hasFalse = (await Promise.all(allDone)).find(v => !v);\r\n                return !hasFalse;\r\n            });\r\n        isDone = await RXSTORAGE_CLEANUP_QUEUE;\r\n    }\r\n    await runAsyncPluginHooks('postCleanup', {\r\n        collectionName: rxCollection.name,\r\n        databaseName: rxDatabase.name\r\n    });\r\n}\r\n\r\nexport async function runCleanupAfterDelete(\r\n    rxCollection: RxCollection,\r\n    cleanupPolicy: RxCleanupPolicy\r\n) {\r\n    while (!rxCollection.closed) {\r\n        /**\r\n         * In theory we should wait here until a document is deleted.\r\n         * But this would mean we have to search through all events ever processed.\r\n         * So instead we just wait for any write event and then we anyway throttle\r\n         * the calls with the promiseWait() below.\r\n         */\r\n        await firstValueFrom(rxCollection.eventBulks$).catch(() => { });\r\n\r\n        await rxCollection.promiseWait(cleanupPolicy.runEach);\r\n        if (rxCollection.closed) {\r\n            return;\r\n        }\r\n        await cleanupRxCollection(rxCollection, cleanupPolicy);\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/cleanup/index.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  RxDBCleanupPlugin: true
+};
+exports.RxDBCleanupPlugin = void 0;
+var _cleanupHelper = require("./cleanup-helper.js");
+Object.keys(_cleanupHelper).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _cleanupHelper[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cleanupHelper[key];
+    }
+  });
+});
+var _cleanupState = require("./cleanup-state.js");
+var _cleanup = require("./cleanup.js");
+Object.keys(_cleanup).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _cleanup[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cleanup[key];
+    }
+  });
+});
+var RxDBCleanupPlugin = exports.RxDBCleanupPlugin = {
+  name: 'cleanup',
+  rxdb: true,
+  prototypes: {
+    RxCollection: proto => {
+      proto.cleanup = async function (minimumDeletedTime) {
+        var cleanupPolicy = Object.assign({}, _cleanupHelper.DEFAULT_CLEANUP_POLICY, this.database.cleanupPolicy ? this.database.cleanupPolicy : {});
+        if (typeof minimumDeletedTime !== 'undefined') {
+          cleanupPolicy.minimumDeletedTime = minimumDeletedTime;
+        }
+
+        // run cleanup() until it returns true
+        await (0, _cleanup.cleanupRxCollection)(this, cleanupPolicy);
+      };
+    }
+  },
+  hooks: {
+    createRxCollection: {
+      after: i => {
+        (0, _cleanup.startCleanupForRxCollection)(i.collection);
+      }
+    },
+    createRxState: {
+      after: i => {
+        (0, _cleanupState.startCleanupForRxState)(i.state);
+      }
+    }
+  }
+};
+//# sourceMappingURL=index.js.map

package/dist/cjs/plugins/cleanup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_cleanupHelper","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_cleanupState","_cleanup","RxDBCleanupPlugin","name","rxdb","prototypes","RxCollection","proto","cleanup","minimumDeletedTime","cleanupPolicy","assign","DEFAULT_CLEANUP_POLICY","database","cleanupRxCollection","hooks","createRxCollection","after","i","startCleanupForRxCollection","collection","createRxState","startCleanupForRxState","state"],"sources":["../../../../src/plugins/cleanup/index.ts"],"sourcesContent":["import type {\r\n    RxCollection,\r\n    RxPlugin\r\n} from '../../types/index.d.ts';\r\nimport { DEFAULT_CLEANUP_POLICY } from './cleanup-helper.ts';\r\nimport { startCleanupForRxState } from './cleanup-state.ts';\r\nimport { cleanupRxCollection, startCleanupForRxCollection } from './cleanup.ts';\r\n\r\nexport const RxDBCleanupPlugin: RxPlugin = {\r\n    name: 'cleanup',\r\n    rxdb: true,\r\n    prototypes: {\r\n        RxCollection: (proto: any) => {\r\n            proto.cleanup = async function (this: RxCollection, minimumDeletedTime?: number): Promise<void> {\r\n                const cleanupPolicy = Object.assign(\r\n                    {},\r\n                    DEFAULT_CLEANUP_POLICY,\r\n                    this.database.cleanupPolicy ? this.database.cleanupPolicy : {}\r\n                );\r\n\r\n                if (typeof minimumDeletedTime !== 'undefined') {\r\n                    cleanupPolicy.minimumDeletedTime = minimumDeletedTime;\r\n                }\r\n\r\n                // run cleanup() until it returns true\r\n                await cleanupRxCollection(this, cleanupPolicy);\r\n            };\r\n        }\r\n    },\r\n    hooks: {\r\n        createRxCollection: {\r\n            after: (i) => {\r\n                startCleanupForRxCollection(i.collection);\r\n            }\r\n        },\r\n        createRxState: {\r\n            after: (i) => {\r\n                startCleanupForRxState(i.state);\r\n            }\r\n        }\r\n    }\r\n};\r\n\r\nexport * from './cleanup.ts';\r\nexport * from './cleanup-helper.ts';\r\n"],"mappings":";;;;;;;;;AAIA,IAAAA,cAAA,GAAAC,OAAA;AAwCAC,MAAA,CAAAC,IAAA,CAAAH,cAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,cAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,cAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AAvCA,IAAAS,aAAA,GAAAb,OAAA;AACA,IAAAc,QAAA,GAAAd,OAAA;AAqCAC,MAAA,CAAAC,IAAA,CAAAY,QAAA,EAAAX,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAU,QAAA,CAAAV,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,QAAA,CAAAV,GAAA;IAAA;EAAA;AAAA;AAnCO,IAAMW,iBAA2B,GAAAN,OAAA,CAAAM,iBAAA,GAAG;EACvCC,IAAI,EAAE,SAAS;EACfC,IAAI,EAAE,IAAI;EACVC,UAAU,EAAE;IACRC,YAAY,EAAGC,KAAU,IAAK;MAC1BA,KAAK,CAACC,OAAO,GAAG,gBAAoCC,kBAA2B,EAAiB;QAC5F,IAAMC,aAAa,GAAGtB,MAAM,CAACuB,MAAM,CAC/B,CAAC,CAAC,EACFC,qCAAsB,EACtB,IAAI,CAACC,QAAQ,CAACH,aAAa,GAAG,IAAI,CAACG,QAAQ,CAACH,aAAa,GAAG,CAAC,CACjE,CAAC;QAED,IAAI,OAAOD,kBAAkB,KAAK,WAAW,EAAE;UAC3CC,aAAa,CAACD,kBAAkB,GAAGA,kBAAkB;QACzD;;QAEA;QACA,MAAM,IAAAK,4BAAmB,EAAC,IAAI,EAAEJ,aAAa,CAAC;MAClD,CAAC;IACL;EACJ,CAAC;EACDK,KAAK,EAAE;IACHC,kBAAkB,EAAE;MAChBC,KAAK,EAAGC,CAAC,IAAK;QACV,IAAAC,oCAA2B,EAACD,CAAC,CAACE,UAAU,CAAC;MAC7C;IACJ,CAAC;IACDC,aAAa,EAAE;MACXJ,KAAK,EAAGC,CAAC,IAAK;QACV,IAAAI,oCAAsB,EAACJ,CAAC,CAACK,KAAK,CAAC;MACnC;IACJ;EACJ;AACJ,CAAC","ignoreList":[]}