@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugin-helpers.js

@@ -0,0 +1,217 @@
+import { filter, mergeMap, tap } from 'rxjs/operators';
+import { getPrimaryFieldOfPrimaryKey } from "./rx-schema-helper.js";
+import { flatClone, getFromMapOrCreate, requestIdleCallbackIfAvailable } from "./plugins/utils/index.js";
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+
+/**
+ * Returns the validation errors.
+ * If document is fully valid, returns an empty array.
+ */
+
+/**
+ * cache the validators by the schema string
+ * so we can reuse them when multiple collections have the same schema
+ *
+ * Notice: to make it easier and not dependent on a hash function,
+ * we use the plain json string.
+ */
+var VALIDATOR_CACHE_BY_VALIDATOR_KEY = new Map();
+
+/**
+ * This factory is used in the validation plugins
+ * so that we can reuse the basic storage wrapping code.
+ */
+export function wrappedValidateStorageFactory(
+/**
+ * Returns a method that can be used to validate
+ * documents and throws when the document is not valid.
+ */
+getValidator,
+/**
+ * A string to identify the validation library.
+ */
+validatorKey) {
+  var VALIDATOR_CACHE = getFromMapOrCreate(VALIDATOR_CACHE_BY_VALIDATOR_KEY, validatorKey, () => new Map());
+  function initValidator(schema) {
+    return getFromMapOrCreate(VALIDATOR_CACHE, JSON.stringify(schema), () => getValidator(schema));
+  }
+  return args => {
+    return Object.assign({}, args.storage, {
+      name: 'validate-' + validatorKey + '-' + args.storage.name,
+      async createStorageInstance(params) {
+        var instance = await args.storage.createStorageInstance(params);
+        var primaryPath = getPrimaryFieldOfPrimaryKey(params.schema.primaryKey);
+
+        /**
+         * Lazy initialize the validator
+         * to save initial page load performance.
+         * Some libraries take really long to initialize the validator
+         * from the schema.
+         */
+        var validatorCached;
+        requestIdleCallbackIfAvailable(() => validatorCached = initValidator(params.schema));
+        var oldBulkWrite = instance.bulkWrite.bind(instance);
+        instance.bulkWrite = (documentWrites, context) => {
+          if (!validatorCached) {
+            validatorCached = initValidator(params.schema);
+          }
+          var errors = [];
+          var continueWrites = [];
+          documentWrites.forEach(row => {
+            var documentId = row.document[primaryPath];
+            var validationErrors = validatorCached(row.document);
+            if (validationErrors.length > 0) {
+              errors.push({
+                status: 422,
+                isError: true,
+                documentId,
+                validationErrors,
+                schema: instance.schema,
+                writeRow: row,
+                context
+              });
+            } else {
+              continueWrites.push(row);
+            }
+          });
+          var writePromise = continueWrites.length > 0 ? oldBulkWrite(continueWrites, context) : Promise.resolve({
+            error: [],
+            success: []
+          });
+          return writePromise.then(writeResult => {
+            errors.forEach(validationError => {
+              writeResult.error.push(validationError);
+            });
+            return writeResult;
+          });
+        };
+        return instance;
+      }
+    });
+  };
+}
+
+/**
+ * Used in plugins to easily modify all in- and outgoing
+ * data of that storage instance.
+ */
+export function wrapRxStorageInstance(originalSchema, instance, modifyToStorage, modifyFromStorage, modifyAttachmentFromStorage = v => v) {
+  async function toStorage(docData) {
+    if (!docData) {
+      return docData;
+    }
+    return await modifyToStorage(docData);
+  }
+  async function fromStorage(docData) {
+    if (!docData) {
+      return docData;
+    }
+    return await modifyFromStorage(docData);
+  }
+  async function errorFromStorage(error) {
+    var ret = flatClone(error);
+    ret.writeRow = flatClone(ret.writeRow);
+    if (ret.documentInDb) {
+      ret.documentInDb = await fromStorage(ret.documentInDb);
+    }
+    if (ret.writeRow.previous) {
+      ret.writeRow.previous = await fromStorage(ret.writeRow.previous);
+    }
+    ret.writeRow.document = await fromStorage(ret.writeRow.document);
+    return ret;
+  }
+  var processingChangesCount$ = new BehaviorSubject(0);
+  var wrappedInstance = {
+    databaseName: instance.databaseName,
+    internals: instance.internals,
+    cleanup: instance.cleanup.bind(instance),
+    options: instance.options,
+    close: instance.close.bind(instance),
+    schema: originalSchema,
+    collectionName: instance.collectionName,
+    count: instance.count.bind(instance),
+    remove: instance.remove.bind(instance),
+    originalStorageInstance: instance,
+    bulkWrite: async (documentWrites, context) => {
+      var useRows = [];
+      await Promise.all(documentWrites.map(async row => {
+        var [previous, document] = await Promise.all([row.previous ? toStorage(row.previous) : undefined, toStorage(row.document)]);
+        useRows.push({
+          previous,
+          document
+        });
+      }));
+      var writeResult = await instance.bulkWrite(useRows, context);
+      var ret = {
+        error: []
+      };
+      var promises = [];
+      writeResult.error.forEach(error => {
+        promises.push(errorFromStorage(error).then(err => ret.error.push(err)));
+      });
+      await Promise.all(promises);
+
+      /**
+       * By definition, all change events must be emitted
+       * BEFORE the write call resolves.
+       * To ensure that even when the modifiers are async,
+       * we wait here until the processing queue is empty.
+       */
+      await firstValueFrom(processingChangesCount$.pipe(filter(v => v === 0)));
+      return ret;
+    },
+    query: preparedQuery => {
+      return instance.query(preparedQuery).then(queryResult => {
+        return Promise.all(queryResult.documents.map(doc => fromStorage(doc)));
+      }).then(documents => ({
+        documents: documents
+      }));
+    },
+    getAttachmentData: async (documentId, attachmentId, digest) => {
+      var data = await instance.getAttachmentData(documentId, attachmentId, digest);
+      data = await modifyAttachmentFromStorage(data);
+      return data;
+    },
+    findDocumentsById: (ids, deleted) => {
+      return instance.findDocumentsById(ids, deleted).then(async findResult => {
+        var ret = [];
+        await Promise.all(findResult.map(async doc => {
+          ret.push(await fromStorage(doc));
+        }));
+        return ret;
+      });
+    },
+    getChangedDocumentsSince: !instance.getChangedDocumentsSince ? undefined : (limit, checkpoint) => {
+      return instance.getChangedDocumentsSince(limit, checkpoint).then(async result => {
+        return {
+          checkpoint: result.checkpoint,
+          documents: await Promise.all(result.documents.map(d => fromStorage(d)))
+        };
+      });
+    },
+    changeStream: () => {
+      return instance.changeStream().pipe(tap(() => processingChangesCount$.next(processingChangesCount$.getValue() + 1)), mergeMap(async eventBulk => {
+        var useEvents = await Promise.all(eventBulk.events.map(async event => {
+          var [documentData, previousDocumentData] = await Promise.all([fromStorage(event.documentData), fromStorage(event.previousDocumentData)]);
+          var ev = {
+            operation: event.operation,
+            documentId: event.documentId,
+            documentData: documentData,
+            previousDocumentData: previousDocumentData,
+            isLocal: false
+          };
+          return ev;
+        }));
+        var ret = {
+          id: eventBulk.id,
+          events: useEvents,
+          checkpoint: eventBulk.checkpoint,
+          context: eventBulk.context
+        };
+        return ret;
+      }), tap(() => processingChangesCount$.next(processingChangesCount$.getValue() - 1)));
+    }
+  };
+  return wrappedInstance;
+}
+//# sourceMappingURL=plugin-helpers.js.map

