@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.1

package/src/plugins/storage-mongodb/rx-storage-instance-mongodb.ts

@@ -51,7 +51,9 @@ import {
     getMongoDBIndexName,
     prepareMongoDBQuery,
     swapMongoToRxDoc,
-    swapRxDocToMongo
+    swapRxDocToMongo,
+    getMongoDBClient,
+    closeMongoDBClient
 } from './mongodb-helper.ts';
 
 export class RxStorageInstanceMongoDB<RxDocType> implements RxStorageInstance<
@@ -65,7 +67,6 @@ export class RxStorageInstanceMongoDB<RxDocType> implements RxStorageInstance<
     public readonly inMongoPrimaryPath: string;
     public closed?: Promise<void>;
     private readonly changes$: Subject<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>> = new Subject();
-    public readonly mongoClient: MongoClient;
     public readonly mongoDatabase: MongoDatabase;
     public readonly mongoCollectionPromise: Promise<MongoCollection<RxDocumentData<RxDocType> | any>>;
     // public mongoChangeStream?: MongoChangeStream<any, ChangeStreamDocument<any>>;
@@ -94,15 +95,14 @@ export class RxStorageInstanceMongoDB<RxDocType> implements RxStorageInstance<
         public readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>,
         public readonly internals: MongoDBStorageInternals,
         public readonly options: Readonly<RxStorageMongoDBInstanceCreationOptions>,
-        public readonly settings: RxStorageMongoDBSettings
+        public readonly settings: RxStorageMongoDBSettings,
+        public readonly mongoClient: MongoClient
     ) {
         if (this.schema.attachments) {
             throw new Error('attachments not supported in mongodb storage, make a PR if you need that');
         }
         this.primaryPath = getPrimaryFieldOfPrimaryKey(this.schema.primaryKey);
         this.inMongoPrimaryPath = this.primaryPath === '_id' ? MONGO_ID_SUBSTITUTE_FIELDNAME : this.primaryPath;
-
-        this.mongoClient = new MongoClient(storage.databaseSettings.connection, MONGO_OPTIONS_DRIVER_INFO);
         this.mongoDatabase = this.mongoClient.db(databaseName + '-v' + this.schema.version);
 
         const indexes = (this.schema.indexes ? this.schema.indexes.slice() : []).map(index => {
@@ -440,17 +440,18 @@ export class RxStorageInstanceMongoDB<RxDocType> implements RxStorageInstance<
             await this.mongoCollectionPromise;
             await firstValueFrom(this.runningOperations.pipe(filter((c: number) => c === 0)));
             // await ensureNotFalsy(this.mongoChangeStream).close();
-            await this.mongoClient.close();
+            await closeMongoDBClient(this.storage.databaseSettings.connection);
         })();
         return this.closed;
     }
 }
 
