@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.0

package/src/doc-cache.ts

@@ -7,7 +7,6 @@ import type {
 } from './types/index.d.ts';
 import {
     getFromMapOrThrow,
-    getHeightOfRevision,
     overwriteGetterForCaching,
     requestIdlePromiseNoQueue
 } from './plugins/utils/index.ts';
@@ -57,7 +56,7 @@ declare type CacheItem<RxDocType, OrmMethods> = [
  */
 declare type FinalizationRegistryValue = {
     docId: string;
-    revisionHeight: number;
+    rev: string;
     lwt: number;
 };
 
@@ -91,7 +90,7 @@ export class DocumentCache<RxDocType, OrmMethods> {
             const docId = docMeta.docId;
             const cacheItem = this.cacheItemByDocId.get(docId);
             if (cacheItem) {
-                cacheItem[0].delete(docMeta.revisionHeight + docMeta.lwt + '');
+                cacheItem[0].delete(docMeta.rev + docMeta.lwt);
                 if (cacheItem[0].size === 0) {
                     /**
                      * No state of the document is cached anymore,
@@ -138,8 +137,7 @@ export class DocumentCache<RxDocType, OrmMethods> {
         if (this.tasks.size === 0) {
             return;
         }
-        const tasks = Array.from(this.tasks);
-        tasks.forEach(task => task());
+        this.tasks.forEach(task => task());
         this.tasks.clear();
     }
 
@@ -160,11 +158,11 @@ export class DocumentCache<RxDocType, OrmMethods> {
     }
 
     get getCachedRxDocument(): (docData: RxDocumentData<RxDocType>) => RxDocument<RxDocType, OrmMethods> {
-        const fn = getCachedRxDocumentMonad(this);
+        const fn = getCachedRxDocumentSingle(this);
         return overwriteGetterForCaching(
             this,
             'getCachedRxDocument',
-            doc => fn([doc])[0]
+            fn
         );
     }
 
@@ -186,6 +184,77 @@ export class DocumentCache<RxDocType, OrmMethods> {
     }
 }
 
+/**
+ * @hotPath Dedicated single-document function that avoids array allocations.
+ * Used by getCachedRxDocument which is called from many call sites.
+ */
+function getCachedRxDocumentSingle<RxDocType, OrmMethods>(
+    docCache: DocumentCache<RxDocType, OrmMethods>
+): (docData: RxDocumentData<RxDocType>) => RxDocument<RxDocType, OrmMethods> {
+    const primaryPath = docCache.primaryPath;
+    const cacheItemByDocId = docCache.cacheItemByDocId;
+    const registry = docCache.registry;
+    const deepFreezeWhenDevMode = overwritable.deepFreezeWhenDevMode;
+    const documentCreator = docCache.documentCreator;
+
+    return (docData: RxDocumentData<RxDocType>): RxDocument<RxDocType, OrmMethods> => {
+        const docId: string = (docData as any)[primaryPath];
+        const rev = docData._rev;
+        const lwt = docData._meta.lwt;
+        const cacheKey = rev + lwt;
+
+        const cacheItem = cacheItemByDocId.get(docId);
+        if (!cacheItem) {
+            docData = deepFreezeWhenDevMode(docData) as any;
+            const newDoc = documentCreator(docData) as RxDocument<RxDocType, OrmMethods>;
+            const newByRev = new Map<string, WeakRef<RxDocument<RxDocType, OrmMethods>>>();
+            newByRev.set(cacheKey, createWeakRefWithFallback(newDoc));
+            cacheItemByDocId.set(docId, [newByRev, docData]);
+            if (registry) {
+                docCache.tasks.add(() => {
+                    registry.register(newDoc, {
+                        docId: newDoc.primary,
+                        rev,
+                        lwt
+                    });
+                });
+                if (docCache.tasks.size <= 1) {
+                    requestIdlePromiseNoQueue().then(() => {
+                        docCache.processTasks();
+                    });
+                }
+            }
+            return newDoc;
+        }
+
+        const byRev = cacheItem[0];
+        const cachedRxDocumentWeakRef = byRev.get(cacheKey);
+        let cachedRxDocument = cachedRxDocumentWeakRef ? cachedRxDocumentWeakRef.deref() : undefined;
+        if (!cachedRxDocument) {
+            docData = deepFreezeWhenDevMode(docData) as any;
+            cachedRxDocument = documentCreator(docData) as RxDocument<RxDocType, OrmMethods>;
+            byRev.set(cacheKey, createWeakRefWithFallback(cachedRxDocument));
+            if (registry) {
+                const registeredDoc = cachedRxDocument;
+                docCache.tasks.add(() => {
+                    registry.register(registeredDoc, {
+                        docId: registeredDoc.primary,
+                        rev,
+                        lwt
+                    });
+                });
+                if (docCache.tasks.size <= 1) {
+                    requestIdlePromiseNoQueue().then(() => {
+                        docCache.processTasks();
+                    });
+                }
+            }
+        }
+        return cachedRxDocument;
+    };
+}
+
+
 /**
  * This function is called very very often.
  * @hotPath This is one of the most important methods for performance.
@@ -201,58 +270,65 @@ function getCachedRxDocumentMonad<RxDocType, OrmMethods>(
     const documentCreator = docCache.documentCreator;
     const fn: (docsData: RxDocumentData<RxDocType>[]) => RxDocument<RxDocType, OrmMethods>[] = (docsData: RxDocumentData<RxDocType>[]) => {
         const ret: RxDocument<RxDocType, OrmMethods>[] = new Array(docsData.length);
-        const registryTasks: RxDocument<RxDocType, OrmMethods>[] = [];
+        let registryTasks: { doc: RxDocument<RxDocType, OrmMethods>; rev: string; lwt: number; }[] | undefined;
         for (let index = 0; index < docsData.length; index++) {
             let docData = docsData[index];
             const docId: string = (docData as any)[primaryPath];
 
-            const revisionHeight = getHeightOfRevision(docData._rev);
+            const rev = docData._rev;
+            const lwt = docData._meta.lwt;
+            const cacheKey = rev + lwt;
 
-            /**
-             * @performance
-             * Compute the byRev cache key once and reuse it
-             * for both the Map.get() and Map.set() calls.
-             */
-            const cacheKey = revisionHeight + docData._meta.lwt + '';
-
-            let byRev: Map<string, WeakRef<RxDocument<RxDocType, OrmMethods>>>;
-            let cachedRxDocumentWeakRef: WeakRef<RxDocument<RxDocType, OrmMethods>> | undefined;
-            let cacheItem = cacheItemByDocId.get(docId);
+            const cacheItem = cacheItemByDocId.get(docId);
             if (!cacheItem) {
-                byRev = new Map();
-                cacheItem = [
-                    byRev,
-                    docData
-                ];
-                cacheItemByDocId.set(docId, cacheItem);
-            } else {
-                byRev = cacheItem[0];
-                cachedRxDocumentWeakRef = byRev.get(cacheKey);
-            }
-            let cachedRxDocument = cachedRxDocumentWeakRef ? cachedRxDocumentWeakRef.deref() : undefined;
-            if (!cachedRxDocument) {
+                /**
+                 * New document - no need for WeakRef lookup.
+                 * Create cache item directly.
+                 */
                 docData = deepFreezeWhenDevMode(docData) as any;
-                cachedRxDocument = documentCreator(docData) as RxDocument<RxDocType, OrmMethods>;
+                const cachedRxDocument = documentCreator(docData) as RxDocument<RxDocType, OrmMethods>;
+                const byRev = new Map<string, WeakRef<RxDocument<RxDocType, OrmMethods>>>();
                 byRev.set(cacheKey, createWeakRefWithFallback(cachedRxDocument));
+                cacheItemByDocId.set(docId, [byRev, docData]);
+                ret[index] = cachedRxDocument;
                 if (registry) {
-                    registryTasks.push(cachedRxDocument);
+                    if (!registryTasks) {
+                        registryTasks = [];
+                    }
+                    registryTasks.push({ doc: cachedRxDocument, rev, lwt });
+                }
+            } else {
+                const byRev = cacheItem[0];
+                const cachedRxDocumentWeakRef = byRev.get(cacheKey);
+                let cachedRxDocument = cachedRxDocumentWeakRef ? cachedRxDocumentWeakRef.deref() : undefined;
+                if (!cachedRxDocument) {
+                    docData = deepFreezeWhenDevMode(docData) as any;
+                    cachedRxDocument = documentCreator(docData) as RxDocument<RxDocType, OrmMethods>;
+                    byRev.set(cacheKey, createWeakRefWithFallback(cachedRxDocument));
+                    if (registry) {
+                        if (!registryTasks) {
+                            registryTasks = [];
+                        }
+                        registryTasks.push({ doc: cachedRxDocument, rev, lwt });
+                    }
                 }
+                ret[index] = cachedRxDocument;
             }
-            ret[index] = cachedRxDocument;
         }
-        if (registryTasks.length > 0 && registry) {
+        if (registryTasks && registry) {
             /**
              * Calling registry.register() has shown to have
              * really bad performance. So we add the cached documents
              * lazily.
              */
+            const tasks = registryTasks;
             docCache.tasks.add(() => {
-                for (let index = 0; index < registryTasks.length; index++) {
-                    const doc = registryTasks[index];
-                    registry.register(doc, {
-                        docId: doc.primary,
-                        revisionHeight: getHeightOfRevision(doc.revision),
-                        lwt: doc._data._meta.lwt
+                for (let index = 0; index < tasks.length; index++) {
+                    const task = tasks[index];
+                    registry.register(task.doc, {
+                        docId: task.doc.primary,
+                        rev: task.rev,
+                        lwt: task.lwt
                     });
                 }
             });

package/src/event-reduce.ts

@@ -109,7 +109,16 @@ export function calculateNewResults<RxDocumentType>(
     }
     const queryParams = getQueryParams(rxQuery);
     const previousResults: RxDocumentType[] = ensureNotFalsy(rxQuery._result).docsData.slice(0);
-    const previousResultsMap: Map<string, RxDocumentType> = ensureNotFalsy(rxQuery._result).docsDataMap;
+    /**
+     * Copy the map to avoid mutating the cached docsDataMap on the result object.
+     * runAction() modifies the map in-place (adds/removes entries),
+     * which would corrupt the cached map if a later event triggers runFullQueryAgain
+     * and the full re-exec returns the same results (keeping the old result object).
+     * On subsequent event-reduce calls, the corrupted map would cause incorrect
+     * results because insertAtSortPosition checks keyDocumentMap.has(docId)
+     * to decide whether to skip insertion.
+     */
+    const previousResultsMap: Map<string, RxDocumentType> = new Map(ensureNotFalsy(rxQuery._result).docsDataMap);
     let changed: boolean = false;
 
 

package/src/plugin-helpers.ts

@@ -23,6 +23,7 @@ import {
     getFromMapOrCreate,
     requestIdleCallbackIfAvailable
 } from './plugins/utils/index.ts';
+import { newRxError } from './rx-error.ts';
 import { BehaviorSubject, firstValueFrom } from 'rxjs';
 
 
@@ -242,6 +243,9 @@ export function wrapRxStorageInstance<RxDocType>(
         query: (preparedQuery) => {
             return instance.query(preparedQuery)
                 .then(queryResult => {
+                    if (typeof queryResult === 'string') {
+                        throw newRxError('EN5', { method: 'query' });
+                    }
                     return Promise.all(queryResult.documents.map(doc => fromStorage(doc)));
                 })
                 .then(documents => ({ documents: documents as any }));
@@ -258,6 +262,9 @@ export function wrapRxStorageInstance<RxDocType>(
         findDocumentsById: (ids, deleted) => {
             return instance.findDocumentsById(ids, deleted)
                 .then(async (findResult) => {
+                    if (typeof findResult === 'string') {
+                        throw newRxError('EN5', { method: 'findDocumentsById' });
+                    }
                     const ret: RxDocumentData<RxDocType>[] = [];
                     await Promise.all(
                         findResult
@@ -271,6 +278,9 @@ export function wrapRxStorageInstance<RxDocType>(
         getChangedDocumentsSince: !instance.getChangedDocumentsSince ? undefined : (limit, checkpoint) => {
             return ((instance as any).getChangedDocumentsSince)(limit, checkpoint)
                 .then(async (result: any) => {
+                    if (typeof result === 'string') {
+                        throw newRxError('EN5', { method: 'getChangedDocumentsSince' });
+                    }
                     return {
                         checkpoint: result.checkpoint,
                         documents: await Promise.all(

package/src/plugins/attachments/index.ts

@@ -283,18 +283,16 @@ export const RxDBAttachmentsPlugin: RxPlugin = {
                 get: function allAttachments$(this: RxDocument) {
                     return this.$
                         .pipe(
-                            map((rxDocument: RxDocument) => Object.entries(
-                                rxDocument.toJSON(true)._attachments
-                            )),
-                            map((entries: [string, any][]) => {
-                                return entries
-                                    .map(([id, attachmentData]: [string, any]) => {
-                                        return fromStorageInstanceResult(
-                                            id,
-                                            attachmentData,
-                                            this
-                                        );
-                                    });
+                            map((rxDocument: RxDocument) => {
+                                return Object.entries(
+                                    rxDocument.toJSON(true)._attachments
+                                ).map(([id, attachmentData]: [string, any]) => {
+                                    return fromStorageInstanceResult(
+                                        id,
+                                        attachmentData,
+                                        rxDocument
+                                    );
+                                });
                             })
                         );
                 }

package/src/plugins/cleanup/cleanup.ts

@@ -93,6 +93,9 @@ export async function cleanupRxCollection(
                     return true;
                 }
                 await rxDatabase.requestIdlePromise();
+                if (rxCollection.closed) {
+                    return true;
+                }
                 const allDone: Promise<boolean>[] = [];
                 allDone.push(storageInstance.cleanup(cleanupPolicy.minimumDeletedTime));
                 const replicationStates = getFromMapOrCreate(
@@ -102,13 +105,12 @@ export async function cleanupRxCollection(
                 );
                 for (const replicationState of replicationStates) {
                     const meta = replicationState.metaInstance;
-                    if (meta) {
+                    if (meta && !replicationState.isStopped()) {
                         allDone.push(meta.cleanup(cleanupPolicy.minimumDeletedTime));
                     }
                 }
 
-                const hasFalse = (await Promise.all(allDone)).find(v => !v);
-                return !hasFalse;
+                return (await Promise.all(allDone)).every(v => v);
             });
         isDone = await RXSTORAGE_CLEANUP_QUEUE;
     }

package/src/plugins/crdt/index.ts

@@ -33,6 +33,7 @@ import {
     RxError
 } from '../../index.ts';
 import { mingoUpdater } from '../update/mingo-updater.ts';
+import { fillObjectWithDefaults } from '../../rx-schema-helper.ts';
 
 
 
@@ -352,6 +353,43 @@ export const RxDBcrdtPlugin: RxPlugin = {
                 });
             };
 
+            const oldincrementalRemove = proto.incrementalRemove;
+            proto.incrementalRemove = function (this: RxDocument) {
+                if (!this.collection.schema.jsonSchema.crdt) {
+                    return oldincrementalRemove.call(this);
+                }
+                return this.updateCRDT({
+                    ifMatch: {
+                        $set: {
+                            _deleted: true
+                        }
+                    }
+                });
+            };
+
+            const oldModify = proto.modify;
+            proto.modify = function (this: RxDocument, fn: any, context?: string) {
+                if (!this.collection.schema.jsonSchema.crdt) {
+                    return oldModify.call(this, fn, context);
+                }
+                throw newRxError('CRDT4', {
+                    id: this.primary,
+                    args: { method: 'modify' }
+                });
+            };
+
+            const oldPatch = proto.patch;
+            proto.patch = function (this: RxDocument, patch: any) {
+                if (!this.collection.schema.jsonSchema.crdt) {
+                    return oldPatch.call(this, patch);
+                }
+                return this.updateCRDT({
+                    ifMatch: {
+                        $set: patch
+                    }
+                });
+            };
+
             const oldincrementalPatch = proto.incrementalPatch;
             proto.incrementalPatch = function (this: RxDocument, patch: any) {
                 if (!this.collection.schema.jsonSchema.crdt) {
@@ -377,6 +415,16 @@ export const RxDBcrdtPlugin: RxPlugin = {
                     });
                 }
             };
+
+            const oldUpdate = proto.update;
+            proto.update = function (this: RxDocument, updateObj: any) {
+                if (!this.collection.schema.jsonSchema.crdt) {
+                    return oldUpdate.call(this, updateObj);
+                }
+                return this.updateCRDT({
+                    ifMatch: updateObj
+                });
+            };
         },
         RxCollection: (proto: any) => {
             proto.insertCRDT = insertCRDT;
@@ -468,6 +516,13 @@ export const RxDBcrdtPlugin: RxPlugin = {
                     const storageToken = await collection.database.storageToken;
                     const useDocsData = await Promise.all(
                         docsData.map(async (docData) => {
+                            /**
+                             * Fill schema default values before creating CRDT operations,
+                             * so that default values are captured in the operations and
+                             * will be preserved during rebuildFromCRDT (conflict resolution).
+                             */
+                            fillObjectWithDefaults(collection.schema, docData);
+
                             const setMe: Partial<RxDocumentData<any>> = {};
                             Object.entries(docData).forEach(([key, value]) => {
                                 if (

package/src/plugins/dev-mode/check-query.ts

@@ -50,7 +50,13 @@ export function checkQuery(args: RxPluginPreCreateRxQueryArgs) {
         }
     });
 
-    // do not allow skip or limit for count queries
+    /**
+     * Count queries cannot use skip or limit.
+     * The storage.count() method returns the total number of matching documents
+     * and is designed to ignore skip/limit (see rx-storage.interface.d.ts).
+     * This is intentional by design - count should always return the total.
+     * @intentional This is correct behavior, not a bug.
+     */
     if (
         args.op === 'count' &&
         (

package/src/plugins/dev-mode/check-schema.ts

@@ -314,10 +314,11 @@ export function checkSchema(jsonSchema: RxJsonSchema<any>) {
     validateFieldsDeep(jsonSchema);
     checkPrimaryKey(jsonSchema);
 
+    const primaryPath = getPrimaryFieldOfPrimaryKey(jsonSchema.primaryKey);
     Object.keys(jsonSchema.properties).forEach(key => {
         const value: any = jsonSchema.properties[key];
         // check primary
-        if (key === jsonSchema.primaryKey) {
+        if (key === primaryPath) {
             if (jsonSchema.indexes && jsonSchema.indexes.includes(key)) {
                 throw newRxError('SC13', {
                     value,

package/src/plugins/dev-mode/error-messages.ts

@@ -122,7 +122,7 @@ export const ERROR_MESSAGES = {
     },
     QU10: {
         message: 'result empty and throwIfMissing: true',
-        cause: 'exec(true) was called but the document was not found.',
+        cause: 'exec(true) or remove(true) was called on a findOne() query but the document was not found.',
         fix: 'Ensure the document exists or do not use the throwIfMissing flag.',
         docs: ''
     },
@@ -450,7 +450,7 @@ export const ERROR_MESSAGES = {
         docs: 'https://rxdb.info/transactions-conflicts-revisions.html?console=errors&code=CONFLICT'
     },
     COL22: {
-        message: '.bulkInsert() and .bulkUpsert() cannot be run with multiple documents that have the same primary key',
+        message: '.bulkInsert() and .bulkUpsert() cannot be run with multiple documents that have the same primary key. Conflicting primary key(s) are in the error parameters (duplicateIds)',
         cause: 'You provided multiple documents with the same primary key in a bulk write.',
         fix: 'Ensure all documents in a bulk write have unique primary keys.',
         docs: ''
@@ -693,6 +693,12 @@ export const ERROR_MESSAGES = {
         fix: 'Check the password.',
         docs: 'https://rxdb.info/encryption.html?console=errors&code=EN4'
     },
+    EN5: {
+        message: 'Storage wrapper received a string instead of an array from the storage. This happens when a storage like OPFS is used inside of a worker and the usesRxDatabaseInWorker option is not set.',
+        cause: 'Some RxStorage implementations (like OPFS) return JSON strings instead of arrays for performance. When you wrap such a storage with encryption (or other plugins) inside of a worker, the wrapper receives the raw string and cannot process it.',
+        fix: 'Set usesRxDatabaseInWorker: true in your storage options. For example: getRxStorageOPFS({ usesRxDatabaseInWorker: true }).',
+        docs: 'https://rxdb.info/encryption.html?console=errors&code=EN5'
+    },
 
     // plugins/json-dump.js
     JD1: {
@@ -1163,6 +1169,12 @@ export const ERROR_MESSAGES = {
         fix: 'Remove the custom conflict handler.',
         docs: 'https://rxdb.info/crdt.html?console=errors&code=CRDT3'
     },
+    CRDT4: {
+        message: 'RxDocument.modify() cannot be used when CRDTs are activated.',
+        cause: 'modify() takes an arbitrary function that cannot be converted to a CRDT operation.',
+        fix: 'Use updateCRDT() instead of modify().',
+        docs: 'https://rxdb.info/crdt.html?console=errors&code=CRDT4'
+    },
 
     // plugins/storage-dexie/
     DXE1: {
@@ -1267,6 +1279,12 @@ export const ERROR_MESSAGES = {
         fix: 'Try to reproduce the error in a unit test and make a PR with a test case.',
         docs: 'https://rxdb.info/replication-google-drive.html?console=errors&code=GDR19'
     },
+    GDR20: {
+        message: 'Document file update conflict',
+        cause: 'Another client modified the document file during the transaction. This indicates a transaction timeout overlap.',
+        fix: 'Increase the transactionTimeout or investigate why two clients are writing to the same document concurrently.',
+        docs: 'https://rxdb.info/replication-google-drive.html?console=errors&code=GDR20'
+    },
 
 
 
@@ -1316,6 +1334,28 @@ export const ERROR_MESSAGES = {
         docs: ''
     },
 
+    // custom-index errors
+    CI1: {
+        message: 'Field not in schema',
+        cause: 'The given field is not defined in the RxJsonSchema.',
+        fix: 'Make sure the field name is spelled correctly and exists in the schema.',
+        docs: ''
+    },
+    CI2: {
+        message: 'Unknown index type',
+        cause: 'The schema field type is not supported for indexing.',
+        fix: 'Use a supported type (string, boolean, number, integer) for the indexed field.',
+        docs: ''
+    },
+
+    // change-event-buffer errors
+    COB1: {
+        message: 'ChangeEventBuffer out of bounds',
+        cause: 'The requested pointer is out of the change event buffer bounds.',
+        fix: 'This means something in RxDB itself behaves wrong because any access to the api should not make an out of bounds request.',
+        docs: ''
+    },
+
     /**
      * Should never be thrown, use this for
      * null checks etc. so you do not have to increase the
@@ -1323,9 +1363,9 @@ export const ERROR_MESSAGES = {
      */
     SNH: {
         message: 'This should never happen',
-        cause: '',
-        fix: '',
-        docs: ''
+        cause: 'Should never be thrown. This error code is used for internal things like null-checks etc.',
+        fix: 'If this throws, you likely found a bug and should make a PR with a test case to the RxDB repo, so we can reproduce it.',
+        docs: 'https://rxdb.info/contribution.html'
     },
 };
 

package/src/plugins/encryption-crypto-js/index.ts

@@ -97,12 +97,24 @@ export function wrappedKeyEncryptionCryptoJsStorage<Internals, InstanceCreationO
 
                 /**
                  * Encrypted data is always stored as string
-                 * so we have to change the schema to have "type": "string"
-                 * on encrypted fields.
+                 * so we have to replace the schema definition of
+                 * encrypted fields with just {type: 'string'}.
+                 * All type-specific keywords (properties, required,
+                 * items, maxLength, enum etc.) must be removed because
+                 * they do not apply to the encrypted ciphertext string.
                  */
                 ensureNotFalsy(params.schema.encrypted).forEach(key => {
-                    (schemaWithoutEncrypted as any).properties[key].type = 'string';
-                    delete (schemaWithoutEncrypted as any).properties[key].properties;
+                    const pathParts = key.split('.');
+                    if (pathParts.length === 1) {
+                        (schemaWithoutEncrypted as any).properties[key] = { type: 'string' };
+                    } else {
+                        // Navigate nested schema structure: properties.a.properties.b.properties.c
+                        let currentSchemaLevel: any = schemaWithoutEncrypted;
+                        for (let i = 0; i < pathParts.length - 1; i++) {
+                            currentSchemaLevel = currentSchemaLevel.properties[pathParts[i]];
+                        }
+                        currentSchemaLevel.properties[pathParts[pathParts.length - 1]] = { type: 'string' };
+                    }
                 });
 
                 const instance = await args.storage.createStorageInstance(
@@ -208,13 +220,13 @@ function cloneWithoutAttachments<T>(data: RxDocumentWriteData<T>): RxDocumentDat
 function validatePassword(password: string) {
     if (typeof password !== 'string') {
         throw newRxTypeError('EN1', {
-            password
+            passwordType: typeof password
         });
     }
     if (password.length < MINIMUM_PASSWORD_LENGTH) {
         throw newRxError('EN2', {
             minPassLength: MINIMUM_PASSWORD_LENGTH,
-            password
+            passwordLength: password.length
         });
     }
 }

package/src/plugins/leader-election/index.ts

@@ -21,6 +21,8 @@ import { PROMISE_RESOLVE_TRUE, getFromMapOrCreate } from '../utils/index.ts';
 const LEADER_ELECTORS_OF_DB: WeakMap<RxDatabase, LeaderElector> = new WeakMap();
 const LEADER_ELECTOR_BY_BROADCAST_CHANNEL: WeakMap<BroadcastChannel, LeaderElector> = new WeakMap();
 
+export const OPEN_LEADER_ELECTORS: Set<LeaderElector> = new Set();
+
 
 /**
  * Returns the leader elector of a broadcast channel.
@@ -64,14 +66,12 @@ export function getForDatabase(this: RxDatabase): LeaderElector {
     };
 
 
-    let elector = getLeaderElectorByBroadcastChannel(broadcastChannel);
-    if (!elector) {
-        elector = getLeaderElectorByBroadcastChannel(broadcastChannel);
-        LEADER_ELECTORS_OF_DB.set(
-            this,
-            elector
-        );
-    }
+    const elector = getLeaderElectorByBroadcastChannel(broadcastChannel);
+    LEADER_ELECTORS_OF_DB.set(
+        this,
+        elector
+    );
+    OPEN_LEADER_ELECTORS.add(elector);
 
     /**
      * Overwrite for caching
@@ -105,6 +105,7 @@ export function onClose(db: RxDatabase) {
     const has = LEADER_ELECTORS_OF_DB.get(db);
     if (has) {
         has.die();
+        OPEN_LEADER_ELECTORS.delete(has);
     }
 }