@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugins/attachments/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["map","blobToBase64String","blobToString","createBlobFromBase64","flatClone","PROMISE_RESOLVE_VOID","assignMethodsToAttachment","ensureSchemaSupportsAttachments","RxAttachment","doc","id","type","length","digest","_proto","prototype","remove","collection","incrementalWriteQueue","addWrite","_data","docWriteData","_attachments","then","getData","blob","storageInstance","getAttachmentData","primary","slice","size","getStringData","data","asString","getDataBase64","fromStorageInstanceResult","attachmentData","rxDocument","_putAttachmentsImpl","attachments","prepared","Promise","all","att","database","hashFunction","writeResult","newDocument","_docCache","getCachedRxDocument","putAttachment","results","putAttachmentBase64","putAttachments","getAttachment","docData","attachment","allAttachments","Object","keys","preMigrateDocument","newAttachments","attachmentId","docPrimary","oldCollection","schema","primaryPath","rawAttachmentBlob","postMigrateDocument","_action","RxDBAttachmentsPlugin","name","rxdb","prototypes","RxDocument","proto","defineProperty","get","allAttachments$","$","pipe","entries","toJSON","overwritable","hooks","after"],"sources":["../../../../src/plugins/attachments/index.ts"],"sourcesContent":["import {\r\n    map\r\n} from 'rxjs';\r\n\r\nimport {\r\n    blobToBase64String,\r\n    blobToString,\r\n    createBlobFromBase64,\r\n    flatClone,\r\n    PROMISE_RESOLVE_VOID\r\n} from '../../plugins/utils/index.ts';\r\nimport type {\r\n    RxDocument,\r\n    RxPlugin,\r\n    RxDocumentWriteData,\r\n    RxAttachmentData,\r\n    RxDocumentData,\r\n    RxAttachmentCreator,\r\n    RxAttachmentWriteData,\r\n    RxCollection,\r\n    RxAttachmentCreatorBase64\r\n} from '../../types/index.d.ts';\r\nimport {\r\n    assignMethodsToAttachment,\r\n    ensureSchemaSupportsAttachments\r\n} from './attachments-utils.ts';\r\n\r\n\r\n\r\n/**\r\n * an RxAttachment is basically just the attachment-stub\r\n * wrapped so that you can access the attachment-data\r\n */\r\nexport class RxAttachment {\r\n    public doc: RxDocument;\r\n    public id: string;\r\n    public type: string;\r\n    public length: number;\r\n    public digest: string;\r\n    constructor({\r\n        doc,\r\n        id,\r\n        type,\r\n        length,\r\n        digest\r\n    }: any) {\r\n        this.doc = doc;\r\n        this.id = id;\r\n        this.type = type;\r\n        this.length = length;\r\n        this.digest = digest;\r\n\r\n        assignMethodsToAttachment(this);\r\n    }\r\n\r\n    remove(): Promise<void> {\r\n        return this.doc.collection.incrementalWriteQueue.addWrite(\r\n            this.doc._data,\r\n            docWriteData => {\r\n                delete docWriteData._attachments[this.id];\r\n                return docWriteData;\r\n            }\r\n        ).then(() => { });\r\n    }\r\n\r\n    /**\r\n     * returns the data for the attachment\r\n     */\r\n    async getData(): Promise<Blob> {\r\n        const blob = await this.doc.collection.storageInstance.getAttachmentData(\r\n            this.doc.primary,\r\n            this.id,\r\n            this.digest\r\n        );\r\n        // Some storage layers return blobs without the original MIME type.\r\n        // Ensure the returned Blob has the attachment's MIME type.\r\n        if (blob && blob.type !== this.type) {\r\n            return blob.slice(0, blob.size, this.type);\r\n        }\r\n        return blob;\r\n    }\r\n\r\n    async getStringData(): Promise<string> {\r\n        const data = await this.getData();\r\n        const asString = await blobToString(data);\r\n        return asString;\r\n    }\r\n\r\n    async getDataBase64(): Promise<string> {\r\n        const blob = await this.getData();\r\n        return blobToBase64String(blob);\r\n    }\r\n}\r\n\r\nexport function fromStorageInstanceResult<RxDocType>(\r\n    id: string,\r\n    attachmentData: RxAttachmentData,\r\n    rxDocument: RxDocument<RxDocType>\r\n) {\r\n    return new RxAttachment({\r\n        doc: rxDocument,\r\n        id,\r\n        type: attachmentData.type,\r\n        length: attachmentData.length,\r\n        digest: attachmentData.digest\r\n    });\r\n}\r\n\r\nasync function _putAttachmentsImpl<RxDocType>(\r\n    doc: RxDocument<RxDocType>,\r\n    attachments: RxAttachmentCreator[]\r\n): Promise<RxAttachment[]> {\r\n    ensureSchemaSupportsAttachments(doc);\r\n\r\n    if (attachments.length === 0) {\r\n        return [];\r\n    }\r\n\r\n    const prepared = await Promise.all(\r\n        attachments.map(async (att) => ({\r\n            id: att.id,\r\n            type: att.type,\r\n            data: att.data,\r\n            digest: await doc.collection.database.hashFunction(att.data)\r\n        }))\r\n    );\r\n\r\n    const writeResult = await doc.collection.incrementalWriteQueue.addWrite(\r\n        doc._data,\r\n        (docWriteData: RxDocumentWriteData<RxDocType>) => {\r\n            docWriteData = flatClone(docWriteData);\r\n            docWriteData._attachments = flatClone(docWriteData._attachments);\r\n            for (const att of prepared) {\r\n                docWriteData._attachments[att.id] = {\r\n                    length: att.data.size,\r\n                    type: att.type,\r\n                    data: att.data,\r\n                    digest: att.digest\r\n                };\r\n            }\r\n            return docWriteData;\r\n        }\r\n    );\r\n\r\n    const newDocument = doc.collection._docCache.getCachedRxDocument(writeResult);\r\n    return prepared.map((att) => fromStorageInstanceResult(\r\n        att.id,\r\n        writeResult._attachments[att.id],\r\n        newDocument\r\n    ));\r\n}\r\n\r\nexport async function putAttachment<RxDocType>(\r\n    this: RxDocument<RxDocType>,\r\n    attachmentData: RxAttachmentCreator\r\n): Promise<RxAttachment> {\r\n    const results = await _putAttachmentsImpl(this, [attachmentData]);\r\n    return results[0];\r\n}\r\n\r\nexport async function putAttachmentBase64<RxDocType>(\r\n    this: RxDocument<RxDocType>,\r\n    attachmentData: RxAttachmentCreatorBase64\r\n) {\r\n    ensureSchemaSupportsAttachments(this);\r\n    const blob = await createBlobFromBase64(attachmentData.data, attachmentData.type);\r\n    return this.putAttachment({\r\n        id: attachmentData.id,\r\n        type: attachmentData.type,\r\n        data: blob\r\n    });\r\n}\r\n\r\n/**\r\n * Write multiple attachments in a single atomic operation.\r\n */\r\nexport function putAttachments<RxDocType>(\r\n    this: RxDocument<RxDocType>,\r\n    attachments: RxAttachmentCreator[]\r\n): Promise<RxAttachment[]> {\r\n    return _putAttachmentsImpl(this, attachments);\r\n}\r\n\r\n/**\r\n * get an attachment of the document by its id\r\n */\r\nexport function getAttachment(\r\n    this: RxDocument,\r\n    id: string\r\n): RxAttachment | null {\r\n    ensureSchemaSupportsAttachments(this);\r\n    const docData: any = this._data;\r\n    if (!docData._attachments || !docData._attachments[id])\r\n        return null;\r\n\r\n    const attachmentData = docData._attachments[id];\r\n    const attachment = fromStorageInstanceResult(\r\n        id,\r\n        attachmentData,\r\n        this\r\n    );\r\n    return attachment;\r\n}\r\n\r\n/**\r\n * returns all attachments of the document\r\n */\r\nexport function allAttachments(\r\n    this: RxDocument\r\n): RxAttachment[] {\r\n    ensureSchemaSupportsAttachments(this);\r\n    const docData: any = this._data;\r\n\r\n    // if there are no attachments, the field is missing\r\n    if (!docData._attachments) {\r\n        return [];\r\n    }\r\n    return Object.keys(docData._attachments)\r\n        .map(id => {\r\n            return fromStorageInstanceResult(\r\n                id,\r\n                docData._attachments[id],\r\n                this\r\n            );\r\n        });\r\n}\r\n\r\nexport async function preMigrateDocument<RxDocType>(\r\n    data: {\r\n        docData: RxDocumentData<RxDocType>;\r\n        oldCollection: RxCollection<RxDocType>;\r\n    }\r\n): Promise<void> {\r\n    const attachments = data.docData._attachments;\r\n    if (attachments) {\r\n        const newAttachments: { [attachmentId: string]: RxAttachmentWriteData; } = {};\r\n        await Promise.all(\r\n            Object.keys(attachments).map(async (attachmentId) => {\r\n                const attachment: RxAttachmentData = attachments[attachmentId];\r\n                const docPrimary: string = (data.docData as any)[data.oldCollection.schema.primaryPath];\r\n                const rawAttachmentBlob = await data.oldCollection.storageInstance.getAttachmentData(\r\n                    docPrimary,\r\n                    attachmentId,\r\n                    attachment.digest\r\n                );\r\n                const digest = await data.oldCollection.database.hashFunction(rawAttachmentBlob);\r\n                newAttachments[attachmentId] = {\r\n                    length: rawAttachmentBlob.size,\r\n                    type: attachment.type,\r\n                    data: rawAttachmentBlob,\r\n                    digest\r\n                };\r\n            })\r\n        );\r\n\r\n        /**\r\n         * Hooks mutate the input\r\n         * instead of returning stuff\r\n         */\r\n        (data.docData as RxDocumentWriteData<RxDocType>)._attachments = newAttachments;\r\n    }\r\n}\r\n\r\nexport function postMigrateDocument(_action: any): Promise<void> {\r\n    /**\r\n     * No longer needed because\r\n     * we store the attachments data buffers directly in the document.\r\n     */\r\n    return PROMISE_RESOLVE_VOID;\r\n}\r\n\r\nexport const RxDBAttachmentsPlugin: RxPlugin = {\r\n    name: 'attachments',\r\n    rxdb: true,\r\n    prototypes: {\r\n        RxDocument: (proto: any) => {\r\n            proto.putAttachment = putAttachment;\r\n            proto.putAttachments = putAttachments;\r\n            proto.putAttachmentBase64 = putAttachmentBase64;\r\n            proto.getAttachment = getAttachment;\r\n            proto.allAttachments = allAttachments;\r\n            Object.defineProperty(proto, 'allAttachments$', {\r\n                get: function allAttachments$(this: RxDocument) {\r\n                    return this.$\r\n                        .pipe(\r\n                            map((rxDocument: RxDocument) => Object.entries(\r\n                                rxDocument.toJSON(true)._attachments\r\n                            )),\r\n                            map((entries: [string, any][]) => {\r\n                                return entries\r\n                                    .map(([id, attachmentData]: [string, any]) => {\r\n                                        return fromStorageInstanceResult(\r\n                                            id,\r\n                                            attachmentData,\r\n                                            this\r\n                                        );\r\n                                    });\r\n                            })\r\n                        );\r\n                }\r\n            });\r\n        }\r\n    },\r\n    overwritable: {},\r\n    hooks: {\r\n        preMigrateDocument: {\r\n            after: preMigrateDocument\r\n        },\r\n        postMigrateDocument: {\r\n            after: postMigrateDocument\r\n        }\r\n    }\r\n};\r\n\r\n\r\nexport * from './attachments-utils.ts';\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/attachments-compression/index.js

@@ -0,0 +1,134 @@
+import { wrapRxStorageInstance } from "../../plugin-helpers.js";
+import { ensureNotFalsy, flatClone } from "../utils/index.js";
+
+/**
+ * Default MIME type patterns that benefit from compression.
+ * Types like images (JPEG, PNG, WebP), videos, and audio
+ * are already compressed and should NOT be re-compressed.
+ */
+export var DEFAULT_COMPRESSIBLE_TYPES = ['text/*', 'application/json', 'application/xml', 'application/xhtml+xml', 'application/javascript', 'application/x-javascript', 'application/ecmascript', 'application/rss+xml', 'application/atom+xml', 'application/soap+xml', 'application/wasm', 'application/x-yaml', 'application/sql', 'application/graphql', 'application/ld+json', 'application/manifest+json', 'application/schema+json', 'application/vnd.api+json', 'image/svg+xml', 'image/bmp', 'font/ttf', 'font/otf', 'application/x-font-ttf', 'application/x-font-otf', 'application/pdf', 'application/rtf', 'application/x-sh', 'application/x-csh', 'application/x-httpd-php'];
+
+/**
+ * Checks if a given MIME type should be compressed,
+ * based on a list of type patterns. Supports wildcard suffix matching
+ * (e.g., 'text/*' matches 'text/plain', 'text/html', etc.).
+ *
+ * Deterministic: same type + same pattern list = same answer.
+ * No byte-level inspection needed.
+ */
+export function isCompressibleType(mimeType, compressibleTypes) {
+  var lower = mimeType.toLowerCase();
+  for (var pattern of compressibleTypes) {
+    var lowerPattern = pattern.toLowerCase();
+    if (lowerPattern.endsWith('/*')) {
+      // 'text/*' -> 'text/', so startsWith matches all subtypes
+      var prefix = lowerPattern.slice(0, -1);
+      if (lower.startsWith(prefix)) {
+        return true;
+      }
+    } else if (lower === lowerPattern) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Compress a Blob using streaming CompressionStream API.
+ * @link https://github.com/WICG/compression/blob/main/explainer.md
+ */
+export async function compressBlob(mode, blob) {
+  var stream = blob.stream().pipeThrough(new CompressionStream(mode));
+  return new Response(stream).blob();
+}
+
+/**
+ * Decompress a Blob using streaming DecompressionStream API.
+ */
+export async function decompressBlob(mode, blob) {
+  var stream = blob.stream().pipeThrough(new DecompressionStream(mode));
+  return new Response(stream).blob();
+}
+
+/**
+ * Digest prefix that marks an attachment as having been
+ * stored with compression. Used by getAttachmentData to
+ * determine whether decompression is needed, without
+ * having to fetch the full document to inspect the MIME type.
+ */
+var COMPRESSED_DIGEST_PREFIX = 'c-';
+
+/**
+ * A RxStorage wrapper that compresses attachment data on writes
+ * and decompresses the data on reads.
+ *
+ * Only compresses attachments whose MIME type is in the compressible list.
+ * Already-compressed formats (JPEG, PNG, MP4, etc.) are passed through as-is.
+ *
+ * This is using the CompressionStream API,
+ * @link https://caniuse.com/?search=compressionstream
+ */
+export function wrappedAttachmentsCompressionStorage(args) {
+  return Object.assign({}, args.storage, {
+    async createStorageInstance(params) {
+      if (!params.schema.attachments || !params.schema.attachments.compression) {
+        return args.storage.createStorageInstance(params);
+      }
+      var mode = params.schema.attachments.compression;
+      var compressibleTypes = params.schema.attachments.compressibleTypes || DEFAULT_COMPRESSIBLE_TYPES;
+      async function modifyToStorage(docData) {
+        await Promise.all(Object.values(docData._attachments).map(async attachment => {
+          if (!attachment.data) {
+            return;
+          }
+          var attachmentWriteData = attachment;
+          if (isCompressibleType(attachmentWriteData.type, compressibleTypes)) {
+            attachmentWriteData.data = await compressBlob(mode, attachmentWriteData.data);
+            /**
+             * Prefix the digest to signal that this attachment is compressed.
+             * This is intentional: the stored digest is 'c-' + hash(originalData),
+             * NOT hash(compressedData). RxDB does not use digests for integrity
+             * verification — only for change detection (comparing before vs after).
+             * Change detection remains correct because both sides of any comparison
+             * consistently carry the 'c-' prefix for compressed attachments.
+             * All write paths flow through this modifyToStorage wrapper so the
+             * prefix is always applied, regardless of which API was used to write.
+             */
+            if (!attachmentWriteData.digest.startsWith(COMPRESSED_DIGEST_PREFIX)) {
+              attachmentWriteData.digest = COMPRESSED_DIGEST_PREFIX + attachmentWriteData.digest;
+            }
+          }
+        }));
+        return docData;
+      }
+
+      /**
+       * Because this wrapper resolves the attachments.compression,
+       * we have to remove it before sending it to the underlying RxStorage.
+       * which allows underlying storages to detect wrong configurations
+       * like when compression is set to false but no attachment-compression module is used.
+       */
+      var childSchema = flatClone(params.schema);
+      childSchema.attachments = flatClone(childSchema.attachments);
+      delete ensureNotFalsy(childSchema.attachments).compression;
+      var instance = await args.storage.createStorageInstance(Object.assign({}, params, {
+        schema: childSchema
+      }));
+      var wrappedInstance = wrapRxStorageInstance(params.schema, instance, modifyToStorage, d => d);
+
+      /**
+       * Override getAttachmentData to decompress based on the
+       * digest prefix rather than looking up the document's MIME type.
+       */
+      wrappedInstance.getAttachmentData = async (documentId, attachmentId, digest) => {
+        var data = await instance.getAttachmentData(documentId, attachmentId, digest);
+        if (digest.startsWith(COMPRESSED_DIGEST_PREFIX)) {
+          return decompressBlob(mode, data);
+        }
+        return data;
+      };
+      return wrappedInstance;
+    }
+  });
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/plugins/attachments-compression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["wrapRxStorageInstance","ensureNotFalsy","flatClone","DEFAULT_COMPRESSIBLE_TYPES","isCompressibleType","mimeType","compressibleTypes","lower","toLowerCase","pattern","lowerPattern","endsWith","prefix","slice","startsWith","compressBlob","mode","blob","stream","pipeThrough","CompressionStream","Response","decompressBlob","DecompressionStream","COMPRESSED_DIGEST_PREFIX","wrappedAttachmentsCompressionStorage","args","Object","assign","storage","createStorageInstance","params","schema","attachments","compression","modifyToStorage","docData","Promise","all","values","_attachments","map","attachment","data","attachmentWriteData","type","digest","childSchema","instance","wrappedInstance","d","getAttachmentData","documentId","attachmentId"],"sources":["../../../../src/plugins/attachments-compression/index.ts"],"sourcesContent":["import { wrapRxStorageInstance } from '../../plugin-helpers.ts';\r\nimport type {\r\n    RxStorage,\r\n    RxStorageInstanceCreationParams,\r\n    RxDocumentWriteData,\r\n    CompressionMode,\r\n    RxAttachmentWriteData\r\n} from '../../types/index.d.ts';\r\n\r\nimport {\r\n    ensureNotFalsy,\r\n    flatClone\r\n} from '../utils/index.ts';\r\n\r\n\r\n/**\r\n * Default MIME type patterns that benefit from compression.\r\n * Types like images (JPEG, PNG, WebP), videos, and audio\r\n * are already compressed and should NOT be re-compressed.\r\n */\r\nexport const DEFAULT_COMPRESSIBLE_TYPES: string[] = [\r\n    'text/*',\r\n    'application/json',\r\n    'application/xml',\r\n    'application/xhtml+xml',\r\n    'application/javascript',\r\n    'application/x-javascript',\r\n    'application/ecmascript',\r\n    'application/rss+xml',\r\n    'application/atom+xml',\r\n    'application/soap+xml',\r\n    'application/wasm',\r\n    'application/x-yaml',\r\n    'application/sql',\r\n    'application/graphql',\r\n    'application/ld+json',\r\n    'application/manifest+json',\r\n    'application/schema+json',\r\n    'application/vnd.api+json',\r\n    'image/svg+xml',\r\n    'image/bmp',\r\n    'font/ttf',\r\n    'font/otf',\r\n    'application/x-font-ttf',\r\n    'application/x-font-otf',\r\n    'application/pdf',\r\n    'application/rtf',\r\n    'application/x-sh',\r\n    'application/x-csh',\r\n    'application/x-httpd-php'\r\n];\r\n\r\n/**\r\n * Checks if a given MIME type should be compressed,\r\n * based on a list of type patterns. Supports wildcard suffix matching\r\n * (e.g., 'text/*' matches 'text/plain', 'text/html', etc.).\r\n *\r\n * Deterministic: same type + same pattern list = same answer.\r\n * No byte-level inspection needed.\r\n */\r\nexport function isCompressibleType(\r\n    mimeType: string,\r\n    compressibleTypes: string[]\r\n): boolean {\r\n    const lower = mimeType.toLowerCase();\r\n    for (const pattern of compressibleTypes) {\r\n        const lowerPattern = pattern.toLowerCase();\r\n        if (lowerPattern.endsWith('/*')) {\r\n            // 'text/*' -> 'text/', so startsWith matches all subtypes\r\n            const prefix = lowerPattern.slice(0, -1);\r\n            if (lower.startsWith(prefix)) {\r\n                return true;\r\n            }\r\n        } else if (lower === lowerPattern) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\n\r\n\r\n/**\r\n * Compress a Blob using streaming CompressionStream API.\r\n * @link https://github.com/WICG/compression/blob/main/explainer.md\r\n */\r\nexport async function compressBlob(\r\n    mode: CompressionMode,\r\n    blob: Blob\r\n): Promise<Blob> {\r\n    const stream = blob.stream().pipeThrough(new CompressionStream(mode));\r\n    return new Response(stream).blob();\r\n}\r\n\r\n/**\r\n * Decompress a Blob using streaming DecompressionStream API.\r\n */\r\nexport async function decompressBlob(\r\n    mode: CompressionMode,\r\n    blob: Blob\r\n): Promise<Blob> {\r\n    const stream = blob.stream().pipeThrough(new DecompressionStream(mode));\r\n    return new Response(stream).blob();\r\n}\r\n\r\n\r\n/**\r\n * Digest prefix that marks an attachment as having been\r\n * stored with compression. Used by getAttachmentData to\r\n * determine whether decompression is needed, without\r\n * having to fetch the full document to inspect the MIME type.\r\n */\r\nconst COMPRESSED_DIGEST_PREFIX = 'c-';\r\n\r\n/**\r\n * A RxStorage wrapper that compresses attachment data on writes\r\n * and decompresses the data on reads.\r\n *\r\n * Only compresses attachments whose MIME type is in the compressible list.\r\n * Already-compressed formats (JPEG, PNG, MP4, etc.) are passed through as-is.\r\n *\r\n * This is using the CompressionStream API,\r\n * @link https://caniuse.com/?search=compressionstream\r\n */\r\nexport function wrappedAttachmentsCompressionStorage<Internals, InstanceCreationOptions>(\r\n    args: {\r\n        storage: RxStorage<Internals, InstanceCreationOptions>;\r\n    }\r\n): RxStorage<Internals, InstanceCreationOptions> {\r\n    return Object.assign(\r\n        {},\r\n        args.storage,\r\n        {\r\n            async createStorageInstance<RxDocType>(\r\n                params: RxStorageInstanceCreationParams<RxDocType, any>\r\n            ) {\r\n                if (\r\n                    !params.schema.attachments ||\r\n                    !params.schema.attachments.compression\r\n                ) {\r\n                    return args.storage.createStorageInstance(params);\r\n                }\r\n\r\n                const mode = params.schema.attachments.compression;\r\n                const compressibleTypes = params.schema.attachments.compressibleTypes || DEFAULT_COMPRESSIBLE_TYPES;\r\n\r\n                async function modifyToStorage(docData: RxDocumentWriteData<RxDocType>) {\r\n                    await Promise.all(\r\n                        Object.values(docData._attachments).map(async (attachment) => {\r\n                            if (!(attachment as RxAttachmentWriteData).data) {\r\n                                return;\r\n                            }\r\n                            const attachmentWriteData = attachment as RxAttachmentWriteData;\r\n                            if (isCompressibleType(attachmentWriteData.type, compressibleTypes)) {\r\n                                attachmentWriteData.data = await compressBlob(mode, attachmentWriteData.data);\r\n                                /**\r\n                                 * Prefix the digest to signal that this attachment is compressed.\r\n                                 * This is intentional: the stored digest is 'c-' + hash(originalData),\r\n                                 * NOT hash(compressedData). RxDB does not use digests for integrity\r\n                                 * verification — only for change detection (comparing before vs after).\r\n                                 * Change detection remains correct because both sides of any comparison\r\n                                 * consistently carry the 'c-' prefix for compressed attachments.\r\n                                 * All write paths flow through this modifyToStorage wrapper so the\r\n                                 * prefix is always applied, regardless of which API was used to write.\r\n                                 */\r\n                                if (!attachmentWriteData.digest.startsWith(COMPRESSED_DIGEST_PREFIX)) {\r\n                                    attachmentWriteData.digest = COMPRESSED_DIGEST_PREFIX + attachmentWriteData.digest;\r\n                                }\r\n                            }\r\n                        })\r\n                    );\r\n                    return docData;\r\n                }\r\n\r\n                /**\r\n                 * Because this wrapper resolves the attachments.compression,\r\n                 * we have to remove it before sending it to the underlying RxStorage.\r\n                 * which allows underlying storages to detect wrong configurations\r\n                 * like when compression is set to false but no attachment-compression module is used.\r\n                 */\r\n                const childSchema = flatClone(params.schema);\r\n                childSchema.attachments = flatClone(childSchema.attachments);\r\n                delete ensureNotFalsy(childSchema.attachments).compression;\r\n\r\n                const instance = await args.storage.createStorageInstance(\r\n                    Object.assign(\r\n                        {},\r\n                        params,\r\n                        {\r\n                            schema: childSchema\r\n                        }\r\n                    )\r\n                );\r\n\r\n                const wrappedInstance = wrapRxStorageInstance(\r\n                    params.schema,\r\n                    instance,\r\n                    modifyToStorage,\r\n                    d => d\r\n                );\r\n\r\n                /**\r\n                 * Override getAttachmentData to decompress based on the\r\n                 * digest prefix rather than looking up the document's MIME type.\r\n                 */\r\n                wrappedInstance.getAttachmentData = async (\r\n                    documentId: string,\r\n                    attachmentId: string,\r\n                    digest: string\r\n                ) => {\r\n                    const data = await instance.getAttachmentData(documentId, attachmentId, digest);\r\n                    if (digest.startsWith(COMPRESSED_DIGEST_PREFIX)) {\r\n                        return decompressBlob(mode, data);\r\n                    }\r\n                    return data;\r\n                };\r\n\r\n                return wrappedInstance;\r\n            }\r\n        }\r\n    );\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/backup/file-util.js

@@ -0,0 +1,87 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { blobToString, now } from "../../plugins/utils/index.js";
+
+/**
+ * ensure that the given folder exists
+ */
+export function ensureFolderExists(folderPath) {
+  if (!fs.existsSync(folderPath)) {
+    fs.mkdirSync(folderPath, {
+      recursive: true
+    });
+  }
+}
+
+/**
+ * deletes and recreates the folder
+ */
+export function clearFolder(folderPath) {
+  deleteFolder(folderPath);
+  ensureFolderExists(folderPath);
+}
+export function deleteFolder(folderPath) {
+  // only remove if exists to not raise warning
+  if (fs.existsSync(folderPath)) {
+    fs.rmdirSync(folderPath, {
+      recursive: true
+    });
+  }
+}
+export function prepareFolders(database, options) {
+  ensureFolderExists(options.directory);
+  var metaLoc = metaFileLocation(options);
+  if (!fs.existsSync(metaLoc)) {
+    var currentTime = now();
+    var metaData = {
+      createdAt: currentTime,
+      updatedAt: currentTime,
+      collectionStates: {}
+    };
+    fs.writeFileSync(metaLoc, JSON.stringify(metaData), 'utf-8');
+  }
+  Object.keys(database.collections).forEach(collectionName => {
+    ensureFolderExists(path.join(options.directory, collectionName));
+  });
+}
+export async function writeToFile(location, data) {
+  if (typeof data !== 'string') {
+    data = await blobToString(data);
+  }
+  return new Promise(function (res, rej) {
+    fs.writeFile(location, data, 'utf-8', err => {
+      if (err) {
+        rej(err);
+      } else {
+        res();
+      }
+    });
+  });
+}
+export function writeJsonToFile(location, data) {
+  return writeToFile(location, JSON.stringify(data));
+}
+export function metaFileLocation(options) {
+  return path.join(options.directory, 'backup_meta.json');
+}
+export function getMeta(options) {
+  var loc = metaFileLocation(options);
+  return new Promise((res, rej) => {
+    fs.readFile(loc, 'utf-8', (err, data) => {
+      if (err) {
+        rej(err);
+      } else {
+        var metaContent = JSON.parse(data);
+        res(metaContent);
+      }
+    });
+  });
+}
+export function setMeta(options, meta) {
+  var loc = metaFileLocation(options);
+  return writeJsonToFile(loc, meta);
+}
+export function documentFolder(options, docId) {
+  return path.join(options.directory, docId);
+}
+//# sourceMappingURL=file-util.js.map

package/dist/esm/plugins/backup/file-util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-util.js","names":["fs","path","blobToString","now","ensureFolderExists","folderPath","existsSync","mkdirSync","recursive","clearFolder","deleteFolder","rmdirSync","prepareFolders","database","options","directory","metaLoc","metaFileLocation","currentTime","metaData","createdAt","updatedAt","collectionStates","writeFileSync","JSON","stringify","Object","keys","collections","forEach","collectionName","join","writeToFile","location","data","Promise","res","rej","writeFile","err","writeJsonToFile","getMeta","loc","readFile","metaContent","parse","setMeta","meta","documentFolder","docId"],"sources":["../../../../src/plugins/backup/file-util.ts"],"sourcesContent":["import * as fs from 'node:fs';\r\nimport * as path from 'node:path';\r\nimport type {\r\n    BackupMetaFileContent,\r\n    BackupOptions,\r\n    RxDatabase\r\n} from '../../types/index.d.ts';\r\nimport { blobToString, now } from '../../plugins/utils/index.ts';\r\n\r\n/**\r\n * ensure that the given folder exists\r\n */\r\nexport function ensureFolderExists(folderPath: string): void {\r\n    if (!fs.existsSync(folderPath)) {\r\n        fs.mkdirSync(folderPath, { recursive: true });\r\n    }\r\n}\r\n\r\n/**\r\n * deletes and recreates the folder\r\n */\r\nexport function clearFolder(folderPath: string): void {\r\n    deleteFolder(folderPath);\r\n    ensureFolderExists(folderPath);\r\n}\r\n\r\nexport function deleteFolder(folderPath: string): void {\r\n    // only remove if exists to not raise warning\r\n    if (fs.existsSync(folderPath)) {\r\n        fs.rmdirSync(folderPath, { recursive: true });\r\n    }\r\n}\r\n\r\nexport function prepareFolders(\r\n    database: RxDatabase,\r\n    options: BackupOptions\r\n) {\r\n    ensureFolderExists(options.directory);\r\n\r\n    const metaLoc = metaFileLocation(options);\r\n\r\n    if (!fs.existsSync(metaLoc)) {\r\n        const currentTime = now();\r\n        const metaData: BackupMetaFileContent = {\r\n            createdAt: currentTime,\r\n            updatedAt: currentTime,\r\n            collectionStates: {}\r\n        };\r\n        fs.writeFileSync(metaLoc, JSON.stringify(metaData), 'utf-8');\r\n    }\r\n\r\n    Object.keys(database.collections).forEach(collectionName => {\r\n        ensureFolderExists(\r\n            path.join(\r\n                options.directory,\r\n                collectionName\r\n            )\r\n        );\r\n    });\r\n}\r\n\r\nexport async function writeToFile(\r\n    location: string,\r\n    data: string | Blob\r\n): Promise<void> {\r\n    if (typeof data !== 'string') {\r\n        data = await blobToString(data);\r\n    }\r\n    return new Promise(function (res, rej) {\r\n        fs.writeFile(\r\n            location,\r\n            data as string,\r\n            'utf-8',\r\n            (err: Error | null) => {\r\n                if (err) {\r\n                    rej(err);\r\n                } else {\r\n                    res();\r\n                }\r\n            }\r\n        );\r\n    });\r\n}\r\n\r\nexport function writeJsonToFile(\r\n    location: string,\r\n    data: any\r\n): Promise<void> {\r\n    return writeToFile(\r\n        location,\r\n        JSON.stringify(data)\r\n    );\r\n}\r\n\r\nexport function metaFileLocation(options: BackupOptions): string {\r\n    return path.join(\r\n        options.directory,\r\n        'backup_meta.json'\r\n    );\r\n}\r\n\r\nexport function getMeta(options: BackupOptions): Promise<BackupMetaFileContent> {\r\n    const loc = metaFileLocation(options);\r\n    return new Promise((res, rej) => {\r\n        fs.readFile(loc, 'utf-8', (err: Error | null, data: string) => {\r\n            if (err) {\r\n                rej(err);\r\n            } else {\r\n                const metaContent = JSON.parse(data);\r\n                res(metaContent);\r\n            }\r\n        });\r\n    });\r\n}\r\n\r\nexport function setMeta(\r\n    options: BackupOptions,\r\n    meta: BackupMetaFileContent\r\n): Promise<void> {\r\n    const loc = metaFileLocation(options);\r\n    return writeJsonToFile(loc, meta);\r\n}\r\n\r\nexport function documentFolder(\r\n    options: BackupOptions,\r\n    docId: string\r\n): string {\r\n    return path.join(\r\n        options.directory,\r\n        docId\r\n    );\r\n}\r\n"],"mappings":"AAAA,OAAO,KAAKA,EAAE,MAAM,SAAS;AAC7B,OAAO,KAAKC,IAAI,MAAM,WAAW;AAMjC,SAASC,YAAY,EAAEC,GAAG,QAAQ,8BAA8B;;AAEhE;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAACC,UAAkB,EAAQ;EACzD,IAAI,CAACL,EAAE,CAACM,UAAU,CAACD,UAAU,CAAC,EAAE;IAC5BL,EAAE,CAACO,SAAS,CAACF,UAAU,EAAE;MAAEG,SAAS,EAAE;IAAK,CAAC,CAAC;EACjD;AACJ;;AAEA;AACA;AACA;AACA,OAAO,SAASC,WAAWA,CAACJ,UAAkB,EAAQ;EAClDK,YAAY,CAACL,UAAU,CAAC;EACxBD,kBAAkB,CAACC,UAAU,CAAC;AAClC;AAEA,OAAO,SAASK,YAAYA,CAACL,UAAkB,EAAQ;EACnD;EACA,IAAIL,EAAE,CAACM,UAAU,CAACD,UAAU,CAAC,EAAE;IAC3BL,EAAE,CAACW,SAAS,CAACN,UAAU,EAAE;MAAEG,SAAS,EAAE;IAAK,CAAC,CAAC;EACjD;AACJ;AAEA,OAAO,SAASI,cAAcA,CAC1BC,QAAoB,EACpBC,OAAsB,EACxB;EACEV,kBAAkB,CAACU,OAAO,CAACC,SAAS,CAAC;EAErC,IAAMC,OAAO,GAAGC,gBAAgB,CAACH,OAAO,CAAC;EAEzC,IAAI,CAACd,EAAE,CAACM,UAAU,CAACU,OAAO,CAAC,EAAE;IACzB,IAAME,WAAW,GAAGf,GAAG,CAAC,CAAC;IACzB,IAAMgB,QAA+B,GAAG;MACpCC,SAAS,EAAEF,WAAW;MACtBG,SAAS,EAAEH,WAAW;MACtBI,gBAAgB,EAAE,CAAC;IACvB,CAAC;IACDtB,EAAE,CAACuB,aAAa,CAACP,OAAO,EAAEQ,IAAI,CAACC,SAAS,CAACN,QAAQ,CAAC,EAAE,OAAO,CAAC;EAChE;EAEAO,MAAM,CAACC,IAAI,CAACd,QAAQ,CAACe,WAAW,CAAC,CAACC,OAAO,CAACC,cAAc,IAAI;IACxD1B,kBAAkB,CACdH,IAAI,CAAC8B,IAAI,CACLjB,OAAO,CAACC,SAAS,EACjBe,cACJ,CACJ,CAAC;EACL,CAAC,CAAC;AACN;AAEA,OAAO,eAAeE,WAAWA,CAC7BC,QAAgB,EAChBC,IAAmB,EACN;EACb,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IAC1BA,IAAI,GAAG,MAAMhC,YAAY,CAACgC,IAAI,CAAC;EACnC;EACA,OAAO,IAAIC,OAAO,CAAC,UAAUC,GAAG,EAAEC,GAAG,EAAE;IACnCrC,EAAE,CAACsC,SAAS,CACRL,QAAQ,EACRC,IAAI,EACJ,OAAO,EACNK,GAAiB,IAAK;MACnB,IAAIA,GAAG,EAAE;QACLF,GAAG,CAACE,GAAG,CAAC;MACZ,CAAC,MAAM;QACHH,GAAG,CAAC,CAAC;MACT;IACJ,CACJ,CAAC;EACL,CAAC,CAAC;AACN;AAEA,OAAO,SAASI,eAAeA,CAC3BP,QAAgB,EAChBC,IAAS,EACI;EACb,OAAOF,WAAW,CACdC,QAAQ,EACRT,IAAI,CAACC,SAAS,CAACS,IAAI,CACvB,CAAC;AACL;AAEA,OAAO,SAASjB,gBAAgBA,CAACH,OAAsB,EAAU;EAC7D,OAAOb,IAAI,CAAC8B,IAAI,CACZjB,OAAO,CAACC,SAAS,EACjB,kBACJ,CAAC;AACL;AAEA,OAAO,SAAS0B,OAAOA,CAAC3B,OAAsB,EAAkC;EAC5E,IAAM4B,GAAG,GAAGzB,gBAAgB,CAACH,OAAO,CAAC;EACrC,OAAO,IAAIqB,OAAO,CAAC,CAACC,GAAG,EAAEC,GAAG,KAAK;IAC7BrC,EAAE,CAAC2C,QAAQ,CAACD,GAAG,EAAE,OAAO,EAAE,CAACH,GAAiB,EAAEL,IAAY,KAAK;MAC3D,IAAIK,GAAG,EAAE;QACLF,GAAG,CAACE,GAAG,CAAC;MACZ,CAAC,MAAM;QACH,IAAMK,WAAW,GAAGpB,IAAI,CAACqB,KAAK,CAACX,IAAI,CAAC;QACpCE,GAAG,CAACQ,WAAW,CAAC;MACpB;IACJ,CAAC,CAAC;EACN,CAAC,CAAC;AACN;AAEA,OAAO,SAASE,OAAOA,CACnBhC,OAAsB,EACtBiC,IAA2B,EACd;EACb,IAAML,GAAG,GAAGzB,gBAAgB,CAACH,OAAO,CAAC;EACrC,OAAO0B,eAAe,CAACE,GAAG,EAAEK,IAAI,CAAC;AACrC;AAEA,OAAO,SAASC,cAAcA,CAC1BlC,OAAsB,EACtBmC,KAAa,EACP;EACN,OAAOhD,IAAI,CAAC8B,IAAI,CACZjB,OAAO,CAACC,SAAS,EACjBkC,KACJ,CAAC;AACL","ignoreList":[]}

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

@@ -0,0 +1,183 @@
+import * as path from 'node:path';
+import { BehaviorSubject, firstValueFrom, Subject } from 'rxjs';
+import { filter, map } from 'rxjs';
+import { getFromMapOrCreate, PROMISE_RESOLVE_FALSE, PROMISE_RESOLVE_TRUE, PROMISE_RESOLVE_VOID } from "../../plugins/utils/index.js";
+import { clearFolder, deleteFolder, documentFolder, ensureFolderExists, getMeta, prepareFolders, setMeta, writeJsonToFile, writeToFile } from "./file-util.js";
+import { getChangedDocumentsSince } from "../../rx-storage-helper.js";
+
+/**
+ * Backups a single documents,
+ * returns the paths to all written files
+ */
+export async function backupSingleDocument(rxDocument, options) {
+  var data = rxDocument.toJSON(true);
+  var writtenFiles = [];
+  var docFolder = documentFolder(options, rxDocument.primary);
+  await clearFolder(docFolder);
+  var fileLocation = path.join(docFolder, 'document.json');
+  await writeJsonToFile(fileLocation, data);
+  writtenFiles.push(fileLocation);
+  if (options.attachments) {
+    var attachmentsFolder = path.join(docFolder, 'attachments');
+    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 writeToFile(attachmentFileLocation, content);
+      writtenFiles.push(attachmentFileLocation);
+    }));
+  }
+  return writtenFiles;
+}
+var BACKUP_STATES_BY_DB = new WeakMap();
+function addToBackupStates(db, state) {
+  var ar = getFromMapOrCreate(BACKUP_STATES_BY_DB, db, () => []);
+  ar.push(state);
+}
+export var RxBackupState = /*#__PURE__*/function () {
+  function RxBackupState(database, options) {
+    this.isStopped = false;
+    this.subs = [];
+    this.persistRunning = PROMISE_RESOLVE_VOID;
+    this.initialReplicationDone$ = new BehaviorSubject(false);
+    this.internalWriteEvents$ = new Subject();
+    this.writeEvents$ = this.internalWriteEvents$.asObservable();
+    this.database = database;
+    this.options = options;
+    if (!this.options.batchSize) {
+      this.options.batchSize = 10;
+    }
+    addToBackupStates(database, this);
+    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 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 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 deleteFolder(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 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 firstValueFrom(this.initialReplicationDone$.pipe(filter(v => !!v), map(() => true)));
+  };
+  _proto.cancel = function cancel() {
+    if (this.isStopped) {
+      return PROMISE_RESOLVE_FALSE;
+    }
+    this.isStopped = true;
+    this.subs.forEach(sub => sub.unsubscribe());
+    return PROMISE_RESOLVE_TRUE;
+  };
+  return RxBackupState;
+}();
+export function backup(options) {
+  var backupState = new RxBackupState(this, options);
+  backupState.persistOnce();
+  if (options.live) {
+    backupState.watchForChanges();
+  }
+  return backupState;
+}
+export * from "./file-util.js";
+export var 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/esm/plugins/backup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["path","BehaviorSubject","firstValueFrom","Subject","filter","map","getFromMapOrCreate","PROMISE_RESOLVE_FALSE","PROMISE_RESOLVE_TRUE","PROMISE_RESOLVE_VOID","clearFolder","deleteFolder","documentFolder","ensureFolderExists","getMeta","prepareFolders","setMeta","writeJsonToFile","writeToFile","getChangedDocumentsSince","backupSingleDocument","rxDocument","options","data","toJSON","writtenFiles","docFolder","primary","fileLocation","join","push","attachments","attachmentsFolder","allAttachments","Promise","all","attachment","content","getData","attachmentFileLocation","id","BACKUP_STATES_BY_DB","WeakMap","addToBackupStates","db","state","ar","RxBackupState","database","isStopped","subs","persistRunning","initialReplicationDone$","internalWriteEvents$","writeEvents$","asObservable","batchSize","_proto","prototype","persistOnce","then","_persistOnce","_this","meta","Object","entries","collections","collectionName","collection","primaryKey","schema","primaryPath","processedDocuments","Set","requestIdlePromise","collectionStates","lastCheckpoint","checkpoint","hasMore","_loop","changesResult","storageInstance","documents","length","docIds","doc","has","add","elem","pos","arr","indexOf","docs","findByIds","exec","size","Array","from","values","next","name","documentId","files","deleted","docId","getValue","watchForChanges","forEach","changes$","changeStream","sub","subscribe","awaitInitialBackup","pipe","v","cancel","unsubscribe","backup","backupState","live","RxDBBackupPlugin","rxdb","prototypes","RxDatabase","proto","hooks","preCloseRxDatabase","after","states","get"],"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":"AAAA,OAAO,KAAKA,IAAI,MAAM,WAAW;AACjC,SACIC,eAAe,EACfC,cAAc,EAEdC,OAAO,QAEJ,MAAM;AACb,SACIC,MAAM,EACNC,GAAG,QACA,MAAM;AASb,SACIC,kBAAkB,EAClBC,qBAAqB,EACrBC,oBAAoB,EACpBC,oBAAoB,QACjB,8BAA8B;AACrC,SACIC,WAAW,EACXC,YAAY,EACZC,cAAc,EACdC,kBAAkB,EAClBC,OAAO,EACPC,cAAc,EACdC,OAAO,EACPC,eAAe,EACfC,WAAW,QACR,gBAAgB;AACvB,SAASC,wBAAwB,QAAQ,4BAA4B;;AAGrE;AACA;AACA;AACA;AACA,OAAO,eAAeC,oBAAoBA,CACtCC,UAAgC,EAChCC,OAAsB,EACL;EACjB,IAAMC,IAAI,GAAGF,UAAU,CAACG,MAAM,CAAC,IAAI,CAAC;EACpC,IAAMC,YAAsB,GAAG,EAAE;EAEjC,IAAMC,SAAS,GAAGd,cAAc,CAACU,OAAO,EAAED,UAAU,CAACM,OAAO,CAAC;EAC7D,MAAMjB,WAAW,CAACgB,SAAS,CAAC;EAE5B,IAAME,YAAY,GAAG5B,IAAI,CAAC6B,IAAI,CAC1BH,SAAS,EACT,eACJ,CAAC;EACD,MAAMT,eAAe,CAACW,YAAY,EAAEL,IAAI,CAAC;EACzCE,YAAY,CAACK,IAAI,CAACF,YAAY,CAAC;EAE/B,IAAIN,OAAO,CAACS,WAAW,EAAE;IACrB,IAAMC,iBAAiB,GAAGhC,IAAI,CAAC6B,IAAI,CAC/BH,SAAS,EACT,aACJ,CAAC;IACDb,kBAAkB,CAACmB,iBAAiB,CAAC;IACrC,IAAMD,WAAW,GAAIV,UAAU,CAAgBY,cAAc,CAAC,CAAC;IAC/D,MAAMC,OAAO,CAACC,GAAG,CACbJ,WAAW,CACN1B,GAAG,CAAC,MAAO+B,UAAU,IAAK;MACvB,IAAMC,OAAO,GAAG,MAAMD,UAAU,CAACE,OAAO,CAAC,CAAC;MAC1C,IAAMC,sBAAsB,GAAGvC,IAAI,CAAC6B,IAAI,CACpCG,iBAAiB,EACjBI,UAAU,CAACI,EACf,CAAC;MACD,MAAMtB,WAAW,CAACqB,sBAAsB,EAAEF,OAAO,CAAC;MAClDZ,YAAY,CAACK,IAAI,CAACS,sBAAsB,CAAC;IAC7C,CAAC,CACT,CAAC;EACL;EAEA,OAAOd,YAAY;AACvB;AAEA,IAAMgB,mBAAyD,GAAG,IAAIC,OAAO,CAAC,CAAC;AAC/E,SAASC,iBAAiBA,CAACC,EAAc,EAAEC,KAAoB,EAAE;EAC7D,IAAMC,EAAE,GAAGxC,kBAAkB,CACzBmC,mBAAmB,EACnBG,EAAE,EACF,MAAM,EACV,CAAC;EACDE,EAAE,CAAChB,IAAI,CAACe,KAAK,CAAC;AAClB;AAEA,WAAaE,aAAa;EAStB,SAAAA,cACoBC,QAAoB,EACpB1B,OAAsB,EACxC;IAAA,KAXK2B,SAAS,GAAY,KAAK;IAAA,KACzBC,IAAI,GAAmB,EAAE;IAAA,KACzBC,cAAc,GAAkB1C,oBAAoB;IAAA,KACpD2C,uBAAuB,GAA6B,IAAInD,eAAe,CAAC,KAAY,CAAC;IAAA,KAE5EoD,oBAAoB,GAAgC,IAAIlD,OAAO,CAAC,CAAC;IAAA,KAClEmD,YAAY,GAAmC,IAAI,CAACD,oBAAoB,CAACE,YAAY,CAAC,CAAC;IAAA,KAGnFP,QAAoB,GAApBA,QAAoB;IAAA,KACpB1B,OAAsB,GAAtBA,OAAsB;IAEtC,IAAI,CAAC,IAAI,CAACA,OAAO,CAACkC,SAAS,EAAE;MACzB,IAAI,CAAClC,OAAO,CAACkC,SAAS,GAAG,EAAE;IAC/B;IACAb,iBAAiB,CAACK,QAAQ,EAAE,IAAI,CAAC;IACjCjC,cAAc,CAACiC,QAAQ,EAAE1B,OAAO,CAAC;EACrC;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;EANI,IAAAmC,MAAA,GAAAV,aAAA,CAAAW,SAAA;EAAAD,MAAA,CAOOE,WAAW,GAAlB,SAAOA,WAAWA,CAAA,EAAG;IACjB,OAAO,IAAI,CAACR,cAAc,GAAG,IAAI,CAACA,cAAc,CAACS,IAAI,CAAC,MAAM,IAAI,CAACC,YAAY,CAAC,CAAC,CAAC;EACpF,CAAC;EAAAJ,MAAA,CAEYI,YAAY,GAAzB,eAAaA,YAAYA,CAAA,EAAG;IAAA,IAAAC,KAAA;IACxB,IAAMC,IAAI,GAAG,MAAMjD,OAAO,CAAC,IAAI,CAACQ,OAAO,CAAC;IAExC,MAAMY,OAAO,CAACC,GAAG,CACb6B,MAAM,CACDC,OAAO,CAAC,IAAI,CAACjB,QAAQ,CAACkB,WAAW,CAAC,CAClC7D,GAAG,CAAC,OAAO,CAAC8D,cAAc,EAAEC,UAAU,CAAC,KAAK;MACzC,IAAMC,UAAU,GAAGD,UAAU,CAACE,MAAM,CAACC,WAAW;MAChD,IAAMC,kBAA+B,GAAG,IAAIC,GAAG,CAAC,CAAC;MAEjD,MAAM,IAAI,CAACzB,QAAQ,CAAC0B,kBAAkB,CAAC,CAAC;MAExC,IAAI,CAACX,IAAI,CAACY,gBAAgB,CAACR,cAAc,CAAC,EAAE;QACxCJ,IAAI,CAACY,gBAAgB,CAACR,cAAc,CAAC,GAAG,CAAC,CAAC;MAC9C;MACA,IAAIS,cAAc,GAAGb,IAAI,CAACY,gBAAgB,CAACR,cAAc,CAAC,CAACU,UAAU;MAErE,IAAIC,OAAO,GAAG,IAAI;MAAC,IAAAC,KAAA,kBAAAA,CAAA,EACgB;QAC/B,MAAMjB,KAAI,CAACd,QAAQ,CAAC0B,kBAAkB,CAAC,CAAC;QACxC,IAAMM,aAAa,GAAG,MAAM7D,wBAAwB,CAChDiD,UAAU,CAACa,eAAe,EAC1BnB,KAAI,CAACxC,OAAO,CAACkC,SAAS,GAAGM,KAAI,CAACxC,OAAO,CAACkC,SAAS,GAAG,CAAC,EACnDoB,cACJ,CAAC;QACDA,cAAc,GAAGI,aAAa,CAACE,SAAS,CAACC,MAAM,GAAG,CAAC,GAAGH,aAAa,CAACH,UAAU,GAAGD,cAAc;QAC/Fb,IAAI,CAACY,gBAAgB,CAACR,cAAc,CAAC,CAACU,UAAU,GAAGD,cAAc;QAEjE,IAAMQ,MAAgB,GAAGJ,aAAa,CAACE,SAAS,CAC3C7E,GAAG,CAACgF,GAAG,IAAIA,GAAG,CAAChB,UAAU,CAAC,CAAC,CAC3BjE,MAAM,CAACoC,EAAE,IAAI;UACV,IACIgC,kBAAkB,CAACc,GAAG,CAAC9C,EAAE,CAAC,EAC5B;YACE,OAAO,KAAK;UAChB,CAAC,MAAM;YACHgC,kBAAkB,CAACe,GAAG,CAAC/C,EAAE,CAAC;YAC1B,OAAO,IAAI;UACf;QACJ,CAAC,CAAC,CACDpC,MAAM,CAAC,CAACoF,IAAI,EAAEC,GAAG,EAAEC,GAAG,KAAKA,GAAG,CAACC,OAAO,CAACH,IAAI,CAAC,KAAKC,GAAG,CAAC,CAAC,CAAC;QAC5D,MAAM3B,KAAI,CAACd,QAAQ,CAAC0B,kBAAkB,CAAC,CAAC;QAExC,IAAMkB,IAA6B,GAAG,MAAMxB,UAAU,CAACyB,SAAS,CAACT,MAAM,CAAC,CAACU,IAAI,CAAC,CAAC;QAC/E,IAAIF,IAAI,CAACG,IAAI,KAAK,CAAC,EAAE;UACjBjB,OAAO,GAAG,KAAK;UAAC;QAEpB;QACA,MAAM5C,OAAO,CAACC,GAAG,CACb6D,KAAK,CACAC,IAAI,CAACL,IAAI,CAACM,MAAM,CAAC,CAAC,CAAC,CACnB7F,GAAG,CAAC,MAAOgF,GAAG,IAAK;UAChB,IAAM5D,YAAY,GAAG,MAAML,oBAAoB,CAACiE,GAAG,EAAEvB,KAAI,CAACxC,OAAO,CAAC;UAClEwC,KAAI,CAACT,oBAAoB,CAAC8C,IAAI,CAAC;YAC3BhC,cAAc,EAAEC,UAAU,CAACgC,IAAI;YAC/BC,UAAU,EAAEhB,GAAG,CAAC1D,OAAO;YACvB2E,KAAK,EAAE7E,YAAY;YACnB8E,OAAO,EAAE;UACb,CAAC,CAAC;QACN,CAAC,CACT,CAAC;QACD;QACA,MAAMrE,OAAO,CAACC,GAAG,CACbiD,MAAM,CACDhF,MAAM,CAACoG,KAAK,IAAI,CAACZ,IAAI,CAACN,GAAG,CAACkB,KAAK,CAAC,CAAC,CACjCnG,GAAG,CAAC,MAAOmG,KAAK,IAAK;UAClB,MAAM7F,YAAY,CAACC,cAAc,CAACkD,KAAI,CAACxC,OAAO,EAAEkF,KAAK,CAAC,CAAC;UACvD1C,KAAI,CAACT,oBAAoB,CAAC8C,IAAI,CAAC;YAC3BhC,cAAc,EAAEC,UAAU,CAACgC,IAAI;YAC/BC,UAAU,EAAEG,KAAK;YACjBF,KAAK,EAAE,EAAE;YACTC,OAAO,EAAE;UACb,CAAC,CAAC;QACN,CAAC,CACT,CAAC;MACL,CAAC;MAzDD,OAAOzB,OAAO,IAAI,CAAC,IAAI,CAAC7B,SAAS;QAAA,UAAA8B,KAAA,IA4BzB;MAAS;MA8BjBhB,IAAI,CAACY,gBAAgB,CAACR,cAAc,CAAC,CAACU,UAAU,GAAGD,cAAc;MACjE,MAAM5D,OAAO,CAAC,IAAI,CAACM,OAAO,EAAEyC,IAAI,CAAC;IACrC,CAAC,CACT,CAAC;IAED,IAAI,CAAC,IAAI,CAACX,uBAAuB,CAACqD,QAAQ,CAAC,CAAC,EAAE;MAC1C,IAAI,CAACrD,uBAAuB,CAAC+C,IAAI,CAAC,IAAI,CAAC;IAC3C;EACJ,CAAC;EAAA1C,MAAA,CAEMiD,eAAe,GAAtB,SAAOA,eAAeA,CAAA,EAAG;IACrB,IAAMxC,WAA2B,GAAGF,MAAM,CAACkC,MAAM,CAAC,IAAI,CAAClD,QAAQ,CAACkB,WAAW,CAAC;IAC5EA,WAAW,CAACyC,OAAO,CAACvC,UAAU,IAAI;MAC9B,IAAMwC,QAAQ,GAAGxC,UAAU,CAACa,eAAe,CAAC4B,YAAY,CAAC,CAAC;MAC1D,IAAMC,GAAG,GAAGF,QAAQ,CAACG,SAAS,CAAC,MAAM;QACjC,IAAI,CAACpD,WAAW,CAAC,CAAC;MACtB,CAAC,CAAC;MACF,IAAI,CAACT,IAAI,CAACpB,IAAI,CAACgF,GAAG,CAAC;IACvB,CAAC,CAAC;EACN;;EAEA;AACJ;AACA;AACA,KAHI;EAAArD,MAAA,CAIOuD,kBAAkB,GAAzB,SAAOA,kBAAkBA,CAAA,EAAqB;IAC1C,OAAO9G,cAAc,CACjB,IAAI,CAACkD,uBAAuB,CAAC6D,IAAI,CAC7B7G,MAAM,CAAE8G,CAAU,IAAK,CAAC,CAACA,CAAC,CAAC,EAC3B7G,GAAG,CAAC,MAAM,IAAI,CAClB,CACJ,CAAC;EACL,CAAC;EAAAoD,MAAA,CAED0D,MAAM,GAAN,SAAAA,MAAMA,CAAA,EAAqB;IACvB,IAAI,IAAI,CAAClE,SAAS,EAAE;MAChB,OAAO1C,qBAAqB;IAChC;IACA,IAAI,CAAC0C,SAAS,GAAG,IAAI;IACrB,IAAI,CAACC,IAAI,CAACyD,OAAO,CAACG,GAAG,IAAIA,GAAG,CAACM,WAAW,CAAC,CAAC,CAAC;IAC3C,OAAO5G,oBAAoB;EAC/B,CAAC;EAAA,OAAAuC,aAAA;AAAA;AAIL,OAAO,SAASsE,MAAMA,CAElB/F,OAAsB,EACT;EACb,IAAMgG,WAAW,GAAG,IAAIvE,aAAa,CAAC,IAAI,EAAEzB,OAAO,CAAC;EACpDgG,WAAW,CAAC3D,WAAW,CAAC,CAAC;EAEzB,IAAIrC,OAAO,CAACiG,IAAI,EAAE;IACdD,WAAW,CAACZ,eAAe,CAAC,CAAC;EACjC;EAEA,OAAOY,WAAW;AACtB;AAEA,cAAc,gBAAgB;AAC9B,OAAO,IAAME,gBAA0B,GAAG;EACtCpB,IAAI,EAAE,QAAQ;EACdqB,IAAI,EAAE,IAAI;EACVC,UAAU,EAAE;IACRC,UAAUA,CAACC,KAAU,EAAE;MACnBA,KAAK,CAACP,MAAM,GAAGA,MAAM;IACzB;EACJ,CAAC;EACDQ,KAAK,EAAE;IACHC,kBAAkB,EAAE;MAChBC,KAAK,EAAE,SAASD,kBAAkBA,CAAClF,EAAc,EAAE;QAC/C,IAAMoF,MAAM,GAAGvF,mBAAmB,CAACwF,GAAG,CAACrF,EAAE,CAAC;QAC1C,IAAIoF,MAAM,EAAE;UACRA,MAAM,CAACrB,OAAO,CAAC9D,KAAK,IAAIA,KAAK,CAACsE,MAAM,CAAC,CAAC,CAAC;QAC3C;MACJ;IACJ;EACJ;AACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,11 @@
+export var 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/esm/plugins/cleanup/cleanup-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup-helper.js","names":["DEFAULT_CLEANUP_POLICY","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":"AAIA,OAAO,IAAMA,sBAAuC,GAAG;EACnDC,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/esm/plugins/cleanup/cleanup-state.js

@@ -0,0 +1,75 @@
+import { PROMISE_RESOLVE_TRUE } from "../../plugins/utils/index.js";
+import { REPLICATION_STATE_BY_COLLECTION } from "../replication/index.js";
+import { DEFAULT_CLEANUP_POLICY } from "./cleanup-helper.js";
+import { initialCleanupWait } from "./cleanup.js";
+import { firstValueFrom } from 'rxjs';
+var RXSTATE_CLEANUP_QUEUE = PROMISE_RESOLVE_TRUE;
+export async function startCleanupForRxState(state) {
+  var rxCollection = state.collection;
+  var rxDatabase = rxCollection.database;
+  var cleanupPolicy = Object.assign({}, DEFAULT_CLEANUP_POLICY, rxDatabase.cleanupPolicy ? rxDatabase.cleanupPolicy : {});
+  await 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
+ */
+export 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 = 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;
+  }
+}
+export 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 firstValueFrom(rxCollection.eventBulks$).catch(() => {});
+    await rxCollection.promiseWait(cleanupPolicy.runEach);
+    if (rxCollection.closed) {
+      return;
+    }
+    await cleanupRxState(state, cleanupPolicy);
+  }
+}
+//# sourceMappingURL=cleanup-state.js.map