@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugins/electron/rx-storage-ipc-renderer.js

@@ -0,0 +1,31 @@
+import { Subject } from 'rxjs';
+import { getRxStorageRemote } from "../storage-remote/index.js";
+import { IPC_RENDERER_KEY_PREFIX } from "./electron-helper.js";
+import { PROMISE_RESOLVE_VOID } from "../utils/index.js";
+export function getRxStorageIpcRenderer(settings) {
+  var channelId = [IPC_RENDERER_KEY_PREFIX, settings.key].join('|');
+  var storage = getRxStorageRemote({
+    identifier: 'electron-ipc-renderer',
+    mode: settings.mode,
+    messageChannelCreator() {
+      var messages$ = new Subject();
+      var listener = (_event, message) => {
+        messages$.next(message);
+      };
+      settings.ipcRenderer.on(channelId, listener);
+      settings.ipcRenderer.postMessage(channelId, false);
+      return Promise.resolve({
+        messages$,
+        send(msg) {
+          settings.ipcRenderer.postMessage(channelId, msg);
+        },
+        close() {
+          settings.ipcRenderer.removeListener(channelId, listener);
+          return PROMISE_RESOLVE_VOID;
+        }
+      });
+    }
+  });
+  return storage;
+}
+//# sourceMappingURL=rx-storage-ipc-renderer.js.map

package/dist/esm/plugins/electron/rx-storage-ipc-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-storage-ipc-renderer.js","names":["Subject","getRxStorageRemote","IPC_RENDERER_KEY_PREFIX","PROMISE_RESOLVE_VOID","getRxStorageIpcRenderer","settings","channelId","key","join","storage","identifier","mode","messageChannelCreator","messages$","listener","_event","message","next","ipcRenderer","on","postMessage","Promise","resolve","send","msg","close","removeListener"],"sources":["../../../../src/plugins/electron/rx-storage-ipc-renderer.ts"],"sourcesContent":["import { Subject } from 'rxjs';\r\nimport {\r\n    getRxStorageRemote,\r\n    RxStorageRemote,\r\n    RxStorageRemoteSettings,\r\n    MessageFromRemote\r\n} from '../storage-remote/index.ts';\r\nimport {\r\n    IPC_RENDERER_KEY_PREFIX\r\n} from './electron-helper.ts';\r\nimport { PROMISE_RESOLVE_VOID } from '../utils/index.ts';\r\n\r\nexport type RxStorageIpcRendererSettings = {\r\n    /**\r\n     * Set the same key on both sides\r\n     * to ensure that messages do not get mixed\r\n     * up when you use more than one storage.\r\n     */\r\n    key: string;\r\n    ipcRenderer: any;\r\n    mode: RxStorageRemoteSettings['mode'];\r\n};\r\n\r\nexport type RxStorageIpcRenderer = RxStorageRemote;\r\nexport function getRxStorageIpcRenderer(\r\n    settings: RxStorageIpcRendererSettings\r\n): RxStorageIpcRenderer {\r\n    const channelId = [\r\n        IPC_RENDERER_KEY_PREFIX,\r\n        settings.key\r\n    ].join('|');\r\n\r\n    const storage = getRxStorageRemote({\r\n        identifier: 'electron-ipc-renderer',\r\n        mode: settings.mode,\r\n        messageChannelCreator() {\r\n            const messages$ = new Subject<MessageFromRemote>();\r\n            const listener = (_event: any, message: any) => {\r\n                messages$.next(message);\r\n            };\r\n            settings.ipcRenderer.on(channelId, listener);\r\n            settings.ipcRenderer.postMessage(\r\n                channelId,\r\n                false\r\n            );\r\n            return Promise.resolve({\r\n                messages$,\r\n                send(msg) {\r\n                    settings.ipcRenderer.postMessage(\r\n                        channelId,\r\n                        msg\r\n                    );\r\n                },\r\n                close() {\r\n                    settings.ipcRenderer.removeListener(channelId, listener);\r\n                    return PROMISE_RESOLVE_VOID;\r\n                }\r\n            });\r\n        },\r\n    });\r\n    return storage;\r\n}\r\n"],"mappings":"AAAA,SAASA,OAAO,QAAQ,MAAM;AAC9B,SACIC,kBAAkB,QAIf,4BAA4B;AACnC,SACIC,uBAAuB,QACpB,sBAAsB;AAC7B,SAASC,oBAAoB,QAAQ,mBAAmB;AAcxD,OAAO,SAASC,uBAAuBA,CACnCC,QAAsC,EAClB;EACpB,IAAMC,SAAS,GAAG,CACdJ,uBAAuB,EACvBG,QAAQ,CAACE,GAAG,CACf,CAACC,IAAI,CAAC,GAAG,CAAC;EAEX,IAAMC,OAAO,GAAGR,kBAAkB,CAAC;IAC/BS,UAAU,EAAE,uBAAuB;IACnCC,IAAI,EAAEN,QAAQ,CAACM,IAAI;IACnBC,qBAAqBA,CAAA,EAAG;MACpB,IAAMC,SAAS,GAAG,IAAIb,OAAO,CAAoB,CAAC;MAClD,IAAMc,QAAQ,GAAGA,CAACC,MAAW,EAAEC,OAAY,KAAK;QAC5CH,SAAS,CAACI,IAAI,CAACD,OAAO,CAAC;MAC3B,CAAC;MACDX,QAAQ,CAACa,WAAW,CAACC,EAAE,CAACb,SAAS,EAAEQ,QAAQ,CAAC;MAC5CT,QAAQ,CAACa,WAAW,CAACE,WAAW,CAC5Bd,SAAS,EACT,KACJ,CAAC;MACD,OAAOe,OAAO,CAACC,OAAO,CAAC;QACnBT,SAAS;QACTU,IAAIA,CAACC,GAAG,EAAE;UACNnB,QAAQ,CAACa,WAAW,CAACE,WAAW,CAC5Bd,SAAS,EACTkB,GACJ,CAAC;QACL,CAAC;QACDC,KAAKA,CAAA,EAAG;UACJpB,QAAQ,CAACa,WAAW,CAACQ,cAAc,CAACpB,SAAS,EAAEQ,QAAQ,CAAC;UACxD,OAAOX,oBAAoB;QAC/B;MACJ,CAAC,CAAC;IACN;EACJ,CAAC,CAAC;EACF,OAAOM,OAAO;AAClB","ignoreList":[]}