package/dist/esm/plugin-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-helpers.js","names":["filter","mergeMap","tap","getPrimaryFieldOfPrimaryKey","flatClone","getFromMapOrCreate","requestIdleCallbackIfAvailable","BehaviorSubject","firstValueFrom","VALIDATOR_CACHE_BY_VALIDATOR_KEY","Map","wrappedValidateStorageFactory","getValidator","validatorKey","VALIDATOR_CACHE","initValidator","schema","JSON","stringify","args","Object","assign","storage","name","createStorageInstance","params","instance","primaryPath","primaryKey","validatorCached","oldBulkWrite","bulkWrite","bind","documentWrites","context","errors","continueWrites","forEach","row","documentId","document","validationErrors","length","push","status","isError","writeRow","writePromise","Promise","resolve","error","success","then","writeResult","validationError","wrapRxStorageInstance","originalSchema","modifyToStorage","modifyFromStorage","modifyAttachmentFromStorage","v","toStorage","docData","fromStorage","errorFromStorage","ret","documentInDb","previous","processingChangesCount$","wrappedInstance","databaseName","internals","cleanup","options","close","collectionName","count","remove","originalStorageInstance","useRows","all","map","undefined","promises","err","pipe","query","preparedQuery","queryResult","documents","doc","getAttachmentData","attachmentId","digest","data","findDocumentsById","ids","deleted","findResult","getChangedDocumentsSince","limit","checkpoint","result","d","changeStream","next","getValue","eventBulk","useEvents","events","event","documentData","previousDocumentData","ev","operation","isLocal","id"],"sources":["../../src/plugin-helpers.ts"],"sourcesContent":["import { filter, mergeMap, tap } from 'rxjs/operators';\r\nimport { getPrimaryFieldOfPrimaryKey } from './rx-schema-helper.ts';\r\nimport { WrappedRxStorageInstance } from './rx-storage-helper.ts';\r\nimport type {\r\n    BulkWriteRow,\r\n    EventBulk,\r\n    RxChangeEvent,\r\n    RxDocumentData,\r\n    RxDocumentWriteData,\r\n    RxJsonSchema,\r\n    RxStorage,\r\n    RxStorageWriteError,\r\n    RxStorageBulkWriteResponse,\r\n    RxStorageChangeEvent,\r\n    RxStorageInstance,\r\n    RxStorageInstanceCreationParams,\r\n    RxValidationError,\r\n    RxStorageWriteErrorConflict,\r\n    MaybePromise\r\n} from './types/index.d.ts';\r\nimport {\r\n    flatClone,\r\n    getFromMapOrCreate,\r\n    requestIdleCallbackIfAvailable\r\n} from './plugins/utils/index.ts';\r\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\r\n\r\n\r\ntype WrappedStorageFunction = <Internals, InstanceCreationOptions>(\r\n    args: {\r\n        storage: RxStorage<Internals, InstanceCreationOptions>;\r\n    }\r\n) => RxStorage<Internals, InstanceCreationOptions>;\r\n\r\n/**\r\n * Returns the validation errors.\r\n * If document is fully valid, returns an empty array.\r\n */\r\ntype ValidatorFunction = (docData: RxDocumentData<any>) => RxValidationError[];\r\n\r\n/**\r\n * cache the validators by the schema string\r\n * so we can reuse them when multiple collections have the same schema\r\n *\r\n * Notice: to make it easier and not dependent on a hash function,\r\n * we use the plain json string.\r\n */\r\nconst VALIDATOR_CACHE_BY_VALIDATOR_KEY: Map<string, Map<string, ValidatorFunction>> = new Map();\r\n\r\n/**\r\n * This factory is used in the validation plugins\r\n * so that we can reuse the basic storage wrapping code.\r\n */\r\nexport function wrappedValidateStorageFactory(\r\n    /**\r\n     * Returns a method that can be used to validate\r\n     * documents and throws when the document is not valid.\r\n     */\r\n    getValidator: (schema: RxJsonSchema<any>) => ValidatorFunction,\r\n    /**\r\n     * A string to identify the validation library.\r\n     */\r\n    validatorKey: string\r\n): WrappedStorageFunction {\r\n    const VALIDATOR_CACHE = getFromMapOrCreate(\r\n        VALIDATOR_CACHE_BY_VALIDATOR_KEY,\r\n        validatorKey,\r\n        () => new Map()\r\n    );\r\n\r\n    function initValidator(\r\n        schema: RxJsonSchema<any>\r\n    ): ValidatorFunction {\r\n        return getFromMapOrCreate(\r\n            VALIDATOR_CACHE,\r\n            JSON.stringify(schema),\r\n            () => getValidator(schema)\r\n        );\r\n    }\r\n\r\n    return (args) => {\r\n        return Object.assign(\r\n            {},\r\n            args.storage,\r\n            {\r\n                name: 'validate-' + validatorKey + '-' + args.storage.name,\r\n                async createStorageInstance<RxDocType>(\r\n                    params: RxStorageInstanceCreationParams<RxDocType, any>\r\n                ) {\r\n                    const instance = await args.storage.createStorageInstance(params);\r\n                    const primaryPath = getPrimaryFieldOfPrimaryKey(params.schema.primaryKey);\r\n\r\n                    /**\r\n                     * Lazy initialize the validator\r\n                     * to save initial page load performance.\r\n                     * Some libraries take really long to initialize the validator\r\n                     * from the schema.\r\n                     */\r\n                    let validatorCached: ValidatorFunction;\r\n                    requestIdleCallbackIfAvailable(() => validatorCached = initValidator(params.schema));\r\n\r\n                    const oldBulkWrite = instance.bulkWrite.bind(instance);\r\n                    instance.bulkWrite = (\r\n                        documentWrites: BulkWriteRow<RxDocType>[],\r\n                        context: string\r\n                    ) => {\r\n                        if (!validatorCached) {\r\n                            validatorCached = initValidator(params.schema);\r\n                        }\r\n                        const errors: RxStorageWriteError<RxDocType>[] = [];\r\n                        const continueWrites: typeof documentWrites = [];\r\n                        documentWrites.forEach(row => {\r\n                            const documentId: string = row.document[primaryPath] as any;\r\n                            const validationErrors = validatorCached(row.document);\r\n                            if (validationErrors.length > 0) {\r\n                                errors.push({\r\n                                    status: 422,\r\n                                    isError: true,\r\n                                    documentId,\r\n                                    validationErrors,\r\n                                    schema: instance.schema,\r\n                                    writeRow: row,\r\n                                    context\r\n                                });\r\n                            } else {\r\n                                continueWrites.push(row);\r\n                            }\r\n                        });\r\n                        const writePromise: Promise<RxStorageBulkWriteResponse<RxDocType>> = continueWrites.length > 0 ?\r\n                            oldBulkWrite(continueWrites, context) :\r\n                            Promise.resolve({ error: [], success: [] });\r\n                        return writePromise.then(writeResult => {\r\n                            errors.forEach(validationError => {\r\n                                writeResult.error.push(validationError);\r\n                            });\r\n                            return writeResult;\r\n                        });\r\n                    };\r\n\r\n                    return instance;\r\n                }\r\n            }\r\n        );\r\n    };\r\n\r\n}\r\n\r\n\r\n\r\n/**\r\n * Used in plugins to easily modify all in- and outgoing\r\n * data of that storage instance.\r\n */\r\nexport function wrapRxStorageInstance<RxDocType>(\r\n    originalSchema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    instance: RxStorageInstance<RxDocType, any, any>,\r\n    modifyToStorage: (docData: RxDocumentWriteData<RxDocType>) => MaybePromise<RxDocumentData<any>>,\r\n    modifyFromStorage: (docData: RxDocumentData<any>) => MaybePromise<RxDocumentData<RxDocType>>,\r\n    modifyAttachmentFromStorage: (attachmentData: Blob) => MaybePromise<Blob> = (v) => v\r\n): WrappedRxStorageInstance<RxDocType, any, any> {\r\n    async function toStorage(docData: RxDocumentWriteData<RxDocType>): Promise<RxDocumentData<any>> {\r\n        if (!docData) {\r\n            return docData;\r\n        }\r\n        return await modifyToStorage(docData);\r\n    }\r\n    async function fromStorage(docData: RxDocumentData<any> | null): Promise<RxDocumentData<RxDocType>> {\r\n        if (!docData) {\r\n            return docData;\r\n        }\r\n        return await modifyFromStorage(docData);\r\n    }\r\n    async function errorFromStorage(\r\n        error: RxStorageWriteError<any>\r\n    ): Promise<RxStorageWriteError<RxDocType>> {\r\n        const ret = flatClone(error);\r\n        ret.writeRow = flatClone(ret.writeRow);\r\n        if ((ret as RxStorageWriteErrorConflict<any>).documentInDb) {\r\n            (ret as RxStorageWriteErrorConflict<any>).documentInDb = await fromStorage((ret as RxStorageWriteErrorConflict<any>).documentInDb);\r\n        }\r\n        if (ret.writeRow.previous) {\r\n            ret.writeRow.previous = await fromStorage(ret.writeRow.previous);\r\n        }\r\n        ret.writeRow.document = await fromStorage(ret.writeRow.document);\r\n        return ret;\r\n    }\r\n\r\n\r\n    const processingChangesCount$ = new BehaviorSubject(0);\r\n\r\n    const wrappedInstance: WrappedRxStorageInstance<RxDocType, any, any> = {\r\n        databaseName: instance.databaseName,\r\n        internals: instance.internals,\r\n        cleanup: instance.cleanup.bind(instance),\r\n        options: instance.options,\r\n        close: instance.close.bind(instance),\r\n        schema: originalSchema,\r\n        collectionName: instance.collectionName,\r\n        count: instance.count.bind(instance),\r\n        remove: instance.remove.bind(instance),\r\n        originalStorageInstance: instance,\r\n        bulkWrite: async (\r\n            documentWrites: BulkWriteRow<RxDocType>[],\r\n            context: string\r\n        ) => {\r\n            const useRows: BulkWriteRow<any>[] = [];\r\n            await Promise.all(\r\n                documentWrites.map(async (row) => {\r\n                    const [previous, document] = await Promise.all([\r\n                        row.previous ? toStorage(row.previous) : undefined,\r\n                        toStorage(row.document)\r\n                    ]);\r\n                    useRows.push({ previous, document });\r\n                })\r\n            );\r\n\r\n            const writeResult = await instance.bulkWrite(useRows, context);\r\n            const ret: RxStorageBulkWriteResponse<RxDocType> = {\r\n                error: []\r\n            };\r\n            const promises: Promise<any>[] = [];\r\n            writeResult.error.forEach(error => {\r\n                promises.push(\r\n                    errorFromStorage(error).then(err => ret.error.push(err))\r\n                );\r\n            });\r\n            await Promise.all(promises);\r\n\r\n            /**\r\n             * By definition, all change events must be emitted\r\n             * BEFORE the write call resolves.\r\n             * To ensure that even when the modifiers are async,\r\n             * we wait here until the processing queue is empty.\r\n             */\r\n            await firstValueFrom(\r\n                processingChangesCount$.pipe(\r\n                    filter((v: number) => v === 0)\r\n                )\r\n            );\r\n            return ret;\r\n        },\r\n        query: (preparedQuery) => {\r\n            return instance.query(preparedQuery)\r\n                .then(queryResult => {\r\n                    return Promise.all(queryResult.documents.map(doc => fromStorage(doc)));\r\n                })\r\n                .then(documents => ({ documents: documents as any }));\r\n        },\r\n        getAttachmentData: async (\r\n            documentId: string,\r\n            attachmentId: string,\r\n            digest: string\r\n        ) => {\r\n            let data = await instance.getAttachmentData(documentId, attachmentId, digest);\r\n            data = await modifyAttachmentFromStorage(data);\r\n            return data;\r\n        },\r\n        findDocumentsById: (ids, deleted) => {\r\n            return instance.findDocumentsById(ids, deleted)\r\n                .then(async (findResult) => {\r\n                    const ret: RxDocumentData<RxDocType>[] = [];\r\n                    await Promise.all(\r\n                        findResult\r\n                            .map(async (doc) => {\r\n                                ret.push(await fromStorage(doc));\r\n                            })\r\n                    );\r\n                    return ret;\r\n                });\r\n        },\r\n        getChangedDocumentsSince: !instance.getChangedDocumentsSince ? undefined : (limit, checkpoint) => {\r\n            return ((instance as any).getChangedDocumentsSince)(limit, checkpoint)\r\n                .then(async (result: any) => {\r\n                    return {\r\n                        checkpoint: result.checkpoint,\r\n                        documents: await Promise.all(\r\n                            result.documents.map((d: any) => fromStorage(d))\r\n                        )\r\n                    };\r\n                });\r\n        },\r\n        changeStream: () => {\r\n            return instance.changeStream().pipe(\r\n                tap(() => processingChangesCount$.next(processingChangesCount$.getValue() + 1)),\r\n                mergeMap(async (eventBulk: EventBulk<RxStorageChangeEvent<RxDocType>, any>) => {\r\n                    const useEvents = await Promise.all(\r\n                        eventBulk.events.map(async (event: RxStorageChangeEvent<RxDocType>) => {\r\n                            const [\r\n                                documentData,\r\n                                previousDocumentData\r\n                            ] = await Promise.all([\r\n                                fromStorage(event.documentData),\r\n                                fromStorage(event.previousDocumentData)\r\n                            ]);\r\n                            const ev: RxChangeEvent<RxDocType> = {\r\n                                operation: event.operation,\r\n                                documentId: event.documentId,\r\n                                documentData: documentData as any,\r\n                                previousDocumentData: previousDocumentData as any,\r\n                                isLocal: false\r\n                            };\r\n                            return ev;\r\n                        })\r\n                    );\r\n                    const ret: EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, any> = {\r\n                        id: eventBulk.id,\r\n                        events: useEvents,\r\n                        checkpoint: eventBulk.checkpoint,\r\n                        context: eventBulk.context\r\n                    };\r\n                    return ret;\r\n                }),\r\n                tap(() => processingChangesCount$.next(processingChangesCount$.getValue() - 1))\r\n            );\r\n        },\r\n    };\r\n\r\n    return wrappedInstance;\r\n}\r\n"],"mappings":"AAAA,SAASA,MAAM,EAAEC,QAAQ,EAAEC,GAAG,QAAQ,gBAAgB;AACtD,SAASC,2BAA2B,QAAQ,uBAAuB;AAmBnE,SACIC,SAAS,EACTC,kBAAkB,EAClBC,8BAA8B,QAC3B,0BAA0B;AACjC,SAASC,eAAe,EAAEC,cAAc,QAAQ,MAAM;;AAStD;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMC,gCAA6E,GAAG,IAAIC,GAAG,CAAC,CAAC;;AAE/F;AACA;AACA;AACA;AACA,OAAO,SAASC,6BAA6BA;AACzC;AACJ;AACA;AACA;AACIC,YAA8D;AAC9D;AACJ;AACA;AACIC,YAAoB,EACE;EACtB,IAAMC,eAAe,GAAGT,kBAAkB,CACtCI,gCAAgC,EAChCI,YAAY,EACZ,MAAM,IAAIH,GAAG,CAAC,CAClB,CAAC;EAED,SAASK,aAAaA,CAClBC,MAAyB,EACR;IACjB,OAAOX,kBAAkB,CACrBS,eAAe,EACfG,IAAI,CAACC,SAAS,CAACF,MAAM,CAAC,EACtB,MAAMJ,YAAY,CAACI,MAAM,CAC7B,CAAC;EACL;EAEA,OAAQG,IAAI,IAAK;IACb,OAAOC,MAAM,CAACC,MAAM,CAChB,CAAC,CAAC,EACFF,IAAI,CAACG,OAAO,EACZ;MACIC,IAAI,EAAE,WAAW,GAAGV,YAAY,GAAG,GAAG,GAAGM,IAAI,CAACG,OAAO,CAACC,IAAI;MAC1D,MAAMC,qBAAqBA,CACvBC,MAAuD,EACzD;QACE,IAAMC,QAAQ,GAAG,MAAMP,IAAI,CAACG,OAAO,CAACE,qBAAqB,CAACC,MAAM,CAAC;QACjE,IAAME,WAAW,GAAGxB,2BAA2B,CAACsB,MAAM,CAACT,MAAM,CAACY,UAAU,CAAC;;QAEzE;AACpB;AACA;AACA;AACA;AACA;QACoB,IAAIC,eAAkC;QACtCvB,8BAA8B,CAAC,MAAMuB,eAAe,GAAGd,aAAa,CAACU,MAAM,CAACT,MAAM,CAAC,CAAC;QAEpF,IAAMc,YAAY,GAAGJ,QAAQ,CAACK,SAAS,CAACC,IAAI,CAACN,QAAQ,CAAC;QACtDA,QAAQ,CAACK,SAAS,GAAG,CACjBE,cAAyC,EACzCC,OAAe,KACd;UACD,IAAI,CAACL,eAAe,EAAE;YAClBA,eAAe,GAAGd,aAAa,CAACU,MAAM,CAACT,MAAM,CAAC;UAClD;UACA,IAAMmB,MAAwC,GAAG,EAAE;UACnD,IAAMC,cAAqC,GAAG,EAAE;UAChDH,cAAc,CAACI,OAAO,CAACC,GAAG,IAAI;YAC1B,IAAMC,UAAkB,GAAGD,GAAG,CAACE,QAAQ,CAACb,WAAW,CAAQ;YAC3D,IAAMc,gBAAgB,GAAGZ,eAAe,CAACS,GAAG,CAACE,QAAQ,CAAC;YACtD,IAAIC,gBAAgB,CAACC,MAAM,GAAG,CAAC,EAAE;cAC7BP,MAAM,CAACQ,IAAI,CAAC;gBACRC,MAAM,EAAE,GAAG;gBACXC,OAAO,EAAE,IAAI;gBACbN,UAAU;gBACVE,gBAAgB;gBAChBzB,MAAM,EAAEU,QAAQ,CAACV,MAAM;gBACvB8B,QAAQ,EAAER,GAAG;gBACbJ;cACJ,CAAC,CAAC;YACN,CAAC,MAAM;cACHE,cAAc,CAACO,IAAI,CAACL,GAAG,CAAC;YAC5B;UACJ,CAAC,CAAC;UACF,IAAMS,YAA4D,GAAGX,cAAc,CAACM,MAAM,GAAG,CAAC,GAC1FZ,YAAY,CAACM,cAAc,EAAEF,OAAO,CAAC,GACrCc,OAAO,CAACC,OAAO,CAAC;YAAEC,KAAK,EAAE,EAAE;YAAEC,OAAO,EAAE;UAAG,CAAC,CAAC;UAC/C,OAAOJ,YAAY,CAACK,IAAI,CAACC,WAAW,IAAI;YACpClB,MAAM,CAACE,OAAO,CAACiB,eAAe,IAAI;cAC9BD,WAAW,CAACH,KAAK,CAACP,IAAI,CAACW,eAAe,CAAC;YAC3C,CAAC,CAAC;YACF,OAAOD,WAAW;UACtB,CAAC,CAAC;QACN,CAAC;QAED,OAAO3B,QAAQ;MACnB;IACJ,CACJ,CAAC;EACL,CAAC;AAEL;;AAIA;AACA;AACA;AACA;AACA,OAAO,SAAS6B,qBAAqBA,CACjCC,cAAuD,EACvD9B,QAAgD,EAChD+B,eAA+F,EAC/FC,iBAA4F,EAC5FC,2BAAyE,GAAIC,CAAC,IAAKA,CAAC,EACvC;EAC7C,eAAeC,SAASA,CAACC,OAAuC,EAAgC;IAC5F,IAAI,CAACA,OAAO,EAAE;MACV,OAAOA,OAAO;IAClB;IACA,OAAO,MAAML,eAAe,CAACK,OAAO,CAAC;EACzC;EACA,eAAeC,WAAWA,CAACD,OAAmC,EAAsC;IAChG,IAAI,CAACA,OAAO,EAAE;MACV,OAAOA,OAAO;IAClB;IACA,OAAO,MAAMJ,iBAAiB,CAACI,OAAO,CAAC;EAC3C;EACA,eAAeE,gBAAgBA,CAC3Bd,KAA+B,EACQ;IACvC,IAAMe,GAAG,GAAG7D,SAAS,CAAC8C,KAAK,CAAC;IAC5Be,GAAG,CAACnB,QAAQ,GAAG1C,SAAS,CAAC6D,GAAG,CAACnB,QAAQ,CAAC;IACtC,IAAKmB,GAAG,CAAsCC,YAAY,EAAE;MACvDD,GAAG,CAAsCC,YAAY,GAAG,MAAMH,WAAW,CAAEE,GAAG,CAAsCC,YAAY,CAAC;IACtI;IACA,IAAID,GAAG,CAACnB,QAAQ,CAACqB,QAAQ,EAAE;MACvBF,GAAG,CAACnB,QAAQ,CAACqB,QAAQ,GAAG,MAAMJ,WAAW,CAACE,GAAG,CAACnB,QAAQ,CAACqB,QAAQ,CAAC;IACpE;IACAF,GAAG,CAACnB,QAAQ,CAACN,QAAQ,GAAG,MAAMuB,WAAW,CAACE,GAAG,CAACnB,QAAQ,CAACN,QAAQ,CAAC;IAChE,OAAOyB,GAAG;EACd;EAGA,IAAMG,uBAAuB,GAAG,IAAI7D,eAAe,CAAC,CAAC,CAAC;EAEtD,IAAM8D,eAA8D,GAAG;IACnEC,YAAY,EAAE5C,QAAQ,CAAC4C,YAAY;IACnCC,SAAS,EAAE7C,QAAQ,CAAC6C,SAAS;IAC7BC,OAAO,EAAE9C,QAAQ,CAAC8C,OAAO,CAACxC,IAAI,CAACN,QAAQ,CAAC;IACxC+C,OAAO,EAAE/C,QAAQ,CAAC+C,OAAO;IACzBC,KAAK,EAAEhD,QAAQ,CAACgD,KAAK,CAAC1C,IAAI,CAACN,QAAQ,CAAC;IACpCV,MAAM,EAAEwC,cAAc;IACtBmB,cAAc,EAAEjD,QAAQ,CAACiD,cAAc;IACvCC,KAAK,EAAElD,QAAQ,CAACkD,KAAK,CAAC5C,IAAI,CAACN,QAAQ,CAAC;IACpCmD,MAAM,EAAEnD,QAAQ,CAACmD,MAAM,CAAC7C,IAAI,CAACN,QAAQ,CAAC;IACtCoD,uBAAuB,EAAEpD,QAAQ;IACjCK,SAAS,EAAE,MAAAA,CACPE,cAAyC,EACzCC,OAAe,KACd;MACD,IAAM6C,OAA4B,GAAG,EAAE;MACvC,MAAM/B,OAAO,CAACgC,GAAG,CACb/C,cAAc,CAACgD,GAAG,CAAC,MAAO3C,GAAG,IAAK;QAC9B,IAAM,CAAC6B,QAAQ,EAAE3B,QAAQ,CAAC,GAAG,MAAMQ,OAAO,CAACgC,GAAG,CAAC,CAC3C1C,GAAG,CAAC6B,QAAQ,GAAGN,SAAS,CAACvB,GAAG,CAAC6B,QAAQ,CAAC,GAAGe,SAAS,EAClDrB,SAAS,CAACvB,GAAG,CAACE,QAAQ,CAAC,CAC1B,CAAC;QACFuC,OAAO,CAACpC,IAAI,CAAC;UAAEwB,QAAQ;UAAE3B;QAAS,CAAC,CAAC;MACxC,CAAC,CACL,CAAC;MAED,IAAMa,WAAW,GAAG,MAAM3B,QAAQ,CAACK,SAAS,CAACgD,OAAO,EAAE7C,OAAO,CAAC;MAC9D,IAAM+B,GAA0C,GAAG;QAC/Cf,KAAK,EAAE;MACX,CAAC;MACD,IAAMiC,QAAwB,GAAG,EAAE;MACnC9B,WAAW,CAACH,KAAK,CAACb,OAAO,CAACa,KAAK,IAAI;QAC/BiC,QAAQ,CAACxC,IAAI,CACTqB,gBAAgB,CAACd,KAAK,CAAC,CAACE,IAAI,CAACgC,GAAG,IAAInB,GAAG,CAACf,KAAK,CAACP,IAAI,CAACyC,GAAG,CAAC,CAC3D,CAAC;MACL,CAAC,CAAC;MACF,MAAMpC,OAAO,CAACgC,GAAG,CAACG,QAAQ,CAAC;;MAE3B;AACZ;AACA;AACA;AACA;AACA;MACY,MAAM3E,cAAc,CAChB4D,uBAAuB,CAACiB,IAAI,CACxBrF,MAAM,CAAE4D,CAAS,IAAKA,CAAC,KAAK,CAAC,CACjC,CACJ,CAAC;MACD,OAAOK,GAAG;IACd,CAAC;IACDqB,KAAK,EAAGC,aAAa,IAAK;MACtB,OAAO7D,QAAQ,CAAC4D,KAAK,CAACC,aAAa,CAAC,CAC/BnC,IAAI,CAACoC,WAAW,IAAI;QACjB,OAAOxC,OAAO,CAACgC,GAAG,CAACQ,WAAW,CAACC,SAAS,CAACR,GAAG,CAACS,GAAG,IAAI3B,WAAW,CAAC2B,GAAG,CAAC,CAAC,CAAC;MAC1E,CAAC,CAAC,CACDtC,IAAI,CAACqC,SAAS,KAAK;QAAEA,SAAS,EAAEA;MAAiB,CAAC,CAAC,CAAC;IAC7D,CAAC;IACDE,iBAAiB,EAAE,MAAAA,CACfpD,UAAkB,EAClBqD,YAAoB,EACpBC,MAAc,KACb;MACD,IAAIC,IAAI,GAAG,MAAMpE,QAAQ,CAACiE,iBAAiB,CAACpD,UAAU,EAAEqD,YAAY,EAAEC,MAAM,CAAC;MAC7EC,IAAI,GAAG,MAAMnC,2BAA2B,CAACmC,IAAI,CAAC;MAC9C,OAAOA,IAAI;IACf,CAAC;IACDC,iBAAiB,EAAEA,CAACC,GAAG,EAAEC,OAAO,KAAK;MACjC,OAAOvE,QAAQ,CAACqE,iBAAiB,CAACC,GAAG,EAAEC,OAAO,CAAC,CAC1C7C,IAAI,CAAC,MAAO8C,UAAU,IAAK;QACxB,IAAMjC,GAAgC,GAAG,EAAE;QAC3C,MAAMjB,OAAO,CAACgC,GAAG,CACbkB,UAAU,CACLjB,GAAG,CAAC,MAAOS,GAAG,IAAK;UAChBzB,GAAG,CAACtB,IAAI,CAAC,MAAMoB,WAAW,CAAC2B,GAAG,CAAC,CAAC;QACpC,CAAC,CACT,CAAC;QACD,OAAOzB,GAAG;MACd,CAAC,CAAC;IACV,CAAC;IACDkC,wBAAwB,EAAE,CAACzE,QAAQ,CAACyE,wBAAwB,GAAGjB,SAAS,GAAG,CAACkB,KAAK,EAAEC,UAAU,KAAK;MAC9F,OAAS3E,QAAQ,CAASyE,wBAAwB,CAAEC,KAAK,EAAEC,UAAU,CAAC,CACjEjD,IAAI,CAAC,MAAOkD,MAAW,IAAK;QACzB,OAAO;UACHD,UAAU,EAAEC,MAAM,CAACD,UAAU;UAC7BZ,SAAS,EAAE,MAAMzC,OAAO,CAACgC,GAAG,CACxBsB,MAAM,CAACb,SAAS,CAACR,GAAG,CAAEsB,CAAM,IAAKxC,WAAW,CAACwC,CAAC,CAAC,CACnD;QACJ,CAAC;MACL,CAAC,CAAC;IACV,CAAC;IACDC,YAAY,EAAEA,CAAA,KAAM;MAChB,OAAO9E,QAAQ,CAAC8E,YAAY,CAAC,CAAC,CAACnB,IAAI,CAC/BnF,GAAG,CAAC,MAAMkE,uBAAuB,CAACqC,IAAI,CAACrC,uBAAuB,CAACsC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAC/EzG,QAAQ,CAAC,MAAO0G,SAA0D,IAAK;QAC3E,IAAMC,SAAS,GAAG,MAAM5D,OAAO,CAACgC,GAAG,CAC/B2B,SAAS,CAACE,MAAM,CAAC5B,GAAG,CAAC,MAAO6B,KAAsC,IAAK;UACnE,IAAM,CACFC,YAAY,EACZC,oBAAoB,CACvB,GAAG,MAAMhE,OAAO,CAACgC,GAAG,CAAC,CAClBjB,WAAW,CAAC+C,KAAK,CAACC,YAAY,CAAC,EAC/BhD,WAAW,CAAC+C,KAAK,CAACE,oBAAoB,CAAC,CAC1C,CAAC;UACF,IAAMC,EAA4B,GAAG;YACjCC,SAAS,EAAEJ,KAAK,CAACI,SAAS;YAC1B3E,UAAU,EAAEuE,KAAK,CAACvE,UAAU;YAC5BwE,YAAY,EAAEA,YAAmB;YACjCC,oBAAoB,EAAEA,oBAA2B;YACjDG,OAAO,EAAE;UACb,CAAC;UACD,OAAOF,EAAE;QACb,CAAC,CACL,CAAC;QACD,IAAMhD,GAAoE,GAAG;UACzEmD,EAAE,EAAET,SAAS,CAACS,EAAE;UAChBP,MAAM,EAAED,SAAS;UACjBP,UAAU,EAAEM,SAAS,CAACN,UAAU;UAChCnE,OAAO,EAAEyE,SAAS,CAACzE;QACvB,CAAC;QACD,OAAO+B,GAAG;MACd,CAAC,CAAC,EACF/D,GAAG,CAAC,MAAMkE,uBAAuB,CAACqC,IAAI,CAACrC,uBAAuB,CAACsC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAClF,CAAC;IACL;EACJ,CAAC;EAED,OAAOrC,eAAe;AAC1B","ignoreList":[]}