-export function createMongoDBStorageInstance<RxDocType>(
+export async function createMongoDBStorageInstance<RxDocType>(
     storage: RxStorageMongoDB,
     params: RxStorageInstanceCreationParams<RxDocType, RxStorageMongoDBInstanceCreationOptions>,
     settings: RxStorageMongoDBSettings
 ): Promise<RxStorageInstanceMongoDB<RxDocType>> {
+    const mongoClient = await getMongoDBClient(storage.databaseSettings.connection);
     const instance = new RxStorageInstanceMongoDB(
         storage,
         params.databaseName,
@@ -458,7 +459,8 @@ export function createMongoDBStorageInstance<RxDocType>(
         params.schema,
         {},
         params.options,
-        settings
+        settings,
+        mongoClient
     );
-    return Promise.resolve(instance);
+    return instance;
 }

package/src/plugins/test-utils/config.ts

@@ -40,7 +40,8 @@ function getEnvVariables() {
         const ret: any = {};
         [
             'DEFAULT_STORAGE',
-            'NODE_ENV'
+            'NODE_ENV',
+            'STORAGE_PASSWORD'
         ].forEach(k => {
             ret[k] = Deno.env.get(k);
         });

package/src/plugins/test-utils/performance.ts

@@ -53,6 +53,42 @@ export type PerformanceTestConfig = {
      * @default true
      */
     log?: boolean;
+    /**
+     * If set, the database will be created with encryption
+     * and the schema will mark applicable fields as encrypted.
+     */
+    password?: any;
+    /**
+     * Whether to run the bulk find-by-ids test.
+     * @default true
+     */
+    testBulkFindByIds?: boolean;
+    /**
+     * Whether to run the serial find-by-id test.
+     * @default true
+     */
+    testSerialFindById?: boolean;
+    /**
+     * Whether to run the find-by-query test.
+     * @default true
+     */
+    testFindByQuery?: boolean;
+    /**
+     * Whether to run the find-by-query-parallel test.
+     * @default true
+     */
+    testFindByQueryParallel?: boolean;
+    /**
+     * Whether to run the count query test.
+     * @default true
+     */
+    testCount?: boolean;
+    /**
+     * Whether to run the property access test.
+     * Requires testFindByQuery to also be enabled.
+     * @default true
+     */
+    testPropertyAccess?: boolean;
 };
 
 export type PerformanceTestResult = {
@@ -84,11 +120,23 @@ export async function runPerformanceTests(
         parallelQueryAmount = 4,
         insertBatches = 6,
         waitBetweenTests = 100,
-        log = true
+        log = true,
+        password
     } = config;
+    const testBulkFindByIds = config.testBulkFindByIds !== false;
+    const testSerialFindById = config.testSerialFindById !== false;
+    const testFindByQuery = config.testFindByQuery !== false;
+    const testFindByQueryParallel = config.testFindByQueryParallel !== false;
+    const testCount = config.testCount !== false;
+    const testPropertyAccess = config.testPropertyAccess !== false;
 
     const totalTimes: { [k: string]: number[]; } = {};
 
+    // Generate dbName outside the loop to reuse the exact same MongoDB database.
+    // This allows `.remove()` to drop the old collections and the next run to cleanly reuse the same 
+    // namespace, avoiding creating thousands of collections on the DB server causing file exhaustion.
+    const dbName = 'test-db-performance-' + randomToken(10);
+
     let runsDone = 0;
     while (runsDone < runs) {
         if (log) {
@@ -115,8 +163,16 @@ export async function runPerformanceTests(
         updateTime();
 
         // create database
-        const dbName = 'test-db-performance-' + randomToken(10);
         const schema = averageSchema();
+        if (password) {
+            schema.encrypted = ['deep', 'list'];
+            schema.indexes = schema.indexes!.filter(index => {
+                if (typeof index === 'string') {
+                    return !index.startsWith('deep.');
+                }
+                return !index.some(field => field.startsWith('deep.'));
+            });
+        }
         let collection: RxCollection<AverageSchemaDocumentType>;
         async function createDbWithCollections() {
             if (collection) {
@@ -133,7 +189,8 @@ export async function runPerformanceTests(
                  * creation time.
                 */
                 multiInstance: false,
-                storage
+                storage,
+                password
             });
 
             // create collections
@@ -183,18 +240,20 @@ export async function runPerformanceTests(
             await awaitBetweenTest(waitBetweenTests);
         }
 
-        // refresh db to ensure we do not run on caches
-        collection = await createDbWithCollections();
-        await awaitBetweenTest(waitBetweenTests);
+        if (testBulkFindByIds) {
+            // refresh db to ensure we do not run on caches
+            collection = await createDbWithCollections();
+            await awaitBetweenTest(waitBetweenTests);
 
-        /**
-         * Bulk Find by id
-         */
-        updateTime();
-        const idsResult = await collection.findByIds(docIds).exec();
-        updateTime('find-by-ids-' + docsAmount);
-        assert.strictEqual(Array.from(idsResult.keys()).length, docsAmount, 'find-by-id amount');
-        await awaitBetweenTest(waitBetweenTests);
+            /**
+             * Bulk Find by id
+             */
+            updateTime();
+            const idsResult = await collection.findByIds(docIds).exec();
+            updateTime('find-by-ids-' + docsAmount);
+            assert.strictEqual(Array.from(idsResult.keys()).length, docsAmount, 'find-by-id amount');
+            await awaitBetweenTest(waitBetweenTests);
+        }
 
         /**
          * Serial inserts
@@ -212,86 +271,101 @@ export async function runPerformanceTests(
         }
         updateTime('serial-inserts-' + serialDocsAmount);
 
-        // refresh db to ensure we do not run on caches
-        collection = await createDbWithCollections();
-        await awaitBetweenTest(waitBetweenTests);
+        if (testSerialFindById || testFindByQuery) {
+            // refresh db to ensure we do not run on caches
+            collection = await createDbWithCollections();
+            await awaitBetweenTest(waitBetweenTests);
+        }
 
-        /**
-         * Serial find-by-id
-         */
-        updateTime();
-        for (const id of serialIds) {
-            await collection.findByIds([id]).exec();
+        if (testSerialFindById) {
+            /**
+             * Serial find-by-id
+             */
+            updateTime();
+            for (const id of serialIds) {
+                await collection.findByIds([id]).exec();
+            }
+            updateTime('serial-find-by-id-' + serialDocsAmount);
+            await awaitBetweenTest(waitBetweenTests);
         }
-        updateTime('serial-find-by-id-' + serialDocsAmount);
-        await awaitBetweenTest(waitBetweenTests);
 
-        // find by query
-        updateTime();
-        const query = collection.find({
-            selector: {},
-            sort: [
-                { var2: 'asc' },
-                { var1: 'asc' }
-            ]
-        });
-        const queryResult = await query.exec();
-        updateTime('find-by-query');
-        assert.strictEqual(queryResult.length, docsAmount + serialDocsAmount, 'find-by-query');
+        let queryResult: any[] | undefined;
+        if (testFindByQuery) {
+            // find by query
+            updateTime();
+            const query = collection.find({
+                selector: {},
+                sort: [
+                    { var2: 'asc' },
+                    { var1: 'asc' }
+                ]
+            });
+            queryResult = await query.exec();
+            updateTime('find-by-query');
+            assert.strictEqual(queryResult.length, docsAmount + serialDocsAmount, 'find-by-query');
+        }
 
-        // refresh db to ensure we do not run on caches
-        collection = await createDbWithCollections();
-        await awaitBetweenTest(waitBetweenTests);
+        if (testFindByQueryParallel || testCount) {
+            // refresh db to ensure we do not run on caches
+            collection = await createDbWithCollections();
+            await awaitBetweenTest(waitBetweenTests);
+        }
 
-        // find by multiple queries in parallel
-        updateTime();
-        const parallelResult = await Promise.all(
-            new Array(parallelQueryAmount).fill(0).map((_v, idx) => {
-                const subQuery = collection.find({
+        if (testFindByQueryParallel) {
+            // find by multiple queries in parallel
+            updateTime();
+            const parallelResult = await Promise.all(
+                new Array(parallelQueryAmount).fill(0).map((_v, idx) => {
+                    const subQuery = collection.find({
+                        selector: {
+                            var2: idx
+                        }
+                    });
+                    return subQuery.exec();
+                })
+            );
+            updateTime('find-by-query-parallel-' + parallelQueryAmount);
+            let parallelSum = 0;
+            parallelResult.forEach(r => parallelSum = parallelSum + r.length);
+            assert.strictEqual(parallelSum, docsAmount, 'parallelSum');
+            await awaitBetweenTest(waitBetweenTests);
+        }
+
+        if (testCount) {
+            // run count query
+            updateTime();
+            let t = 0;
+            while (t < parallelQueryAmount) {
+                const countQuery = collection.count({
                     selector: {
-                        var2: idx
+                        var2: {
+                            $eq: t
+                        }
                     }
                 });
-                return subQuery.exec();
-            })
-        );
-        updateTime('find-by-query-parallel-' + parallelQueryAmount);
-        let parallelSum = 0;
-        parallelResult.forEach(r => parallelSum = parallelSum + r.length);
-        assert.strictEqual(parallelSum, docsAmount, 'parallelSum');
-        await awaitBetweenTest(waitBetweenTests);
-
-        // run count query
-        updateTime();
-        let t = 0;
-        while (t < parallelQueryAmount) {
-            const countQuery = collection.count({
-                selector: {
-                    var2: {
-                        $eq: t
-                    }
-                }
-            });
-            const countQueryResult = await countQuery.exec();
-            assert.ok(countQueryResult >= ((docsAmount / insertBatches) - 5), 'count A ' + countQueryResult);
-            assert.ok(countQueryResult < (docsAmount * 0.8), 'count B ' + countQueryResult);
-            t++;
+                const countQueryResult = await countQuery.exec();
+                assert.ok(countQueryResult >= ((docsAmount / insertBatches) - 5), 'count A ' + countQueryResult);
+                assert.ok(countQueryResult < (docsAmount * 0.8), 'count B ' + countQueryResult);
+                t++;
+            }
+            updateTime('4x-count');
+            await awaitBetweenTest(waitBetweenTests);
         }
-        updateTime('4x-count');
-        await awaitBetweenTest(waitBetweenTests);
 
-        // test property access time
-        updateTime();
-        let sum = 0;
-        for (let i = 0; i < queryResult.length; i++) {
-            const doc = queryResult[i];
+        if (testPropertyAccess && testFindByQuery && queryResult) {
+            // test property access time
+            updateTime();
+            let sum = 0;
+            for (let i = 0; i < queryResult.length; i++) {
+                const doc = queryResult[i];
 
-            // access the same property exactly 2 times
-            sum += doc.deep.deeper.deepNr;
-            sum += doc.deep.deeper.deepNr;
+                // access the same property exactly 2 times
+                sum += doc.deep.deeper.deepNr;
+                sum += doc.deep.deeper.deepNr;
+            }
+            updateTime('property-access');
+            assert.ok(sum > 10);
         }
-        updateTime('property-access');
-        assert.ok(sum > 10);
 
         await collection.database.remove();
     }
@@ -302,7 +376,7 @@ export async function runPerformanceTests(
         docsAmount
     };
     Object.entries(totalTimes).forEach(([key, times]) => {
-        result[key] = roundToThree(averageOfTimeValues(times, 95));
+        result[key] = roundToTwo(averageOfTimeValues(times, 95));
     });
 
     if (log) {
@@ -330,8 +404,8 @@ export function averageOfTimeValues(
     return total / useNumbers.length;
 }
 
-function roundToThree(num: number) {
-    return Math.round(num * 1000) / 1000;
+function roundToTwo(num: number) {
+    return Math.round(num * 100) / 100;
 }
 
 async function awaitBetweenTest(waitMs: number) {

package/src/plugins/test-utils/schema-objects.ts

@@ -236,7 +236,7 @@ export interface SimpleHeroArrayDocumentType {
 }
 export function simpleHeroArray(partial: Partial<SimpleHeroArrayDocumentType> = {}): SimpleHeroArrayDocumentType {
     const defaultObj = {
-        name: randomStringWithSpecialChars(6, 8),
+        name: randomStringWithSpecialChars(8, 10),
         skills: new Array(3).fill(0).map(() => randomStringWithSpecialChars(3, 6))
     };
     return Object.assign(

package/src/plugins/test-utils/test-util.ts

@@ -70,6 +70,77 @@ export async function awaitCollectionsHaveEqualState<RxDocType>(
 
 
 
+/**
+ * Deletes all locally stored IndexedDB databases.
+ * Noop if IndexedDB is not available (e.g. in Node.js)
+ * or if the .databases() method is not supported.
+ */
+export async function clearAllLocalIndexedDB(): Promise<void> {
+    if (
+        typeof indexedDB === 'undefined' ||
+        typeof indexedDB.databases !== 'function'
+    ) {
+        return;
+    }
+    const databases = await indexedDB.databases();
+    await Promise.all(
+        databases
+            .filter(db => !!db.name)
+            .map(db => {
+                return new Promise<void>((resolve, reject) => {
+                    const req = indexedDB.deleteDatabase(db.name as string);
+                    req.onsuccess = () => resolve();
+                    req.onerror = () => reject(req.error);
+                });
+            })
+    );
+}
+
+/**
+ * Deletes all files and directories stored in the
+ * Origin Private File System (OPFS).
+ * Noop if OPFS is not available (e.g. in Node.js).
+ */
+export async function clearAllLocalOPFS(maxRetries = 20, delayMs = 200): Promise<void> {
+    if (
+        typeof navigator === 'undefined' ||
+        !navigator.storage ||
+        typeof navigator.storage.getDirectory !== 'function'
+    ) {
+        return;
+    }
+    const root = await navigator.storage.getDirectory();
+    // @ts-ignore entries() is not in all TS lib definitions
+    for await (const [name] of root.entries()) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await root.removeEntry(name, { recursive: true });
+                break;
+            } catch (err: any) {
+                if (err?.name === 'NoModificationAllowedError' && attempt < maxRetries - 1) {
+                    await new Promise(resolve => setTimeout(resolve, delayMs));
+                } else {
+                    throw err;
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Clears all localStorage data.
+ * Noop if localStorage is not available (e.g. in Node.js).
+ */
+export async function clearAllLocalStorage(): Promise<void> {
+    if (
+        typeof localStorage === 'undefined' ||
+        typeof localStorage.clear !== 'function'
+    ) {
+        return;
+    }
+    localStorage.clear();
+}
+
 export function ensureReplicationHasNoErrors(replicationState: RxReplicationState<any, any>) {
     /**
      * We do not have to unsubscribe because the observable will cancel anyway.

package/src/plugins/utils/utils-map.ts

@@ -1,6 +1,6 @@
 export function getFromMapOrThrow<K, V>(map: Map<K, V> | WeakMap<any, V>, key: K): V {
     const val = map.get(key);
-    if (typeof val === 'undefined') {
+    if (val === undefined) {
         throw new Error('missing value from map ' + key);
     }
     return val;
@@ -13,7 +13,7 @@ export function getFromMapOrCreate<MapIndex, MapValue>(
     ifWasThere?: (value: MapValue) => void
 ): MapValue {
     let value = map.get(index);
-    if (typeof value === 'undefined') {
+    if (value === undefined) {
         value = creator();
         map.set(index, value);
     } else if (ifWasThere) {

package/src/plugins/utils/utils-object-deep-equal.ts

@@ -30,12 +30,10 @@ export function deepEqual(a: any, b: any): boolean {
         length = keys.length;
         if (length !== Object.keys(b).length) return false;
 
-        for (i = length; i-- !== 0;)
-            if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
-
+        // Single combined loop: check key existence AND deep-compare in one pass.
         for (i = length; i-- !== 0;) {
             const key = keys[i];
-            if (!deepEqual(a[key], b[key])) return false;
+            if (!Object.prototype.hasOwnProperty.call(b, key) || !deepEqual(a[key], b[key])) return false;
         }
 
         return true;

package/src/plugins/utils/utils-object-dot-prop.ts

@@ -206,6 +206,31 @@ export function getProperty(object: any, path: string | string[], value?: any) {
         return value === undefined ? object : value;
     }
 
+    /**
+     * Fast path for simple dot-notation paths without bracket
+     * notation or backslash escaping. This covers the vast majority
+     * of RxDB property access patterns (e.g. 'nested.field')
+     * and avoids the expensive getPathSegments() parser.
+     */
+    if (!path.includes('[') && !path.includes('\\')) {
+        const segments = path.split('.');
+        let current = object;
+        for (let i = 0; i < segments.length; i++) {
+            const seg = segments[i];
+            if (disallowedKeys.has(seg)) {
+                return value;
+            }
+            current = current[seg];
+            if (current === undefined || current === null) {
+                if (i !== segments.length - 1) {
+                    return value;
+                }
+                break;
+            }
+        }
+        return current === undefined ? value : current;
+    }
+
     const pathArray = getPathSegments(path);
     if (pathArray.length === 0) {
         return value;