package/dist/esm/plugins/encryption-crypto-js/index.js

@@ -0,0 +1,154 @@
+/**
+ * this plugin adds the encryption-capabilities to rxdb
+ * It's using crypto-js/aes for password-encryption
+ * @link https://github.com/brix/crypto-js
+ */
+import pkg from 'crypto-js';
+var {
+  AES,
+  enc: cryptoEnc
+} = pkg;
+import { wrapRxStorageInstance } from "../../plugin-helpers.js";
+import { newRxError, newRxTypeError } from "../../rx-error.js";
+import { hasEncryption } from "../../rx-storage-helper.js";
+import { arrayBufferToBase64, base64ToArrayBuffer, clone, ensureNotFalsy, flatClone, getProperty, setProperty } from "../../plugins/utils/index.js";
+export var MINIMUM_PASSWORD_LENGTH = 8;
+export function encryptString(value, password) {
+  var encrypted = AES.encrypt(value, password);
+  return encrypted.toString();
+}
+export function decryptString(cipherText, password) {
+  /**
+   * Trying to decrypt non-strings
+   * will cause no errors and will be hard to debug.
+   * So instead we do this check here.
+   */
+  if (typeof cipherText !== 'string') {
+    throw newRxError('SNH', {
+      args: {
+        cipherText
+      }
+    });
+  }
+  var decrypted = AES.decrypt(cipherText, password);
+  var ret = decrypted.toString(cryptoEnc.Utf8);
+  return ret;
+}
+export function wrappedKeyEncryptionCryptoJsStorage(args) {
+  return Object.assign({}, args.storage, {
+    async createStorageInstance(params) {
+      if (typeof params.password !== 'undefined') {
+        validatePassword(params.password);
+      }
+      if (!hasEncryption(params.schema)) {
+        var retInstance = await args.storage.createStorageInstance(params);
+        return retInstance;
+      }
+      if (!params.password) {
+        throw newRxError('EN3', {
+          database: params.databaseName,
+          collection: params.collectionName,
+          schema: params.schema
+        });
+      }
+      var password = params.password;
+      var schemaWithoutEncrypted = clone(params.schema);
+      delete schemaWithoutEncrypted.encrypted;
+      if (schemaWithoutEncrypted.attachments) {
+        schemaWithoutEncrypted.attachments.encrypted = false;
+      }
+
+      /**
+       * Encrypted data is always stored as string
+       * so we have to change the schema to have "type": "string"
+       * on encrypted fields.
+       */
+      ensureNotFalsy(params.schema.encrypted).forEach(key => {
+        schemaWithoutEncrypted.properties[key].type = 'string';
+        delete schemaWithoutEncrypted.properties[key].properties;
+      });
+      var instance = await args.storage.createStorageInstance(Object.assign({}, params, {
+        schema: schemaWithoutEncrypted
+      }));
+      async function modifyToStorage(docData) {
+        docData = cloneWithoutAttachments(docData);
+        ensureNotFalsy(params.schema.encrypted).forEach(path => {
+          var value = getProperty(docData, path);
+          if (typeof value === 'undefined') {
+            return;
+          }
+          var stringValue = JSON.stringify(value);
+          var encrypted = encryptString(stringValue, password);
+          setProperty(docData, path, encrypted);
+        });
+
+        // handle attachments
+        if (params.schema.attachments && params.schema.attachments.encrypted) {
+          var newAttachments = {};
+          await Promise.all(Object.entries(docData._attachments).map(async ([id, attachment]) => {
+            var useAttachment = flatClone(attachment);
+            if (useAttachment.data) {
+              var ab = await useAttachment.data.arrayBuffer();
+              var base64 = arrayBufferToBase64(ab);
+              var encrypted = encryptString(base64, password);
+              useAttachment.data = new Blob([encrypted], {
+                type: useAttachment.type
+              });
+            }
+            newAttachments[id] = useAttachment;
+          }));
+          docData._attachments = newAttachments;
+        }
+        return docData;
+      }
+      function modifyFromStorage(docData) {
+        docData = cloneWithoutAttachments(docData);
+        ensureNotFalsy(params.schema.encrypted).forEach(path => {
+          var value = getProperty(docData, path);
+          if (typeof value === 'undefined') {
+            return;
+          }
+          var decrypted = decryptString(value, password);
+          var decryptedParsed = JSON.parse(decrypted);
+          setProperty(docData, path, decryptedParsed);
+        });
+        return docData;
+      }
+      async function modifyAttachmentFromStorage(attachmentData) {
+        if (params.schema.attachments && params.schema.attachments.encrypted) {
+          var encryptedText = await attachmentData.text();
+          var decryptedBase64 = decryptString(encryptedText, password);
+          var ab = base64ToArrayBuffer(decryptedBase64);
+          return new Blob([ab], attachmentData.type ? {
+            type: attachmentData.type
+          } : undefined);
+        } else {
+          return attachmentData;
+        }
+      }
+      return wrapRxStorageInstance(params.schema, instance, modifyToStorage, modifyFromStorage, modifyAttachmentFromStorage);
+    }
+  });
+}
+function cloneWithoutAttachments(data) {
+  var attachments = data._attachments;
+  data = flatClone(data);
+  delete data._attachments;
+  data = clone(data);
+  data._attachments = attachments;
+  return data;
+}
+function validatePassword(password) {
+  if (typeof password !== 'string') {
+    throw newRxTypeError('EN1', {
+      password
+    });
+  }
+  if (password.length < MINIMUM_PASSWORD_LENGTH) {
+    throw newRxError('EN2', {
+      minPassLength: MINIMUM_PASSWORD_LENGTH,
+      password
+    });
+  }
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/plugins/encryption-crypto-js/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["pkg","AES","enc","cryptoEnc","wrapRxStorageInstance","newRxError","newRxTypeError","hasEncryption","arrayBufferToBase64","base64ToArrayBuffer","clone","ensureNotFalsy","flatClone","getProperty","setProperty","MINIMUM_PASSWORD_LENGTH","encryptString","value","password","encrypted","encrypt","toString","decryptString","cipherText","args","decrypted","decrypt","ret","Utf8","wrappedKeyEncryptionCryptoJsStorage","Object","assign","storage","createStorageInstance","params","validatePassword","schema","retInstance","database","databaseName","collection","collectionName","schemaWithoutEncrypted","attachments","forEach","key","properties","type","instance","modifyToStorage","docData","cloneWithoutAttachments","path","stringValue","JSON","stringify","newAttachments","Promise","all","entries","_attachments","map","id","attachment","useAttachment","data","ab","arrayBuffer","base64","Blob","modifyFromStorage","decryptedParsed","parse","modifyAttachmentFromStorage","attachmentData","encryptedText","text","decryptedBase64","undefined","length","minPassLength"],"sources":["../../../../src/plugins/encryption-crypto-js/index.ts"],"sourcesContent":["/**\r\n * this plugin adds the encryption-capabilities to rxdb\r\n * It's using crypto-js/aes for password-encryption\r\n * @link https://github.com/brix/crypto-js\r\n */\r\nimport pkg from 'crypto-js';\r\nconst { AES, enc: cryptoEnc } = pkg;\r\n\r\nimport { wrapRxStorageInstance } from '../../plugin-helpers.ts';\r\nimport { newRxError, newRxTypeError } from '../../rx-error.ts';\r\nimport { hasEncryption } from '../../rx-storage-helper.ts';\r\nimport type {\r\n    InternalStoreDocType,\r\n    RxAttachmentWriteData,\r\n    RxDocumentData,\r\n    RxDocumentWriteData,\r\n    RxJsonSchema,\r\n    RxStorage,\r\n    RxStorageInstanceCreationParams\r\n} from '../../types/index.d.ts';\r\nimport {\r\n    arrayBufferToBase64,\r\n    base64ToArrayBuffer,\r\n    clone,\r\n    ensureNotFalsy,\r\n    flatClone,\r\n    getProperty,\r\n    setProperty\r\n} from '../../plugins/utils/index.ts';\r\n\r\nexport const MINIMUM_PASSWORD_LENGTH: 8 = 8;\r\n\r\n\r\nexport function encryptString(value: string, password: string): string {\r\n    const encrypted = AES.encrypt(value, password);\r\n    return encrypted.toString();\r\n}\r\n\r\nexport function decryptString(cipherText: string, password: any): string {\r\n    /**\r\n     * Trying to decrypt non-strings\r\n     * will cause no errors and will be hard to debug.\r\n     * So instead we do this check here.\r\n     */\r\n    if (typeof cipherText !== 'string') {\r\n        throw newRxError('SNH', {\r\n            args: {\r\n                cipherText\r\n            }\r\n        });\r\n    }\r\n\r\n    const decrypted = AES.decrypt(cipherText, password);\r\n    const ret = decrypted.toString(cryptoEnc.Utf8);\r\n    return ret;\r\n}\r\n\r\nexport type InternalStorePasswordDocType = InternalStoreDocType<{\r\n    hash: string;\r\n}>;\r\n\r\nexport function wrappedKeyEncryptionCryptoJsStorage<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 (typeof params.password !== 'undefined') {\r\n                    validatePassword(params.password as any);\r\n                }\r\n\r\n                if (!hasEncryption(params.schema)) {\r\n                    const retInstance = await args.storage.createStorageInstance(params);\r\n                    return retInstance;\r\n                }\r\n\r\n                if (!params.password) {\r\n                    throw newRxError('EN3', {\r\n                        database: params.databaseName,\r\n                        collection: params.collectionName,\r\n                        schema: params.schema\r\n                    });\r\n                }\r\n                const password = params.password;\r\n\r\n                const schemaWithoutEncrypted: RxJsonSchema<RxDocumentData<RxDocType>> = clone(params.schema);\r\n                delete schemaWithoutEncrypted.encrypted;\r\n                if (schemaWithoutEncrypted.attachments) {\r\n                    schemaWithoutEncrypted.attachments.encrypted = false;\r\n                }\r\n\r\n                /**\r\n                 * Encrypted data is always stored as string\r\n                 * so we have to change the schema to have \"type\": \"string\"\r\n                 * on encrypted fields.\r\n                 */\r\n                ensureNotFalsy(params.schema.encrypted).forEach(key => {\r\n                    (schemaWithoutEncrypted as any).properties[key].type = 'string';\r\n                    delete (schemaWithoutEncrypted as any).properties[key].properties;\r\n                });\r\n\r\n                const instance = await args.storage.createStorageInstance(\r\n                    Object.assign(\r\n                        {},\r\n                        params,\r\n                        {\r\n                            schema: schemaWithoutEncrypted\r\n                        }\r\n                    )\r\n                );\r\n\r\n                async function modifyToStorage(docData: RxDocumentWriteData<RxDocType>) {\r\n                    docData = cloneWithoutAttachments(docData);\r\n                    ensureNotFalsy(params.schema.encrypted)\r\n                        .forEach(path => {\r\n                            const value = getProperty(docData, path);\r\n                            if (typeof value === 'undefined') {\r\n                                return;\r\n                            }\r\n\r\n                            const stringValue = JSON.stringify(value);\r\n                            const encrypted = encryptString(stringValue, password);\r\n                            setProperty(docData, path, encrypted);\r\n                        });\r\n\r\n                    // handle attachments\r\n                    if (\r\n                        params.schema.attachments &&\r\n                        params.schema.attachments.encrypted\r\n                    ) {\r\n                        const newAttachments: typeof docData._attachments = {};\r\n                        await Promise.all(\r\n                            Object.entries(docData._attachments).map(async ([id, attachment]) => {\r\n                                const useAttachment: RxAttachmentWriteData = flatClone(attachment) as any;\r\n                                if (useAttachment.data) {\r\n                                    const ab = await useAttachment.data.arrayBuffer();\r\n                                    const base64 = arrayBufferToBase64(ab);\r\n                                    const encrypted = encryptString(base64, password);\r\n                                    useAttachment.data = new Blob([encrypted], { type: useAttachment.type });\r\n                                }\r\n                                newAttachments[id] = useAttachment;\r\n                            })\r\n                        );\r\n                        docData._attachments = newAttachments;\r\n                    }\r\n                    return docData;\r\n                }\r\n                function modifyFromStorage(docData: RxDocumentData<any>): Promise<RxDocumentData<RxDocType>> {\r\n                    docData = cloneWithoutAttachments(docData);\r\n                    ensureNotFalsy(params.schema.encrypted)\r\n                        .forEach(path => {\r\n                            const value = getProperty(docData, path);\r\n                            if (typeof value === 'undefined') {\r\n                                return;\r\n                            }\r\n                            const decrypted = decryptString(value, password);\r\n                            const decryptedParsed = JSON.parse(decrypted);\r\n                            setProperty(docData, path, decryptedParsed);\r\n                        });\r\n                    return docData;\r\n                }\r\n\r\n                async function modifyAttachmentFromStorage(attachmentData: Blob): Promise<Blob> {\r\n                    if (\r\n                        params.schema.attachments &&\r\n                        params.schema.attachments.encrypted\r\n                    ) {\r\n                        const encryptedText = await attachmentData.text();\r\n                        const decryptedBase64 = decryptString(encryptedText, password);\r\n                        const ab = base64ToArrayBuffer(decryptedBase64);\r\n                        return new Blob([ab], attachmentData.type ? { type: attachmentData.type } : undefined);\r\n                    } else {\r\n                        return attachmentData;\r\n                    }\r\n                }\r\n\r\n                return wrapRxStorageInstance(\r\n                    params.schema,\r\n                    instance,\r\n                    modifyToStorage,\r\n                    modifyFromStorage,\r\n                    modifyAttachmentFromStorage\r\n                );\r\n            }\r\n        }\r\n    );\r\n}\r\n\r\n\r\n\r\n\r\n\r\nfunction cloneWithoutAttachments<T>(data: RxDocumentWriteData<T>): RxDocumentData<T> {\r\n    const attachments = data._attachments;\r\n    data = flatClone(data);\r\n    delete (data as any)._attachments;\r\n    data = clone(data);\r\n    data._attachments = attachments;\r\n    return data as any;\r\n}\r\n\r\nfunction validatePassword(password: string) {\r\n    if (typeof password !== 'string') {\r\n        throw newRxTypeError('EN1', {\r\n            password\r\n        });\r\n    }\r\n    if (password.length < MINIMUM_PASSWORD_LENGTH) {\r\n        throw newRxError('EN2', {\r\n            minPassLength: MINIMUM_PASSWORD_LENGTH,\r\n            password\r\n        });\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,55 @@
+export function setFlutterRxDatabaseConnector(createDB) {
+  process.init = async databaseName => {
+    var db = await createDB(databaseName);
+    db.eventBulks$.subscribe(eventBulk => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      sendRxDBEvent(JSON.stringify(eventBulk));
+    });
+    process.db = db;
+    var collections = [];
+    Object.entries(db.collections).forEach(([collectionName, collection]) => {
+      collections.push({
+        name: collectionName,
+        primaryKey: collection.schema.primaryPath
+      });
+    });
+    return {
+      databaseName,
+      collections
+    };
+  };
+}
+
+/**
+ * Create a simple lokijs adapter so that we can persist string via flutter
+ * @link https://github.com/techfort/LokiJS/blob/master/tutorials/Persistence%20Adapters.md#creating-your-own-basic-persistence-adapter
+ */
+export function getLokijsAdapterFlutter() {
+  var ret = {
+    async loadDatabase(databaseName, callback) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      var serializedDb = await readKeyValue(databaseName);
+      var success = true;
+      if (success) {
+        callback(serializedDb);
+      } else {
+        callback(new Error('There was a problem loading the database'));
+      }
+    },
+    async saveDatabase(databaseName, dbstring, callback) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      await persistKeyValue(databaseName, dbstring);
+      var success = true; // make your own determinations
+      if (success) {
+        callback(null);
+      } else {
+        callback(new Error('An error was encountered loading " + dbname + " database.'));
+      }
+    }
+  };
+  return ret;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["setFlutterRxDatabaseConnector","createDB","process","init","databaseName","db","eventBulks$","subscribe","eventBulk","sendRxDBEvent","JSON","stringify","collections","Object","entries","forEach","collectionName","collection","push","name","primaryKey","schema","primaryPath","getLokijsAdapterFlutter","ret","loadDatabase","callback","serializedDb","readKeyValue","success","Error","saveDatabase","dbstring","persistKeyValue"],"sources":["../../../../src/plugins/flutter/index.ts"],"sourcesContent":["import type {\r\n    RxChangeEventBulk,\r\n    RxDatabase\r\n} from '../../types/index.d.ts';\r\n\r\nexport type CreateRxDatabaseFunctionType = (databaseName: string) => Promise<RxDatabase>;\r\n\r\nexport function setFlutterRxDatabaseConnector(\r\n    createDB: CreateRxDatabaseFunctionType\r\n) {\r\n    (process as any).init = async (databaseName: string) => {\r\n        const db = await createDB(databaseName);\r\n        db.eventBulks$.subscribe((eventBulk: RxChangeEventBulk<any>) => {\r\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\r\n            // @ts-ignore\r\n            sendRxDBEvent(JSON.stringify(eventBulk));\r\n        });\r\n        (process as any).db = db;\r\n        const collections: { name: string; primaryKey: string; }[] = [];\r\n        Object.entries(db.collections).forEach(([collectionName, collection]) => {\r\n            collections.push({\r\n                name: collectionName,\r\n                primaryKey: collection.schema.primaryPath\r\n            });\r\n        });\r\n        return {\r\n            databaseName,\r\n            collections\r\n        };\r\n    };\r\n}\r\n\r\n/**\r\n * Create a simple lokijs adapter so that we can persist string via flutter\r\n * @link https://github.com/techfort/LokiJS/blob/master/tutorials/Persistence%20Adapters.md#creating-your-own-basic-persistence-adapter\r\n */\r\nexport function getLokijsAdapterFlutter() {\r\n    const ret = {\r\n        async loadDatabase(databaseName: string, callback: (v: string | Error) => {}) {\r\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\r\n            // @ts-ignore\r\n            const serializedDb: string = await readKeyValue(databaseName);\r\n\r\n            const success = true;\r\n            if (success) {\r\n                callback(serializedDb);\r\n            } else {\r\n                callback(new Error('There was a problem loading the database'));\r\n            }\r\n        },\r\n        async saveDatabase(databaseName: string, dbstring: string, callback: (v: string | Error | null) => {}) {\r\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\r\n            // @ts-ignore\r\n            await persistKeyValue(databaseName, dbstring);\r\n\r\n            const success = true;  // make your own determinations\r\n            if (success) {\r\n                callback(null);\r\n            } else {\r\n                callback(new Error('An error was encountered loading \" + dbname + \" database.'));\r\n            }\r\n        }\r\n    };\r\n    return ret;\r\n}\r\n"],"mappings":"AAOA,OAAO,SAASA,6BAA6BA,CACzCC,QAAsC,EACxC;EACGC,OAAO,CAASC,IAAI,GAAG,MAAOC,YAAoB,IAAK;IACpD,IAAMC,EAAE,GAAG,MAAMJ,QAAQ,CAACG,YAAY,CAAC;IACvCC,EAAE,CAACC,WAAW,CAACC,SAAS,CAAEC,SAAiC,IAAK;MAC5D;MACA;MACAC,aAAa,CAACC,IAAI,CAACC,SAAS,CAACH,SAAS,CAAC,CAAC;IAC5C,CAAC,CAAC;IACDN,OAAO,CAASG,EAAE,GAAGA,EAAE;IACxB,IAAMO,WAAoD,GAAG,EAAE;IAC/DC,MAAM,CAACC,OAAO,CAACT,EAAE,CAACO,WAAW,CAAC,CAACG,OAAO,CAAC,CAAC,CAACC,cAAc,EAAEC,UAAU,CAAC,KAAK;MACrEL,WAAW,CAACM,IAAI,CAAC;QACbC,IAAI,EAAEH,cAAc;QACpBI,UAAU,EAAEH,UAAU,CAACI,MAAM,CAACC;MAClC,CAAC,CAAC;IACN,CAAC,CAAC;IACF,OAAO;MACHlB,YAAY;MACZQ;IACJ,CAAC;EACL,CAAC;AACL;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASW,uBAAuBA,CAAA,EAAG;EACtC,IAAMC,GAAG,GAAG;IACR,MAAMC,YAAYA,CAACrB,YAAoB,EAAEsB,QAAmC,EAAE;MAC1E;MACA;MACA,IAAMC,YAAoB,GAAG,MAAMC,YAAY,CAACxB,YAAY,CAAC;MAE7D,IAAMyB,OAAO,GAAG,IAAI;MACpB,IAAIA,OAAO,EAAE;QACTH,QAAQ,CAACC,YAAY,CAAC;MAC1B,CAAC,MAAM;QACHD,QAAQ,CAAC,IAAII,KAAK,CAAC,0CAA0C,CAAC,CAAC;MACnE;IACJ,CAAC;IACD,MAAMC,YAAYA,CAAC3B,YAAoB,EAAE4B,QAAgB,EAAEN,QAA0C,EAAE;MACnG;MACA;MACA,MAAMO,eAAe,CAAC7B,YAAY,EAAE4B,QAAQ,CAAC;MAE7C,IAAMH,OAAO,GAAG,IAAI,CAAC,CAAE;MACvB,IAAIA,OAAO,EAAE;QACTH,QAAQ,CAAC,IAAI,CAAC;MAClB,CAAC,MAAM;QACHA,QAAQ,CAAC,IAAII,KAAK,CAAC,2DAA2D,CAAC,CAAC;MACpF;IACJ;EACJ,CAAC;EACD,OAAON,GAAG;AACd","ignoreList":[]}