package/dist/esm/plugin.js

@@ -0,0 +1,88 @@
+/**
+ * this handles how plugins are added to rxdb
+ * basically it changes the internal prototypes
+ * by passing them to the plugins-functions
+ */
+import { RxSchema } from "./rx-schema.js";
+import { basePrototype as RxDocumentPrototype } from "./rx-document.js";
+import { RxQueryBase } from "./rx-query.js";
+import { RxCollectionBase } from "./rx-collection.js";
+import { RxDatabaseBase } from "./rx-database.js";
+import { overwritable } from "./overwritable.js";
+import { HOOKS, runPluginHooks } from "./hooks.js";
+import { newRxError, newRxTypeError } from "./rx-error.js";
+
+/**
+ * prototypes that can be manipulated with a plugin
+ */
+var PROTOTYPES = {
+  RxSchema: RxSchema.prototype,
+  RxDocument: RxDocumentPrototype,
+  RxQuery: RxQueryBase.prototype,
+  RxCollection: RxCollectionBase.prototype,
+  RxDatabase: RxDatabaseBase.prototype
+};
+var ADDED_PLUGINS = new Set();
+var ADDED_PLUGIN_NAMES = new Set();
+
+/**
+ * Add a plugin to the RxDB library.
+ * Plugins are added globally and cannot be removed.
+ */
+export function addRxPlugin(plugin) {
+  runPluginHooks('preAddRxPlugin', {
+    plugin,
+    plugins: ADDED_PLUGINS
+  });
+
+  // do nothing if added before
+  if (ADDED_PLUGINS.has(plugin)) {
+    return;
+  } else {
+    // ensure no other plugin with the same name was already added
+    if (ADDED_PLUGIN_NAMES.has(plugin.name)) {
+      throw newRxError('PL3', {
+        name: plugin.name,
+        plugin
+      });
+    }
+    ADDED_PLUGINS.add(plugin);
+    ADDED_PLUGIN_NAMES.add(plugin.name);
+  }
+
+  /**
+   * To identify broken configurations,
+   * we only allow RxDB plugins to be passed into addRxPlugin().
+   */
+  if (!plugin.rxdb) {
+    throw newRxTypeError('PL1', {
+      plugin
+    });
+  }
+  if (plugin.init) {
+    plugin.init();
+  }
+
+  // prototype-overwrites
+  if (plugin.prototypes) {
+    Object.entries(plugin.prototypes).forEach(([name, fun]) => {
+      return fun(PROTOTYPES[name]);
+    });
+  }
+  // overwritable-overwrites
+  if (plugin.overwritable) {
+    Object.assign(overwritable, plugin.overwritable);
+  }
+  // extend-hooks
+  if (plugin.hooks) {
+    Object.entries(plugin.hooks).forEach(([name, hooksObj]) => {
+      if (hooksObj.after) {
+        HOOKS[name].push(hooksObj.after);
+      }
+      if (hooksObj.before) {
+        HOOKS[name].unshift(hooksObj.before);
+      }
+    });
+  }
+}
+//# sourceMappingURL=plugin.js.map

