@connecttomahdi/rxdb 17.0.0-beta.17

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

@@ -0,0 +1,237 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  RxAttachment: true,
+  fromStorageInstanceResult: true,
+  putAttachment: true,
+  putAttachmentBase64: true,
+  putAttachments: true,
+  getAttachment: true,
+  allAttachments: true,
+  preMigrateDocument: true,
+  postMigrateDocument: true,
+  RxDBAttachmentsPlugin: true
+};
+exports.RxDBAttachmentsPlugin = exports.RxAttachment = void 0;
+exports.allAttachments = allAttachments;
+exports.fromStorageInstanceResult = fromStorageInstanceResult;
+exports.getAttachment = getAttachment;
+exports.postMigrateDocument = postMigrateDocument;
+exports.preMigrateDocument = preMigrateDocument;
+exports.putAttachment = putAttachment;
+exports.putAttachmentBase64 = putAttachmentBase64;
+exports.putAttachments = putAttachments;
+var _rxjs = require("rxjs");
+var _index = require("../../plugins/utils/index.js");
+var _attachmentsUtils = require("./attachments-utils.js");
+Object.keys(_attachmentsUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _attachmentsUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _attachmentsUtils[key];
+    }
+  });
+});
+/**
+ * an RxAttachment is basically just the attachment-stub
+ * wrapped so that you can access the attachment-data
+ */
+var RxAttachment = exports.RxAttachment = /*#__PURE__*/function () {
+  function RxAttachment({
+    doc,
+    id,
+    type,
+    length,
+    digest
+  }) {
+    this.doc = doc;
+    this.id = id;
+    this.type = type;
+    this.length = length;
+    this.digest = digest;
+    (0, _attachmentsUtils.assignMethodsToAttachment)(this);
+  }
+  var _proto = RxAttachment.prototype;
+  _proto.remove = function remove() {
+    return this.doc.collection.incrementalWriteQueue.addWrite(this.doc._data, docWriteData => {
+      delete docWriteData._attachments[this.id];
+      return docWriteData;
+    }).then(() => {});
+  }
+
+  /**
+   * returns the data for the attachment
+   */;
+  _proto.getData = async function getData() {
+    var blob = await this.doc.collection.storageInstance.getAttachmentData(this.doc.primary, this.id, this.digest);
+    // Some storage layers return blobs without the original MIME type.
+    // Ensure the returned Blob has the attachment's MIME type.
+    if (blob && blob.type !== this.type) {
+      return blob.slice(0, blob.size, this.type);
+    }
+    return blob;
+  };
+  _proto.getStringData = async function getStringData() {
+    var data = await this.getData();
+    var asString = await (0, _index.blobToString)(data);
+    return asString;
+  };
+  _proto.getDataBase64 = async function getDataBase64() {
+    var blob = await this.getData();
+    return (0, _index.blobToBase64String)(blob);
+  };
+  return RxAttachment;
+}();
+function fromStorageInstanceResult(id, attachmentData, rxDocument) {
+  return new RxAttachment({
+    doc: rxDocument,
+    id,
+    type: attachmentData.type,
+    length: attachmentData.length,
+    digest: attachmentData.digest
+  });
+}
+async function _putAttachmentsImpl(doc, attachments) {
+  (0, _attachmentsUtils.ensureSchemaSupportsAttachments)(doc);
+  if (attachments.length === 0) {
+    return [];
+  }
+  var prepared = await Promise.all(attachments.map(async att => ({
+    id: att.id,
+    type: att.type,
+    data: att.data,
+    digest: await doc.collection.database.hashFunction(att.data)
+  })));
+  var writeResult = await doc.collection.incrementalWriteQueue.addWrite(doc._data, docWriteData => {
+    docWriteData = (0, _index.flatClone)(docWriteData);
+    docWriteData._attachments = (0, _index.flatClone)(docWriteData._attachments);
+    for (var att of prepared) {
+      docWriteData._attachments[att.id] = {
+        length: att.data.size,
+        type: att.type,
+        data: att.data,
+        digest: att.digest
+      };
+    }
+    return docWriteData;
+  });
+  var newDocument = doc.collection._docCache.getCachedRxDocument(writeResult);
+  return prepared.map(att => fromStorageInstanceResult(att.id, writeResult._attachments[att.id], newDocument));
+}
+async function putAttachment(attachmentData) {
+  var results = await _putAttachmentsImpl(this, [attachmentData]);
+  return results[0];
+}
+async function putAttachmentBase64(attachmentData) {
+  (0, _attachmentsUtils.ensureSchemaSupportsAttachments)(this);
+  var blob = await (0, _index.createBlobFromBase64)(attachmentData.data, attachmentData.type);
+  return this.putAttachment({
+    id: attachmentData.id,
+    type: attachmentData.type,
+    data: blob
+  });
+}
+
+/**
+ * Write multiple attachments in a single atomic operation.
+ */
+function putAttachments(attachments) {
+  return _putAttachmentsImpl(this, attachments);
+}
+
+/**
+ * get an attachment of the document by its id
+ */
+function getAttachment(id) {
+  (0, _attachmentsUtils.ensureSchemaSupportsAttachments)(this);
+  var docData = this._data;
+  if (!docData._attachments || !docData._attachments[id]) return null;
+  var attachmentData = docData._attachments[id];
+  var attachment = fromStorageInstanceResult(id, attachmentData, this);
+  return attachment;
+}
+
+/**
+ * returns all attachments of the document
+ */
+function allAttachments() {
+  (0, _attachmentsUtils.ensureSchemaSupportsAttachments)(this);
+  var docData = this._data;
+
+  // if there are no attachments, the field is missing
+  if (!docData._attachments) {
+    return [];
+  }
+  return Object.keys(docData._attachments).map(id => {
+    return fromStorageInstanceResult(id, docData._attachments[id], this);
+  });
+}
+async function preMigrateDocument(data) {
+  var attachments = data.docData._attachments;
+  if (attachments) {
+    var newAttachments = {};
+    await Promise.all(Object.keys(attachments).map(async attachmentId => {
+      var attachment = attachments[attachmentId];
+      var docPrimary = data.docData[data.oldCollection.schema.primaryPath];
+      var rawAttachmentBlob = await data.oldCollection.storageInstance.getAttachmentData(docPrimary, attachmentId, attachment.digest);
+      var digest = await data.oldCollection.database.hashFunction(rawAttachmentBlob);
+      newAttachments[attachmentId] = {
+        length: rawAttachmentBlob.size,
+        type: attachment.type,
+        data: rawAttachmentBlob,
+        digest
+      };
+    }));
+
+    /**
+     * Hooks mutate the input
+     * instead of returning stuff
+     */
+    data.docData._attachments = newAttachments;
+  }
+}
+function postMigrateDocument(_action) {
+  /**
+   * No longer needed because
+   * we store the attachments data buffers directly in the document.
+   */
+  return _index.PROMISE_RESOLVE_VOID;
+}
+var RxDBAttachmentsPlugin = exports.RxDBAttachmentsPlugin = {
+  name: 'attachments',
+  rxdb: true,
+  prototypes: {
+    RxDocument: proto => {
+      proto.putAttachment = putAttachment;
+      proto.putAttachments = putAttachments;
+      proto.putAttachmentBase64 = putAttachmentBase64;
+      proto.getAttachment = getAttachment;
+      proto.allAttachments = allAttachments;
+      Object.defineProperty(proto, 'allAttachments$', {
+        get: function allAttachments$() {
+          return this.$.pipe((0, _rxjs.map)(rxDocument => Object.entries(rxDocument.toJSON(true)._attachments)), (0, _rxjs.map)(entries => {
+            return entries.map(([id, attachmentData]) => {
+              return fromStorageInstanceResult(id, attachmentData, this);
+            });
+          }));
+        }
+      });
+    }
+  },
+  overwritable: {},
+  hooks: {
+    preMigrateDocument: {
+      after: preMigrateDocument
+    },
+    postMigrateDocument: {
+      after: postMigrateDocument
+    }
+  }
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_rxjs","require","_index","_attachmentsUtils","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","RxAttachment","doc","id","type","length","digest","assignMethodsToAttachment","_proto","remove","collection","incrementalWriteQueue","addWrite","_data","docWriteData","_attachments","then","getData","blob","storageInstance","getAttachmentData","primary","slice","size","getStringData","data","asString","blobToString","getDataBase64","blobToBase64String","fromStorageInstanceResult","attachmentData","rxDocument","_putAttachmentsImpl","attachments","ensureSchemaSupportsAttachments","prepared","Promise","all","map","att","database","hashFunction","writeResult","flatClone","newDocument","_docCache","getCachedRxDocument","putAttachment","results","putAttachmentBase64","createBlobFromBase64","putAttachments","getAttachment","docData","attachment","allAttachments","preMigrateDocument","newAttachments","attachmentId","docPrimary","oldCollection","schema","primaryPath","rawAttachmentBlob","postMigrateDocument","_action","PROMISE_RESOLVE_VOID","RxDBAttachmentsPlugin","name","rxdb","prototypes","RxDocument","proto","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":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AAIA,IAAAC,MAAA,GAAAD,OAAA;AAkBA,IAAAE,iBAAA,GAAAF,OAAA;AAqSAG,MAAA,CAAAC,IAAA,CAAAF,iBAAA,EAAAG,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,MAAAJ,iBAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,iBAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AA9RA;AACA;AACA;AACA;AAHA,IAIaS,YAAY,GAAAJ,OAAA,CAAAI,YAAA;EAMrB,SAAAA,aAAY;IACRC,GAAG;IACHC,EAAE;IACFC,IAAI;IACJC,MAAM;IACNC;EACC,CAAC,EAAE;IACJ,IAAI,CAACJ,GAAG,GAAGA,GAAG;IACd,IAAI,CAACC,EAAE,GAAGA,EAAE;IACZ,IAAI,CAACC,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACC,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,MAAM,GAAGA,MAAM;IAEpB,IAAAC,2CAAyB,EAAC,IAAI,CAAC;EACnC;EAAC,IAAAC,MAAA,GAAAP,YAAA,CAAAR,SAAA;EAAAe,MAAA,CAEDC,MAAM,GAAN,SAAAA,MAAMA,CAAA,EAAkB;IACpB,OAAO,IAAI,CAACP,GAAG,CAACQ,UAAU,CAACC,qBAAqB,CAACC,QAAQ,CACrD,IAAI,CAACV,GAAG,CAACW,KAAK,EACdC,YAAY,IAAI;MACZ,OAAOA,YAAY,CAACC,YAAY,CAAC,IAAI,CAACZ,EAAE,CAAC;MACzC,OAAOW,YAAY;IACvB,CACJ,CAAC,CAACE,IAAI,CAAC,MAAM,CAAE,CAAC,CAAC;EACrB;;EAEA;AACJ;AACA,KAFI;EAAAR,MAAA,CAGMS,OAAO,GAAb,eAAMA,OAAOA,CAAA,EAAkB;IAC3B,IAAMC,IAAI,GAAG,MAAM,IAAI,CAAChB,GAAG,CAACQ,UAAU,CAACS,eAAe,CAACC,iBAAiB,CACpE,IAAI,CAAClB,GAAG,CAACmB,OAAO,EAChB,IAAI,CAAClB,EAAE,EACP,IAAI,CAACG,MACT,CAAC;IACD;IACA;IACA,IAAIY,IAAI,IAAIA,IAAI,CAACd,IAAI,KAAK,IAAI,CAACA,IAAI,EAAE;MACjC,OAAOc,IAAI,CAACI,KAAK,CAAC,CAAC,EAAEJ,IAAI,CAACK,IAAI,EAAE,IAAI,CAACnB,IAAI,CAAC;IAC9C;IACA,OAAOc,IAAI;EACf,CAAC;EAAAV,MAAA,CAEKgB,aAAa,GAAnB,eAAMA,aAAaA,CAAA,EAAoB;IACnC,IAAMC,IAAI,GAAG,MAAM,IAAI,CAACR,OAAO,CAAC,CAAC;IACjC,IAAMS,QAAQ,GAAG,MAAM,IAAAC,mBAAY,EAACF,IAAI,CAAC;IACzC,OAAOC,QAAQ;EACnB,CAAC;EAAAlB,MAAA,CAEKoB,aAAa,GAAnB,eAAMA,aAAaA,CAAA,EAAoB;IACnC,IAAMV,IAAI,GAAG,MAAM,IAAI,CAACD,OAAO,CAAC,CAAC;IACjC,OAAO,IAAAY,yBAAkB,EAACX,IAAI,CAAC;EACnC,CAAC;EAAA,OAAAjB,YAAA;AAAA;AAGE,SAAS6B,yBAAyBA,CACrC3B,EAAU,EACV4B,cAAgC,EAChCC,UAAiC,EACnC;EACE,OAAO,IAAI/B,YAAY,CAAC;IACpBC,GAAG,EAAE8B,UAAU;IACf7B,EAAE;IACFC,IAAI,EAAE2B,cAAc,CAAC3B,IAAI;IACzBC,MAAM,EAAE0B,cAAc,CAAC1B,MAAM;IAC7BC,MAAM,EAAEyB,cAAc,CAACzB;EAC3B,CAAC,CAAC;AACN;AAEA,eAAe2B,mBAAmBA,CAC9B/B,GAA0B,EAC1BgC,WAAkC,EACX;EACvB,IAAAC,iDAA+B,EAACjC,GAAG,CAAC;EAEpC,IAAIgC,WAAW,CAAC7B,MAAM,KAAK,CAAC,EAAE;IAC1B,OAAO,EAAE;EACb;EAEA,IAAM+B,QAAQ,GAAG,MAAMC,OAAO,CAACC,GAAG,CAC9BJ,WAAW,CAACK,GAAG,CAAC,MAAOC,GAAG,KAAM;IAC5BrC,EAAE,EAAEqC,GAAG,CAACrC,EAAE;IACVC,IAAI,EAAEoC,GAAG,CAACpC,IAAI;IACdqB,IAAI,EAAEe,GAAG,CAACf,IAAI;IACdnB,MAAM,EAAE,MAAMJ,GAAG,CAACQ,UAAU,CAAC+B,QAAQ,CAACC,YAAY,CAACF,GAAG,CAACf,IAAI;EAC/D,CAAC,CAAC,CACN,CAAC;EAED,IAAMkB,WAAW,GAAG,MAAMzC,GAAG,CAACQ,UAAU,CAACC,qBAAqB,CAACC,QAAQ,CACnEV,GAAG,CAACW,KAAK,EACRC,YAA4C,IAAK;IAC9CA,YAAY,GAAG,IAAA8B,gBAAS,EAAC9B,YAAY,CAAC;IACtCA,YAAY,CAACC,YAAY,GAAG,IAAA6B,gBAAS,EAAC9B,YAAY,CAACC,YAAY,CAAC;IAChE,KAAK,IAAMyB,GAAG,IAAIJ,QAAQ,EAAE;MACxBtB,YAAY,CAACC,YAAY,CAACyB,GAAG,CAACrC,EAAE,CAAC,GAAG;QAChCE,MAAM,EAAEmC,GAAG,CAACf,IAAI,CAACF,IAAI;QACrBnB,IAAI,EAAEoC,GAAG,CAACpC,IAAI;QACdqB,IAAI,EAAEe,GAAG,CAACf,IAAI;QACdnB,MAAM,EAAEkC,GAAG,CAAClC;MAChB,CAAC;IACL;IACA,OAAOQ,YAAY;EACvB,CACJ,CAAC;EAED,IAAM+B,WAAW,GAAG3C,GAAG,CAACQ,UAAU,CAACoC,SAAS,CAACC,mBAAmB,CAACJ,WAAW,CAAC;EAC7E,OAAOP,QAAQ,CAACG,GAAG,CAAEC,GAAG,IAAKV,yBAAyB,CAClDU,GAAG,CAACrC,EAAE,EACNwC,WAAW,CAAC5B,YAAY,CAACyB,GAAG,CAACrC,EAAE,CAAC,EAChC0C,WACJ,CAAC,CAAC;AACN;AAEO,eAAeG,aAAaA,CAE/BjB,cAAmC,EACd;EACrB,IAAMkB,OAAO,GAAG,MAAMhB,mBAAmB,CAAC,IAAI,EAAE,CAACF,cAAc,CAAC,CAAC;EACjE,OAAOkB,OAAO,CAAC,CAAC,CAAC;AACrB;AAEO,eAAeC,mBAAmBA,CAErCnB,cAAyC,EAC3C;EACE,IAAAI,iDAA+B,EAAC,IAAI,CAAC;EACrC,IAAMjB,IAAI,GAAG,MAAM,IAAAiC,2BAAoB,EAACpB,cAAc,CAACN,IAAI,EAAEM,cAAc,CAAC3B,IAAI,CAAC;EACjF,OAAO,IAAI,CAAC4C,aAAa,CAAC;IACtB7C,EAAE,EAAE4B,cAAc,CAAC5B,EAAE;IACrBC,IAAI,EAAE2B,cAAc,CAAC3B,IAAI;IACzBqB,IAAI,EAAEP;EACV,CAAC,CAAC;AACN;;AAEA;AACA;AACA;AACO,SAASkC,cAAcA,CAE1BlB,WAAkC,EACX;EACvB,OAAOD,mBAAmB,CAAC,IAAI,EAAEC,WAAW,CAAC;AACjD;;AAEA;AACA;AACA;AACO,SAASmB,aAAaA,CAEzBlD,EAAU,EACS;EACnB,IAAAgC,iDAA+B,EAAC,IAAI,CAAC;EACrC,IAAMmB,OAAY,GAAG,IAAI,CAACzC,KAAK;EAC/B,IAAI,CAACyC,OAAO,CAACvC,YAAY,IAAI,CAACuC,OAAO,CAACvC,YAAY,CAACZ,EAAE,CAAC,EAClD,OAAO,IAAI;EAEf,IAAM4B,cAAc,GAAGuB,OAAO,CAACvC,YAAY,CAACZ,EAAE,CAAC;EAC/C,IAAMoD,UAAU,GAAGzB,yBAAyB,CACxC3B,EAAE,EACF4B,cAAc,EACd,IACJ,CAAC;EACD,OAAOwB,UAAU;AACrB;;AAEA;AACA;AACA;AACO,SAASC,cAAcA,CAAA,EAEZ;EACd,IAAArB,iDAA+B,EAAC,IAAI,CAAC;EACrC,IAAMmB,OAAY,GAAG,IAAI,CAACzC,KAAK;;EAE/B;EACA,IAAI,CAACyC,OAAO,CAACvC,YAAY,EAAE;IACvB,OAAO,EAAE;EACb;EACA,OAAO1B,MAAM,CAACC,IAAI,CAACgE,OAAO,CAACvC,YAAY,CAAC,CACnCwB,GAAG,CAACpC,EAAE,IAAI;IACP,OAAO2B,yBAAyB,CAC5B3B,EAAE,EACFmD,OAAO,CAACvC,YAAY,CAACZ,EAAE,CAAC,EACxB,IACJ,CAAC;EACL,CAAC,CAAC;AACV;AAEO,eAAesD,kBAAkBA,CACpChC,IAGC,EACY;EACb,IAAMS,WAAW,GAAGT,IAAI,CAAC6B,OAAO,CAACvC,YAAY;EAC7C,IAAImB,WAAW,EAAE;IACb,IAAMwB,cAAkE,GAAG,CAAC,CAAC;IAC7E,MAAMrB,OAAO,CAACC,GAAG,CACbjD,MAAM,CAACC,IAAI,CAAC4C,WAAW,CAAC,CAACK,GAAG,CAAC,MAAOoB,YAAY,IAAK;MACjD,IAAMJ,UAA4B,GAAGrB,WAAW,CAACyB,YAAY,CAAC;MAC9D,IAAMC,UAAkB,GAAInC,IAAI,CAAC6B,OAAO,CAAS7B,IAAI,CAACoC,aAAa,CAACC,MAAM,CAACC,WAAW,CAAC;MACvF,IAAMC,iBAAiB,GAAG,MAAMvC,IAAI,CAACoC,aAAa,CAAC1C,eAAe,CAACC,iBAAiB,CAChFwC,UAAU,EACVD,YAAY,EACZJ,UAAU,CAACjD,MACf,CAAC;MACD,IAAMA,MAAM,GAAG,MAAMmB,IAAI,CAACoC,aAAa,CAACpB,QAAQ,CAACC,YAAY,CAACsB,iBAAiB,CAAC;MAChFN,cAAc,CAACC,YAAY,CAAC,GAAG;QAC3BtD,MAAM,EAAE2D,iBAAiB,CAACzC,IAAI;QAC9BnB,IAAI,EAAEmD,UAAU,CAACnD,IAAI;QACrBqB,IAAI,EAAEuC,iBAAiB;QACvB1D;MACJ,CAAC;IACL,CAAC,CACL,CAAC;;IAED;AACR;AACA;AACA;IACSmB,IAAI,CAAC6B,OAAO,CAAoCvC,YAAY,GAAG2C,cAAc;EAClF;AACJ;AAEO,SAASO,mBAAmBA,CAACC,OAAY,EAAiB;EAC7D;AACJ;AACA;AACA;EACI,OAAOC,2BAAoB;AAC/B;AAEO,IAAMC,qBAA+B,GAAAvE,OAAA,CAAAuE,qBAAA,GAAG;EAC3CC,IAAI,EAAE,aAAa;EACnBC,IAAI,EAAE,IAAI;EACVC,UAAU,EAAE;IACRC,UAAU,EAAGC,KAAU,IAAK;MACxBA,KAAK,CAACzB,aAAa,GAAGA,aAAa;MACnCyB,KAAK,CAACrB,cAAc,GAAGA,cAAc;MACrCqB,KAAK,CAACvB,mBAAmB,GAAGA,mBAAmB;MAC/CuB,KAAK,CAACpB,aAAa,GAAGA,aAAa;MACnCoB,KAAK,CAACjB,cAAc,GAAGA,cAAc;MACrCnE,MAAM,CAACS,cAAc,CAAC2E,KAAK,EAAE,iBAAiB,EAAE;QAC5CzE,GAAG,EAAE,SAAS0E,eAAeA,CAAA,EAAmB;UAC5C,OAAO,IAAI,CAACC,CAAC,CACRC,IAAI,CACD,IAAArC,SAAG,EAAEP,UAAsB,IAAK3C,MAAM,CAACwF,OAAO,CAC1C7C,UAAU,CAAC8C,MAAM,CAAC,IAAI,CAAC,CAAC/D,YAC5B,CAAC,CAAC,EACF,IAAAwB,SAAG,EAAEsC,OAAwB,IAAK;YAC9B,OAAOA,OAAO,CACTtC,GAAG,CAAC,CAAC,CAACpC,EAAE,EAAE4B,cAAc,CAAgB,KAAK;cAC1C,OAAOD,yBAAyB,CAC5B3B,EAAE,EACF4B,cAAc,EACd,IACJ,CAAC;YACL,CAAC,CAAC;UACV,CAAC,CACL,CAAC;QACT;MACJ,CAAC,CAAC;IACN;EACJ,CAAC;EACDgD,YAAY,EAAE,CAAC,CAAC;EAChBC,KAAK,EAAE;IACHvB,kBAAkB,EAAE;MAChBwB,KAAK,EAAExB;IACX,CAAC;IACDQ,mBAAmB,EAAE;MACjBgB,KAAK,EAAEhB;IACX;EACJ;AACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_COMPRESSIBLE_TYPES = void 0;
+exports.compressBlob = compressBlob;
+exports.decompressBlob = decompressBlob;
+exports.isCompressibleType = isCompressibleType;
+exports.wrappedAttachmentsCompressionStorage = wrappedAttachmentsCompressionStorage;
+var _pluginHelpers = require("../../plugin-helpers.js");
+var _index = require("../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.
+ */
+var DEFAULT_COMPRESSIBLE_TYPES = exports.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.
+ */
+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
+ */
+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.
+ */
+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
+ */
+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 = (0, _index.flatClone)(params.schema);
+      childSchema.attachments = (0, _index.flatClone)(childSchema.attachments);
+      delete (0, _index.ensureNotFalsy)(childSchema.attachments).compression;
+      var instance = await args.storage.createStorageInstance(Object.assign({}, params, {
+        schema: childSchema
+      }));
+      var wrappedInstance = (0, _pluginHelpers.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/cjs/plugins/attachments-compression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_pluginHelpers","require","_index","DEFAULT_COMPRESSIBLE_TYPES","exports","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","flatClone","ensureNotFalsy","instance","wrappedInstance","wrapRxStorageInstance","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/cjs/plugins/backup/file-util.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearFolder = clearFolder;
+exports.deleteFolder = deleteFolder;
+exports.documentFolder = documentFolder;
+exports.ensureFolderExists = ensureFolderExists;
+exports.getMeta = getMeta;
+exports.metaFileLocation = metaFileLocation;
+exports.prepareFolders = prepareFolders;
+exports.setMeta = setMeta;
+exports.writeJsonToFile = writeJsonToFile;
+exports.writeToFile = writeToFile;
+var fs = _interopRequireWildcard(require("node:fs"));
+var path = _interopRequireWildcard(require("node:path"));
+var _index = require("../../plugins/utils/index.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); }
+/**
+ * ensure that the given folder exists
+ */
+function ensureFolderExists(folderPath) {
+  if (!fs.existsSync(folderPath)) {
+    fs.mkdirSync(folderPath, {
+      recursive: true
+    });
+  }
+}
+
+/**
+ * deletes and recreates the folder
+ */
+function clearFolder(folderPath) {
+  deleteFolder(folderPath);
+  ensureFolderExists(folderPath);
+}
+function deleteFolder(folderPath) {
+  // only remove if exists to not raise warning
+  if (fs.existsSync(folderPath)) {
+    fs.rmdirSync(folderPath, {
+      recursive: true
+    });
+  }
+}
+function prepareFolders(database, options) {
+  ensureFolderExists(options.directory);
+  var metaLoc = metaFileLocation(options);
+  if (!fs.existsSync(metaLoc)) {
+    var currentTime = (0, _index.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));
+  });
+}
+async function writeToFile(location, data) {
+  if (typeof data !== 'string') {
+    data = await (0, _index.blobToString)(data);
+  }
+  return new Promise(function (res, rej) {
+    fs.writeFile(location, data, 'utf-8', err => {
+      if (err) {
+        rej(err);
+      } else {
+        res();
+      }
+    });
+  });
+}
+function writeJsonToFile(location, data) {
+  return writeToFile(location, JSON.stringify(data));
+}
+function metaFileLocation(options) {
+  return path.join(options.directory, 'backup_meta.json');
+}
+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);
+      }
+    });
+  });
+}
+function setMeta(options, meta) {
+  var loc = metaFileLocation(options);
+  return writeJsonToFile(loc, meta);
+}
+function documentFolder(options, docId) {
+  return path.join(options.directory, docId);
+}
+//# sourceMappingURL=file-util.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-util.js","names":["fs","_interopRequireWildcard","require","path","_index","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ensureFolderExists","folderPath","existsSync","mkdirSync","recursive","clearFolder","deleteFolder","rmdirSync","prepareFolders","database","options","directory","metaLoc","metaFileLocation","currentTime","now","metaData","createdAt","updatedAt","collectionStates","writeFileSync","JSON","stringify","keys","collections","forEach","collectionName","join","writeToFile","location","data","blobToString","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":"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","ignoreList":[]}