package/dist/esm/plugins/json-dump/index.js

@@ -0,0 +1,87 @@
+/**
+ * this plugin adds the json export/import capabilities to RxDB
+ */
+import { createRxQuery, queryCollection, _getDefaultQuery } from "../../rx-query.js";
+import { newRxError } from "../../rx-error.js";
+import { flatClone, getDefaultRevision, now } from "../../plugins/utils/index.js";
+function dumpRxDatabase(collections) {
+  var json = {
+    name: this.name,
+    instanceToken: this.token,
+    collections: []
+  };
+  var useCollections = Object.keys(this.collections).filter(colName => !collections || collections.includes(colName)).filter(colName => colName.charAt(0) !== '_').map(colName => this.collections[colName]);
+  return Promise.all(useCollections.map(col => col.exportJSON())).then(cols => {
+    json.collections = cols;
+    return json;
+  });
+}
+var importDumpRxDatabase = function (dump) {
+  /**
+   * collections must be created before the import
+   * because we do not know about the other collection-settings here
+   */
+  var missingCollections = dump.collections.filter(col => !this.collections[col.name]).map(col => col.name);
+  if (missingCollections.length > 0) {
+    throw newRxError('JD1', {
+      missingCollections
+    });
+  }
+  return Promise.all(dump.collections.map(colDump => this.collections[colDump.name].importJSON(colDump)));
+};
+var dumpRxCollection = async function () {
+  var json = {
+    name: this.name,
+    schemaHash: await this.schema.hash,
+    docs: []
+  };
+  var query = createRxQuery('find', _getDefaultQuery(), this);
+  return queryCollection(query).then(result => {
+    json.docs = result.docs.map(docData => {
+      docData = flatClone(docData);
+      delete docData._rev;
+      delete docData._attachments;
+      return docData;
+    });
+    return json;
+  });
+};
+async function importDumpRxCollection(exportedJSON) {
+  // check schemaHash
+  if (exportedJSON.schemaHash !== (await this.schema.hash)) {
+    throw newRxError('JD2', {
+      schemaHash: exportedJSON.schemaHash,
+      own: this.schema.hash
+    });
+  }
+  var docs = exportedJSON.docs;
+  return this.storageInstance.bulkWrite(docs.map(docData => {
+    var document = Object.assign({}, docData, {
+      _meta: {
+        lwt: now()
+      },
+      _rev: getDefaultRevision(),
+      _attachments: {},
+      _deleted: false
+    });
+    return {
+      document
+    };
+  }), 'json-dump-import');
+}
+export var RxDBJsonDumpPlugin = {
+  name: 'json-dump',
+  rxdb: true,
+  prototypes: {
+    RxDatabase: proto => {
+      proto.exportJSON = dumpRxDatabase;
+      proto.importJSON = importDumpRxDatabase;
+    },
+    RxCollection: proto => {
+      proto.exportJSON = dumpRxCollection;
+      proto.importJSON = importDumpRxCollection;
+    }
+  },
+  overwritable: {}
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/plugins/json-dump/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createRxQuery","queryCollection","_getDefaultQuery","newRxError","flatClone","getDefaultRevision","now","dumpRxDatabase","collections","json","name","instanceToken","token","useCollections","Object","keys","filter","colName","includes","charAt","map","Promise","all","col","exportJSON","then","cols","importDumpRxDatabase","dump","missingCollections","length","colDump","importJSON","dumpRxCollection","schemaHash","schema","hash","docs","query","result","docData","_rev","_attachments","importDumpRxCollection","exportedJSON","own","storageInstance","bulkWrite","document","assign","_meta","lwt","_deleted","RxDBJsonDumpPlugin","rxdb","prototypes","RxDatabase","proto","RxCollection","overwritable"],"sources":["../../../../src/plugins/json-dump/index.ts"],"sourcesContent":["/**\r\n * this plugin adds the json export/import capabilities to RxDB\r\n */\r\nimport {\r\n    createRxQuery,\r\n    queryCollection,\r\n    _getDefaultQuery\r\n} from '../../rx-query.ts';\r\nimport {\r\n    newRxError\r\n} from '../../rx-error.ts';\r\nimport type {\r\n    RxDatabase,\r\n    RxCollection,\r\n    RxPlugin,\r\n    RxDocumentData\r\n} from '../../types/index.d.ts';\r\nimport {\r\n    flatClone,\r\n    getDefaultRevision,\r\n    now\r\n} from '../../plugins/utils/index.ts';\r\n\r\nfunction dumpRxDatabase(\r\n    this: RxDatabase,\r\n    collections?: string[]\r\n): Promise<any> {\r\n    const json: any = {\r\n        name: this.name,\r\n        instanceToken: this.token,\r\n        collections: []\r\n    };\r\n\r\n    const useCollections = Object.keys(this.collections)\r\n        .filter(colName => !collections || collections.includes(colName))\r\n        .filter(colName => colName.charAt(0) !== '_')\r\n        .map(colName => this.collections[colName]);\r\n\r\n    return Promise.all(\r\n        useCollections\r\n            .map(col => col.exportJSON())\r\n    ).then(cols => {\r\n        json.collections = cols;\r\n        return json;\r\n    });\r\n}\r\n\r\nconst importDumpRxDatabase = function (\r\n    this: RxDatabase,\r\n    dump: any\r\n) {\r\n    /**\r\n     * collections must be created before the import\r\n     * because we do not know about the other collection-settings here\r\n     */\r\n    const missingCollections = dump.collections\r\n        .filter((col: any) => !this.collections[col.name])\r\n        .map((col: any) => col.name);\r\n    if (missingCollections.length > 0) {\r\n        throw newRxError('JD1', {\r\n            missingCollections\r\n        });\r\n    }\r\n\r\n    return Promise.all(\r\n        dump.collections\r\n            .map((colDump: any) => this.collections[colDump.name].importJSON(colDump))\r\n    );\r\n};\r\n\r\nconst dumpRxCollection = async function (\r\n    this: RxCollection\r\n) {\r\n    const json: any = {\r\n        name: this.name,\r\n        schemaHash: await this.schema.hash,\r\n        docs: []\r\n    };\r\n\r\n    const query = createRxQuery(\r\n        'find',\r\n        _getDefaultQuery(),\r\n        this\r\n    );\r\n    return queryCollection(query)\r\n        .then((result) => {\r\n            json.docs = result.docs.map((docData: any) => {\r\n                docData = flatClone(docData);\r\n                delete docData._rev;\r\n                delete docData._attachments;\r\n                return docData;\r\n            });\r\n            return json;\r\n        });\r\n};\r\n\r\nasync function importDumpRxCollection<RxDocType>(\r\n    this: RxCollection<RxDocType>,\r\n    exportedJSON: any\r\n): Promise<any> {\r\n    // check schemaHash\r\n    if (exportedJSON.schemaHash !== await this.schema.hash) {\r\n        throw newRxError('JD2', {\r\n            schemaHash: exportedJSON.schemaHash,\r\n            own: this.schema.hash\r\n        });\r\n    }\r\n\r\n    const docs: RxDocType[] = exportedJSON.docs;\r\n    return this.storageInstance.bulkWrite(\r\n        docs.map(docData => {\r\n            const document: RxDocumentData<RxDocType> = Object.assign(\r\n                {},\r\n                docData,\r\n                {\r\n                    _meta: {\r\n                        lwt: now()\r\n                    },\r\n                    _rev: getDefaultRevision(),\r\n                    _attachments: {},\r\n                    _deleted: false\r\n                }\r\n            );\r\n            return {\r\n                document\r\n            };\r\n        }),\r\n        'json-dump-import'\r\n    );\r\n}\r\n\r\nexport const RxDBJsonDumpPlugin: RxPlugin = {\r\n    name: 'json-dump',\r\n    rxdb: true,\r\n    prototypes: {\r\n        RxDatabase: (proto: any) => {\r\n            proto.exportJSON = dumpRxDatabase;\r\n            proto.importJSON = importDumpRxDatabase;\r\n        },\r\n        RxCollection: (proto: any) => {\r\n            proto.exportJSON = dumpRxCollection;\r\n            proto.importJSON = importDumpRxCollection;\r\n        }\r\n    },\r\n    overwritable: {}\r\n};\r\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,127 @@
+/**
+ * this plugin adds the keycompression-capabilities to rxdb
+ * if you don't use this, ensure that you set disableKeyCompression to false in your schema
+ */
+
+import { createCompressionTable, compressObject, decompressObject, compressedPath, DEFAULT_COMPRESSION_FLAG, createCompressedJsonSchema, compressQuery } from 'jsonschema-key-compression';
+import { overwritable } from "../../overwritable.js";
+import { wrapRxStorageInstance } from "../../plugin-helpers.js";
+import { getPrimaryFieldOfPrimaryKey } from "../../rx-schema-helper.js";
+import { flatCloneDocWithMeta } from "../../rx-storage-helper.js";
+import { flatClone, getFromMapOrCreate, isMaybeReadonlyArray } from "../../plugins/utils/index.js";
+import { prepareQuery } from "../../rx-query-helper.js";
+/**
+ * Cache the compression table and the compressed schema
+ * by the storage instance for better performance.
+ */
+var COMPRESSION_STATE_BY_SCHEMA = new WeakMap();
+export function getCompressionStateByRxJsonSchema(schema) {
+  /**
+   * Because we cache the state by the JsonSchema,
+   * it must be assured that the given schema object
+   * is never mutated.
+   */
+  overwritable.deepFreezeWhenDevMode(schema);
+  return getFromMapOrCreate(COMPRESSION_STATE_BY_SCHEMA, schema, () => {
+    var compressionSchema = flatClone(schema);
+    delete compressionSchema.primaryKey;
+    var table = createCompressionTable(compressionSchema, DEFAULT_COMPRESSION_FLAG, [
+    /**
+     * Do not compress the primary field
+     * for easier debugging.
+     */
+    getPrimaryFieldOfPrimaryKey(schema.primaryKey), '_rev', '_attachments', '_deleted', '_meta']);
+    delete compressionSchema.primaryKey;
+    var compressedSchema = createCompressedJsonSchema(table, compressionSchema);
+
+    // also compress primary key
+    if (typeof schema.primaryKey !== 'string') {
+      var composedPrimary = schema.primaryKey;
+      var newComposedPrimary = {
+        key: compressedPath(table, composedPrimary.key),
+        fields: composedPrimary.fields.map(field => compressedPath(table, field)),
+        separator: composedPrimary.separator
+      };
+      compressedSchema.primaryKey = newComposedPrimary;
+    } else {
+      compressedSchema.primaryKey = compressedPath(table, schema.primaryKey);
+    }
+
+    /**
+     * the key compression module does not know about indexes
+     * in the schema, so we have to also compress them here.
+     */
+    if (schema.indexes) {
+      var newIndexes = schema.indexes.map(idx => {
+        if (isMaybeReadonlyArray(idx)) {
+          return idx.map(subIdx => compressedPath(table, subIdx));
+        } else {
+          return compressedPath(table, idx);
+        }
+      });
+      compressedSchema.indexes = newIndexes;
+    }
+    var compressionState = {
+      table,
+      schema,
+      compressedSchema
+    };
+    return compressionState;
+  });
+}
+export function wrappedKeyCompressionStorage(args) {
+  return Object.assign({}, args.storage, {
+    async createStorageInstance(params) {
+      if (!params.schema.keyCompression) {
+        return args.storage.createStorageInstance(params);
+      }
+      var compressionState = getCompressionStateByRxJsonSchema(params.schema);
+      function modifyToStorage(docData) {
+        var ret = compressDocumentData(compressionState, docData);
+        return ret;
+      }
+      function modifyFromStorage(docData) {
+        return decompressDocumentData(compressionState, docData);
+      }
+
+      /**
+       * Because this wrapper resolves the key-compression,
+       * we can set the flag to false
+       * which allows underlying storages to detect wrong configurations
+       * like when keyCompression is set to false but no key-compression module is used.
+       */
+      var childSchema = flatClone(compressionState.compressedSchema);
+      childSchema.keyCompression = false;
+      var instance = await args.storage.createStorageInstance(Object.assign({}, params, {
+        schema: childSchema
+      }));
+      var wrappedInstance = wrapRxStorageInstance(params.schema, instance, modifyToStorage, modifyFromStorage);
+      var overwriteMethods = ['query', 'count'];
+      overwriteMethods.forEach(methodName => {
+        var methodBefore = wrappedInstance[methodName].bind(wrappedInstance);
+        wrappedInstance[methodName] = async preparedQuery => {
+          var compressedQuery = compressQuery(compressionState.table, preparedQuery.query);
+          var compressedPreparedQuery = prepareQuery(compressionState.compressedSchema, compressedQuery);
+          return methodBefore(compressedPreparedQuery);
+        };
+      });
+      return wrappedInstance;
+    }
+  });
+}
+export function compressDocumentData(compressionState, docData) {
+  /**
+   * Do not send attachments to compressObject()
+   * because it will deep clone which does not work on Blob or Buffer.
+   */
+  docData = flatCloneDocWithMeta(docData);
+  var attachments = docData._attachments;
+  delete docData._attachments;
+  docData = compressObject(compressionState.table, docData);
+  docData._attachments = attachments;
+  return docData;
+}
+export function decompressDocumentData(compressionState, docData) {
+  return decompressObject(compressionState.table, docData);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createCompressionTable","compressObject","decompressObject","compressedPath","DEFAULT_COMPRESSION_FLAG","createCompressedJsonSchema","compressQuery","overwritable","wrapRxStorageInstance","getPrimaryFieldOfPrimaryKey","flatCloneDocWithMeta","flatClone","getFromMapOrCreate","isMaybeReadonlyArray","prepareQuery","COMPRESSION_STATE_BY_SCHEMA","WeakMap","getCompressionStateByRxJsonSchema","schema","deepFreezeWhenDevMode","compressionSchema","primaryKey","table","compressedSchema","composedPrimary","newComposedPrimary","key","fields","map","field","separator","indexes","newIndexes","idx","subIdx","compressionState","wrappedKeyCompressionStorage","args","Object","assign","storage","createStorageInstance","params","keyCompression","modifyToStorage","docData","ret","compressDocumentData","modifyFromStorage","decompressDocumentData","childSchema","instance","wrappedInstance","overwriteMethods","forEach","methodName","methodBefore","bind","preparedQuery","compressedQuery","query","compressedPreparedQuery","attachments","_attachments"],"sources":["../../../../src/plugins/key-compression/index.ts"],"sourcesContent":["/**\r\n * this plugin adds the keycompression-capabilities to rxdb\r\n * if you don't use this, ensure that you set disableKeyCompression to false in your schema\r\n */\r\n\r\nimport {\r\n    createCompressionTable,\r\n    CompressionTable,\r\n    JsonSchema as KeyCompressionJsonSchema,\r\n    compressObject,\r\n    decompressObject,\r\n    compressedPath,\r\n    DEFAULT_COMPRESSION_FLAG,\r\n    createCompressedJsonSchema,\r\n    compressQuery\r\n} from 'jsonschema-key-compression';\r\nimport {\r\n    overwritable\r\n} from '../../overwritable.ts';\r\nimport { wrapRxStorageInstance } from '../../plugin-helpers.ts';\r\nimport { getPrimaryFieldOfPrimaryKey } from '../../rx-schema-helper.ts';\r\nimport { flatCloneDocWithMeta } from '../../rx-storage-helper.ts';\r\n\r\nimport type {\r\n    RxJsonSchema,\r\n    CompositePrimaryKey,\r\n    RxStorage,\r\n    RxStorageInstanceCreationParams,\r\n    RxDocumentData,\r\n    FilledMangoQuery,\r\n    PreparedQuery,\r\n    RxDocumentWriteData\r\n} from '../../types/index.d.ts';\r\nimport {\r\n    clone,\r\n    flatClone,\r\n    getFromMapOrCreate,\r\n    isMaybeReadonlyArray\r\n} from '../../plugins/utils/index.ts';\r\nimport { prepareQuery } from '../../rx-query-helper.ts';\r\n\r\ndeclare type CompressionState = {\r\n    table: CompressionTable;\r\n    schema: RxJsonSchema<any>;\r\n    compressedSchema: RxJsonSchema<any>;\r\n};\r\n\r\n/**\r\n * Cache the compression table and the compressed schema\r\n * by the storage instance for better performance.\r\n */\r\nconst COMPRESSION_STATE_BY_SCHEMA: WeakMap<\r\n    RxJsonSchema<any>,\r\n    CompressionState\r\n> = new WeakMap();\r\n\r\n\r\nexport function getCompressionStateByRxJsonSchema(\r\n    schema: RxJsonSchema<any>\r\n): CompressionState {\r\n    /**\r\n     * Because we cache the state by the JsonSchema,\r\n     * it must be assured that the given schema object\r\n     * is never mutated.\r\n     */\r\n    overwritable.deepFreezeWhenDevMode(schema);\r\n\r\n    return getFromMapOrCreate(\r\n        COMPRESSION_STATE_BY_SCHEMA,\r\n        schema,\r\n        () => {\r\n            const compressionSchema: KeyCompressionJsonSchema = flatClone(schema) as any;\r\n            delete (compressionSchema as any).primaryKey;\r\n\r\n            const table = createCompressionTable(\r\n                compressionSchema,\r\n                DEFAULT_COMPRESSION_FLAG,\r\n                [\r\n                    /**\r\n                     * Do not compress the primary field\r\n                     * for easier debugging.\r\n                     */\r\n                    getPrimaryFieldOfPrimaryKey(schema.primaryKey),\r\n                    '_rev',\r\n                    '_attachments',\r\n                    '_deleted',\r\n                    '_meta'\r\n                ]\r\n            );\r\n\r\n            delete (compressionSchema as any).primaryKey;\r\n            const compressedSchema: RxJsonSchema<any> = createCompressedJsonSchema(\r\n                table,\r\n                compressionSchema\r\n            ) as RxJsonSchema<any>;\r\n\r\n            // also compress primary key\r\n            if (typeof schema.primaryKey !== 'string') {\r\n                const composedPrimary: CompositePrimaryKey<any> = schema.primaryKey;\r\n                const newComposedPrimary: CompositePrimaryKey<any> = {\r\n                    key: compressedPath(table, composedPrimary.key as string),\r\n                    fields: composedPrimary.fields.map(field => compressedPath(table, field as string)),\r\n                    separator: composedPrimary.separator\r\n                };\r\n                compressedSchema.primaryKey = newComposedPrimary;\r\n            } else {\r\n                compressedSchema.primaryKey = compressedPath(table, schema.primaryKey);\r\n            }\r\n\r\n            /**\r\n             * the key compression module does not know about indexes\r\n             * in the schema, so we have to also compress them here.\r\n             */\r\n            if (schema.indexes) {\r\n                const newIndexes = schema.indexes.map(idx => {\r\n                    if (isMaybeReadonlyArray(idx)) {\r\n                        return idx.map(subIdx => compressedPath(table, subIdx));\r\n                    } else {\r\n                        return compressedPath(table, idx);\r\n                    }\r\n                });\r\n                compressedSchema.indexes = newIndexes;\r\n            }\r\n\r\n            const compressionState = {\r\n                table,\r\n                schema,\r\n                compressedSchema\r\n            };\r\n            return compressionState;\r\n        }\r\n    );\r\n}\r\n\r\nexport function wrappedKeyCompressionStorage<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 (!params.schema.keyCompression) {\r\n                    return args.storage.createStorageInstance(params);\r\n                }\r\n\r\n                const compressionState = getCompressionStateByRxJsonSchema(params.schema);\r\n                function modifyToStorage(docData: RxDocumentWriteData<RxDocType>) {\r\n                    const ret = compressDocumentData(compressionState, docData);\r\n                    return ret;\r\n                }\r\n                function modifyFromStorage(docData: RxDocumentData<any>): Promise<RxDocumentData<RxDocType>> {\r\n                    return decompressDocumentData(compressionState, docData);\r\n                }\r\n\r\n                /**\r\n                 * Because this wrapper resolves the key-compression,\r\n                 * we can set the flag to false\r\n                 * which allows underlying storages to detect wrong configurations\r\n                 * like when keyCompression is set to false but no key-compression module is used.\r\n                 */\r\n                const childSchema = flatClone(compressionState.compressedSchema);\r\n                childSchema.keyCompression = false;\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                    modifyFromStorage\r\n                );\r\n\r\n\r\n                const overwriteMethods = ['query', 'count'] as const;\r\n                overwriteMethods.forEach(methodName => {\r\n                    const methodBefore = wrappedInstance[methodName].bind(wrappedInstance);\r\n                    (wrappedInstance as any)[methodName] = async (preparedQuery: PreparedQuery<RxDocType>) => {\r\n                        const compressedQuery: FilledMangoQuery<RxDocType> = compressQuery(\r\n                            compressionState.table,\r\n                            preparedQuery.query as any\r\n                        ) as any;\r\n\r\n                        const compressedPreparedQuery = prepareQuery(\r\n                            compressionState.compressedSchema,\r\n                            compressedQuery\r\n                        );\r\n                        return methodBefore(compressedPreparedQuery);\r\n                    }\r\n                });\r\n\r\n                return wrappedInstance;\r\n            }\r\n        }\r\n    );\r\n}\r\n\r\nexport function compressDocumentData(\r\n    compressionState: CompressionState,\r\n    docData: RxDocumentData<any>\r\n): RxDocumentData<any> {\r\n    /**\r\n     * Do not send attachments to compressObject()\r\n     * because it will deep clone which does not work on Blob or Buffer.\r\n     */\r\n    docData = flatCloneDocWithMeta(docData);\r\n    const attachments = docData._attachments;\r\n    delete docData._attachments;\r\n\r\n    docData = compressObject(\r\n        compressionState.table,\r\n        docData\r\n    );\r\n    docData._attachments = attachments;\r\n    return docData;\r\n}\r\n\r\nexport function decompressDocumentData(\r\n    compressionState: CompressionState,\r\n    docData: RxDocumentData<any>\r\n): RxDocumentData<any> {\r\n    return decompressObject(\r\n        compressionState.table,\r\n        docData\r\n    );\r\n}\r\n"],"mappings":"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","ignoreList":[]}