package/dist/esm/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":["RxSchema","basePrototype","RxDocumentPrototype","RxQueryBase","RxCollectionBase","RxDatabaseBase","overwritable","HOOKS","runPluginHooks","newRxError","newRxTypeError","PROTOTYPES","prototype","RxDocument","RxQuery","RxCollection","RxDatabase","ADDED_PLUGINS","Set","ADDED_PLUGIN_NAMES","addRxPlugin","plugin","plugins","has","name","add","rxdb","init","prototypes","Object","entries","forEach","fun","assign","hooks","hooksObj","after","push","before","unshift"],"sources":["../../src/plugin.ts"],"sourcesContent":["/**\r\n * this handles how plugins are added to rxdb\r\n * basically it changes the internal prototypes\r\n * by passing them to the plugins-functions\r\n */\r\nimport {\r\n    RxSchema\r\n} from './rx-schema.ts';\r\nimport {\r\n    basePrototype as RxDocumentPrototype\r\n} from './rx-document.ts';\r\nimport {\r\n    RxQueryBase\r\n} from './rx-query.ts';\r\nimport {\r\n    RxCollectionBase\r\n} from './rx-collection.ts';\r\nimport {\r\n    RxDatabaseBase\r\n} from './rx-database.ts';\r\nimport type {\r\n    RxPlugin\r\n} from './types/index.d.ts';\r\n\r\nimport { overwritable } from './overwritable.ts';\r\nimport {\r\n    HOOKS,\r\n    runPluginHooks\r\n} from './hooks.ts';\r\nimport { newRxError, newRxTypeError } from './rx-error.ts';\r\n\r\n/**\r\n * prototypes that can be manipulated with a plugin\r\n */\r\nconst PROTOTYPES: { [k: string]: any; } = {\r\n    RxSchema: RxSchema.prototype,\r\n    RxDocument: RxDocumentPrototype,\r\n    RxQuery: RxQueryBase.prototype,\r\n    RxCollection: RxCollectionBase.prototype,\r\n    RxDatabase: RxDatabaseBase.prototype\r\n};\r\n\r\nconst ADDED_PLUGINS: Set<RxPlugin | any> = new Set();\r\nconst ADDED_PLUGIN_NAMES: Set<string> = new Set();\r\n\r\n/**\r\n * Add a plugin to the RxDB library.\r\n * Plugins are added globally and cannot be removed.\r\n */\r\nexport function addRxPlugin(plugin: RxPlugin) {\r\n    runPluginHooks('preAddRxPlugin', { plugin, plugins: ADDED_PLUGINS });\r\n\r\n    // do nothing if added before\r\n    if (ADDED_PLUGINS.has(plugin)) {\r\n        return;\r\n    } else {\r\n\r\n        // ensure no other plugin with the same name was already added\r\n        if (ADDED_PLUGIN_NAMES.has(plugin.name)) {\r\n            throw newRxError('PL3', {\r\n                name: plugin.name,\r\n                plugin,\r\n            });\r\n        }\r\n\r\n        ADDED_PLUGINS.add(plugin);\r\n        ADDED_PLUGIN_NAMES.add(plugin.name);\r\n    }\r\n\r\n    /**\r\n     * To identify broken configurations,\r\n     * we only allow RxDB plugins to be passed into addRxPlugin().\r\n     */\r\n    if (!plugin.rxdb) {\r\n        throw newRxTypeError('PL1', {\r\n            plugin\r\n        });\r\n    }\r\n\r\n    if (plugin.init) {\r\n        plugin.init();\r\n    }\r\n\r\n    // prototype-overwrites\r\n    if (plugin.prototypes) {\r\n        Object\r\n            .entries(plugin.prototypes)\r\n            .forEach(([name, fun]) => {\r\n                return (fun as any)(PROTOTYPES[name]);\r\n            });\r\n    }\r\n    // overwritable-overwrites\r\n    if (plugin.overwritable) {\r\n        Object.assign(\r\n            overwritable,\r\n            plugin.overwritable\r\n        );\r\n    }\r\n    // extend-hooks\r\n    if (plugin.hooks) {\r\n        Object\r\n            .entries(plugin.hooks)\r\n            .forEach(([name, hooksObj]) => {\r\n                if (hooksObj.after) {\r\n                    (HOOKS as any)[name].push(hooksObj.after);\r\n                }\r\n                if (hooksObj.before) {\r\n                    (HOOKS as any)[name].unshift(hooksObj.before);\r\n                }\r\n            });\r\n    }\r\n}\r\n\r\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,SACIA,QAAQ,QACL,gBAAgB;AACvB,SACIC,aAAa,IAAIC,mBAAmB,QACjC,kBAAkB;AACzB,SACIC,WAAW,QACR,eAAe;AACtB,SACIC,gBAAgB,QACb,oBAAoB;AAC3B,SACIC,cAAc,QACX,kBAAkB;AAKzB,SAASC,YAAY,QAAQ,mBAAmB;AAChD,SACIC,KAAK,EACLC,cAAc,QACX,YAAY;AACnB,SAASC,UAAU,EAAEC,cAAc,QAAQ,eAAe;;AAE1D;AACA;AACA;AACA,IAAMC,UAAiC,GAAG;EACtCX,QAAQ,EAAEA,QAAQ,CAACY,SAAS;EAC5BC,UAAU,EAAEX,mBAAmB;EAC/BY,OAAO,EAAEX,WAAW,CAACS,SAAS;EAC9BG,YAAY,EAAEX,gBAAgB,CAACQ,SAAS;EACxCI,UAAU,EAAEX,cAAc,CAACO;AAC/B,CAAC;AAED,IAAMK,aAAkC,GAAG,IAAIC,GAAG,CAAC,CAAC;AACpD,IAAMC,kBAA+B,GAAG,IAAID,GAAG,CAAC,CAAC;;AAEjD;AACA;AACA;AACA;AACA,OAAO,SAASE,WAAWA,CAACC,MAAgB,EAAE;EAC1Cb,cAAc,CAAC,gBAAgB,EAAE;IAAEa,MAAM;IAAEC,OAAO,EAAEL;EAAc,CAAC,CAAC;;EAEpE;EACA,IAAIA,aAAa,CAACM,GAAG,CAACF,MAAM,CAAC,EAAE;IAC3B;EACJ,CAAC,MAAM;IAEH;IACA,IAAIF,kBAAkB,CAACI,GAAG,CAACF,MAAM,CAACG,IAAI,CAAC,EAAE;MACrC,MAAMf,UAAU,CAAC,KAAK,EAAE;QACpBe,IAAI,EAAEH,MAAM,CAACG,IAAI;QACjBH;MACJ,CAAC,CAAC;IACN;IAEAJ,aAAa,CAACQ,GAAG,CAACJ,MAAM,CAAC;IACzBF,kBAAkB,CAACM,GAAG,CAACJ,MAAM,CAACG,IAAI,CAAC;EACvC;;EAEA;AACJ;AACA;AACA;EACI,IAAI,CAACH,MAAM,CAACK,IAAI,EAAE;IACd,MAAMhB,cAAc,CAAC,KAAK,EAAE;MACxBW;IACJ,CAAC,CAAC;EACN;EAEA,IAAIA,MAAM,CAACM,IAAI,EAAE;IACbN,MAAM,CAACM,IAAI,CAAC,CAAC;EACjB;;EAEA;EACA,IAAIN,MAAM,CAACO,UAAU,EAAE;IACnBC,MAAM,CACDC,OAAO,CAACT,MAAM,CAACO,UAAU,CAAC,CAC1BG,OAAO,CAAC,CAAC,CAACP,IAAI,EAAEQ,GAAG,CAAC,KAAK;MACtB,OAAQA,GAAG,CAASrB,UAAU,CAACa,IAAI,CAAC,CAAC;IACzC,CAAC,CAAC;EACV;EACA;EACA,IAAIH,MAAM,CAACf,YAAY,EAAE;IACrBuB,MAAM,CAACI,MAAM,CACT3B,YAAY,EACZe,MAAM,CAACf,YACX,CAAC;EACL;EACA;EACA,IAAIe,MAAM,CAACa,KAAK,EAAE;IACdL,MAAM,CACDC,OAAO,CAACT,MAAM,CAACa,KAAK,CAAC,CACrBH,OAAO,CAAC,CAAC,CAACP,IAAI,EAAEW,QAAQ,CAAC,KAAK;MAC3B,IAAIA,QAAQ,CAACC,KAAK,EAAE;QACf7B,KAAK,CAASiB,IAAI,CAAC,CAACa,IAAI,CAACF,QAAQ,CAACC,KAAK,CAAC;MAC7C;MACA,IAAID,QAAQ,CAACG,MAAM,EAAE;QAChB/B,KAAK,CAASiB,IAAI,CAAC,CAACe,OAAO,CAACJ,QAAQ,CAACG,MAAM,CAAC;MACjD;IACJ,CAAC,CAAC;EACV;AACJ","ignoreList":[]}

package/dist/esm/plugins/attachments/attachments-utils.js

@@ -0,0 +1,41 @@
+import { newRxError } from "../../rx-error.js";
+import { ensureNotFalsy } from "../utils/index.js";
+export function ensureSchemaSupportsAttachments(doc) {
+  var schemaJson = doc.collection.schema.jsonSchema;
+  if (!schemaJson.attachments) {
+    throw newRxError('AT1', {
+      link: 'https://pubkey.github.io/rxdb/rx-attachment.html'
+    });
+  }
+}
+export function assignMethodsToAttachment(attachment) {
+  Object.entries(attachment.doc.collection.attachments).forEach(([funName, fun]) => {
+    Object.defineProperty(attachment, funName, {
+      get: () => fun.bind(attachment)
+    });
+  });
+}
+
+/**
+ * Fill up the missing attachment.data of the newDocument
+ * so that the new document can be sent to somewhere else
+ * which could then receive all required attachments data
+ * that it did not have before.
+ */
+export async function fillWriteDataForAttachmentsChange(primaryPath, storageInstance, newDocument, originalDocument) {
+  if (!newDocument._attachments || originalDocument && !originalDocument._attachments) {
+    throw newRxError('AT4', {
+      document: newDocument
+    });
+  }
+  var docId = newDocument[primaryPath];
+  var originalAttachmentsIds = new Set(originalDocument && originalDocument._attachments ? Object.keys(originalDocument._attachments) : []);
+  await Promise.all(Object.entries(newDocument._attachments).map(async ([key, value]) => {
+    if ((!originalAttachmentsIds.has(key) || originalDocument && ensureNotFalsy(originalDocument._attachments)[key].digest !== value.digest) && !value.data) {
+      var attachmentBlob = await storageInstance.getAttachmentData(docId, key, value.digest);
+      value.data = attachmentBlob;
+    }
+  }));
+  return newDocument;
+}
+//# sourceMappingURL=attachments-utils.js.map

package/dist/esm/plugins/attachments/attachments-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments-utils.js","names":["newRxError","ensureNotFalsy","ensureSchemaSupportsAttachments","doc","schemaJson","collection","schema","jsonSchema","attachments","link","assignMethodsToAttachment","attachment","Object","entries","forEach","funName","fun","defineProperty","get","bind","fillWriteDataForAttachmentsChange","primaryPath","storageInstance","newDocument","originalDocument","_attachments","document","docId","originalAttachmentsIds","Set","keys","Promise","all","map","key","value","has","digest","data","attachmentBlob","getAttachmentData"],"sources":["../../../../src/plugins/attachments/attachments-utils.ts"],"sourcesContent":["import { newRxError } from '../../rx-error.ts';\r\nimport type {\r\n    RxAttachmentWriteData,\r\n    RxStorageInstance,\r\n    WithDeletedAndAttachments\r\n} from '../../types/index.d.ts';\r\nimport { ensureNotFalsy } from '../utils/index.ts';\r\n\r\nexport function ensureSchemaSupportsAttachments(doc: any) {\r\n    const schemaJson = doc.collection.schema.jsonSchema;\r\n    if (!schemaJson.attachments) {\r\n        throw newRxError('AT1', {\r\n            link: 'https://pubkey.github.io/rxdb/rx-attachment.html'\r\n        });\r\n    }\r\n}\r\n\r\nexport function assignMethodsToAttachment(attachment: any) {\r\n    Object\r\n        .entries(attachment.doc.collection.attachments)\r\n        .forEach(([funName, fun]) => {\r\n            Object.defineProperty(attachment, funName, {\r\n                get: () => (fun as any).bind(attachment)\r\n            });\r\n        });\r\n}\r\n\r\n/**\r\n * Fill up the missing attachment.data of the newDocument\r\n * so that the new document can be sent to somewhere else\r\n * which could then receive all required attachments data\r\n * that it did not have before.\r\n */\r\nexport async function fillWriteDataForAttachmentsChange<RxDocType>(\r\n    primaryPath: string,\r\n    storageInstance: RxStorageInstance<RxDocType, any, any, any>,\r\n    newDocument: WithDeletedAndAttachments<RxDocType>,\r\n    originalDocument?: WithDeletedAndAttachments<RxDocType>\r\n): Promise<WithDeletedAndAttachments<RxDocType>> {\r\n\r\n    if (\r\n        !newDocument._attachments ||\r\n        (\r\n            originalDocument &&\r\n            !originalDocument._attachments\r\n        )\r\n    ) {\r\n        throw newRxError('AT4', {\r\n            document: newDocument\r\n        });\r\n    }\r\n\r\n    const docId: string = (newDocument as any)[primaryPath];\r\n    const originalAttachmentsIds = new Set(\r\n        originalDocument && originalDocument._attachments\r\n            ? Object.keys(originalDocument._attachments)\r\n            : []\r\n    );\r\n    await Promise.all(\r\n        Object\r\n            .entries(newDocument._attachments)\r\n            .map(async ([key, value]) => {\r\n                if (\r\n                    (\r\n                        !originalAttachmentsIds.has(key) ||\r\n                        (\r\n                            originalDocument &&\r\n                            ensureNotFalsy(originalDocument._attachments)[key].digest !== value.digest\r\n                        )\r\n                    ) &&\r\n                    !(value as RxAttachmentWriteData).data\r\n                ) {\r\n                    const attachmentBlob = await storageInstance.getAttachmentData(\r\n                        docId,\r\n                        key,\r\n                        value.digest\r\n                    );\r\n                    (value as RxAttachmentWriteData).data = attachmentBlob;\r\n                }\r\n            })\r\n    );\r\n\r\n    return newDocument;\r\n}\r\n"],"mappings":"AAAA,SAASA,UAAU,QAAQ,mBAAmB;AAM9C,SAASC,cAAc,QAAQ,mBAAmB;AAElD,OAAO,SAASC,+BAA+BA,CAACC,GAAQ,EAAE;EACtD,IAAMC,UAAU,GAAGD,GAAG,CAACE,UAAU,CAACC,MAAM,CAACC,UAAU;EACnD,IAAI,CAACH,UAAU,CAACI,WAAW,EAAE;IACzB,MAAMR,UAAU,CAAC,KAAK,EAAE;MACpBS,IAAI,EAAE;IACV,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,SAASC,yBAAyBA,CAACC,UAAe,EAAE;EACvDC,MAAM,CACDC,OAAO,CAACF,UAAU,CAACR,GAAG,CAACE,UAAU,CAACG,WAAW,CAAC,CAC9CM,OAAO,CAAC,CAAC,CAACC,OAAO,EAAEC,GAAG,CAAC,KAAK;IACzBJ,MAAM,CAACK,cAAc,CAACN,UAAU,EAAEI,OAAO,EAAE;MACvCG,GAAG,EAAEA,CAAA,KAAOF,GAAG,CAASG,IAAI,CAACR,UAAU;IAC3C,CAAC,CAAC;EACN,CAAC,CAAC;AACV;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeS,iCAAiCA,CACnDC,WAAmB,EACnBC,eAA4D,EAC5DC,WAAiD,EACjDC,gBAAuD,EACV;EAE7C,IACI,CAACD,WAAW,CAACE,YAAY,IAErBD,gBAAgB,IAChB,CAACA,gBAAgB,CAACC,YACrB,EACH;IACE,MAAMzB,UAAU,CAAC,KAAK,EAAE;MACpB0B,QAAQ,EAAEH;IACd,CAAC,CAAC;EACN;EAEA,IAAMI,KAAa,GAAIJ,WAAW,CAASF,WAAW,CAAC;EACvD,IAAMO,sBAAsB,GAAG,IAAIC,GAAG,CAClCL,gBAAgB,IAAIA,gBAAgB,CAACC,YAAY,GAC3Cb,MAAM,CAACkB,IAAI,CAACN,gBAAgB,CAACC,YAAY,CAAC,GAC1C,EACV,CAAC;EACD,MAAMM,OAAO,CAACC,GAAG,CACbpB,MAAM,CACDC,OAAO,CAACU,WAAW,CAACE,YAAY,CAAC,CACjCQ,GAAG,CAAC,OAAO,CAACC,GAAG,EAAEC,KAAK,CAAC,KAAK;IACzB,IACI,CACI,CAACP,sBAAsB,CAACQ,GAAG,CAACF,GAAG,CAAC,IAE5BV,gBAAgB,IAChBvB,cAAc,CAACuB,gBAAgB,CAACC,YAAY,CAAC,CAACS,GAAG,CAAC,CAACG,MAAM,KAAKF,KAAK,CAACE,MACvE,KAEL,CAAEF,KAAK,CAA2BG,IAAI,EACxC;MACE,IAAMC,cAAc,GAAG,MAAMjB,eAAe,CAACkB,iBAAiB,CAC1Db,KAAK,EACLO,GAAG,EACHC,KAAK,CAACE,MACV,CAAC;MACAF,KAAK,CAA2BG,IAAI,GAAGC,cAAc;IAC1D;EACJ,CAAC,CACT,CAAC;EAED,OAAOhB,WAAW;AACtB","ignoreList":[]}

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

@@ -0,0 +1,202 @@
+import { map } from 'rxjs';
+import { blobToBase64String, blobToString, createBlobFromBase64, flatClone, PROMISE_RESOLVE_VOID } from "../../plugins/utils/index.js";
+import { assignMethodsToAttachment, ensureSchemaSupportsAttachments } from "./attachments-utils.js";
+
+/**
+ * an RxAttachment is basically just the attachment-stub
+ * wrapped so that you can access the attachment-data
+ */
+export var 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;
+    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 blobToString(data);
+    return asString;
+  };
+  _proto.getDataBase64 = async function getDataBase64() {
+    var blob = await this.getData();
+    return blobToBase64String(blob);
+  };
+  return RxAttachment;
+}();
+export 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) {
+  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 = flatClone(docWriteData);
+    docWriteData._attachments = 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));
+}
+export async function putAttachment(attachmentData) {
+  var results = await _putAttachmentsImpl(this, [attachmentData]);
+  return results[0];
+}
+export async function putAttachmentBase64(attachmentData) {
+  ensureSchemaSupportsAttachments(this);
+  var blob = await createBlobFromBase64(attachmentData.data, attachmentData.type);
+  return this.putAttachment({
+    id: attachmentData.id,
+    type: attachmentData.type,
+    data: blob
+  });
+}
+
+/**
+ * Write multiple attachments in a single atomic operation.
+ */
+export function putAttachments(attachments) {
+  return _putAttachmentsImpl(this, attachments);
+}
+
+/**
+ * get an attachment of the document by its id
+ */
+export function getAttachment(id) {
+  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
+ */
+export function allAttachments() {
+  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);
+  });
+}
+export 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;
+  }
+}
+export function postMigrateDocument(_action) {
+  /**
+   * No longer needed because
+   * we store the attachments data buffers directly in the document.
+   */
+  return PROMISE_RESOLVE_VOID;
+}
+export var 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(map(rxDocument => Object.entries(rxDocument.toJSON(true)._attachments)), map(entries => {
+            return entries.map(([id, attachmentData]) => {
+              return fromStorageInstanceResult(id, attachmentData, this);
+            });
+          }));
+        }
+      });
+    }
+  },
+  overwritable: {},
+  hooks: {
+    preMigrateDocument: {
+      after: preMigrateDocument
+    },
+    postMigrateDocument: {
+      after: postMigrateDocument
+    }
+  }
+};
+export * from "./attachments-utils.js";
+//# sourceMappingURL=index.js.map