@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/esm/plugins/test-utils/performance.js

@@ -0,0 +1,267 @@
+import assert from 'assert';
+import { createRxDatabase, randomToken, requestIdlePromise } from "../../index.js";
+import { wait } from 'async-test-util';
+import { averageSchemaData } from "./schema-objects.js";
+import { averageSchema } from "./schemas.js";
+/**
+ * Runs a performance benchmark against the given RxStorage.
+ * Useful for comparing different RxStorage implementations.
+ *
+ * @param storage - The RxStorage to benchmark.
+ * @param storageDescription - A human-readable description of the storage (used in results).
+ * @param config - Optional configuration to override the defaults.
+ * @returns An object with averaged timing values for each measured operation.
+ */
+export async function runPerformanceTests(storage, storageDescription, config = {}) {
+  var {
+    runs = 40,
+    collectionsAmount = 4,
+    docsAmount = 3000,
+    serialDocsAmount = 50,
+    parallelQueryAmount = 4,
+    insertBatches = 6,
+    waitBetweenTests = 100,
+    log = true
+  } = config;
+  var totalTimes = {};
+  var runsDone = 0;
+  var _loop = async function () {
+    if (log) {
+      console.log('runsDone: ' + runsDone + ' of ' + runs);
+    }
+    runsDone++;
+    var time = performance.now();
+    var updateTime = flag => {
+      if (!flag) {
+        time = performance.now();
+        return;
+      }
+      var diff = performance.now() - time;
+      if (!totalTimes[flag]) {
+        totalTimes[flag] = [diff];
+      } else {
+        totalTimes[flag].push(diff);
+      }
+      time = performance.now();
+    };
+    await awaitBetweenTest(waitBetweenTests);
+    updateTime();
+
+    // create database
+    var dbName = 'test-db-performance-' + randomToken(10);
+    var schema = averageSchema();
+    var collection;
+    async function createDbWithCollections() {
+      if (collection) {
+        await collection.database.close();
+      }
+      var db = await createRxDatabase({
+        name: dbName,
+        eventReduce: true,
+        /**
+         * A RxStorage implementation
+         * might need a full leader election cycle to be usable.
+         * So we disable multiInstance here because it would make no sense
+         * to measure the leader election time instead of the database
+         * creation time.
+        */
+        multiInstance: false,
+        storage
+      });
+
+      // create collections
+      var collectionData = {};
+      var collectionNames = [];
+      new Array(collectionsAmount).fill(0).forEach((_v, idx) => {
+        var name = dbName + '_col_' + idx;
+        collectionNames.push(name);
+        collectionData[name] = {
+          schema,
+          statics: {}
+        };
+      });
+      var firstCollectionName = collectionNames[0];
+      var collections = await db.addCollections(collectionData);
+      /**
+       * Many storages have a lazy initialization.
+       * So it makes no sense to measure the time of database/collection creation.
+       * Instead we do a single insert and measure the time to the first insert.
+       */
+      await collections[collectionNames[1]].insert(averageSchemaData());
+      return collections[firstCollectionName];
+    }
+    collection = await createDbWithCollections();
+    updateTime('time-to-first-insert');
+    await awaitBetweenTest(waitBetweenTests);
+
+    // insert documents (in batches)
+    var docIds = [];
+    var docsPerBatch = docsAmount / insertBatches;
+    for (var i = 0; i < insertBatches; i++) {
+      var docsData = new Array(docsPerBatch).fill(0).map((_v, idx) => {
+        var data = averageSchemaData({
+          var1: idx % 2 + '',
+          var2: idx % parallelQueryAmount
+        });
+        docIds.push(data.id);
+        return data;
+      });
+      updateTime();
+      await collection.bulkInsert(docsData);
+      updateTime('insert-documents-' + docsPerBatch);
+      await awaitBetweenTest(waitBetweenTests);
+    }
+
+    // refresh db to ensure we do not run on caches
+    collection = await createDbWithCollections();
+    await awaitBetweenTest(waitBetweenTests);
+
+    /**
+     * Bulk Find by id
+     */
+    updateTime();
+    var 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
+     */
+    updateTime();
+    var c = 0;
+    var serialIds = [];
+    while (c < serialDocsAmount) {
+      c++;
+      var data = averageSchemaData({
+        var2: 1000
+      });
+      serialIds.push(data.id);
+      await collection.insert(data);
+    }
+    updateTime('serial-inserts-' + serialDocsAmount);
+
+    // refresh db to ensure we do not run on caches
+    collection = await createDbWithCollections();
+    await awaitBetweenTest(waitBetweenTests);
+
+    /**
+     * Serial find-by-id
+     */
+    updateTime();
+    for (var id of serialIds) {
+      await collection.findByIds([id]).exec();
+    }
+    updateTime('serial-find-by-id-' + serialDocsAmount);
+    await awaitBetweenTest(waitBetweenTests);
+
+    // find by query
+    updateTime();
+    var query = collection.find({
+      selector: {},
+      sort: [{
+        var2: 'asc'
+      }, {
+        var1: 'asc'
+      }]
+    });
+    var 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);
+
+    // find by multiple queries in parallel
+    updateTime();
+    var parallelResult = await Promise.all(new Array(parallelQueryAmount).fill(0).map((_v, idx) => {
+      var subQuery = collection.find({
+        selector: {
+          var2: idx
+        }
+      });
+      return subQuery.exec();
+    }));
+    updateTime('find-by-query-parallel-' + parallelQueryAmount);
+    var parallelSum = 0;
+    parallelResult.forEach(r => parallelSum = parallelSum + r.length);
+    assert.strictEqual(parallelSum, docsAmount, 'parallelSum');
+    await awaitBetweenTest(waitBetweenTests);
+
+    // run count query
+    updateTime();
+    var t = 0;
+    while (t < parallelQueryAmount) {
+      var countQuery = collection.count({
+        selector: {
+          var2: {
+            $eq: t
+          }
+        }
+      });
+      var 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);
+
+    // test property access time
+    updateTime();
+    var sum = 0;
+    for (var _i = 0; _i < queryResult.length; _i++) {
+      var doc = queryResult[_i];
+
+      // access the same property exactly 2 times
+      sum += doc.deep.deeper.deepNr;
+      sum += doc.deep.deeper.deepNr;
+    }
+    updateTime('property-access');
+    assert.ok(sum > 10);
+    await collection.database.remove();
+  };
+  while (runsDone < runs) {
+    await _loop();
+  }
+  var result = {
+    description: storageDescription,
+    collectionsAmount,
+    docsAmount
+  };
+  Object.entries(totalTimes).forEach(([key, times]) => {
+    result[key] = roundToThree(averageOfTimeValues(times, 95));
+  });
+  if (log) {
+    console.log('Performance test for ' + storageDescription);
+    console.log(JSON.stringify(result, null, 4));
+  }
+  return result;
+}
+export function averageOfTimeValues(times,
+/**
+ * To better account for anomalies
+ * during time measurements,
+ * we strip the highest x percent.
+ */
+striphighestXPercent) {
+  times = times.sort((a, b) => a - b);
+  var stripAmount = Math.floor(times.length * (striphighestXPercent * 0.01));
+  var useNumbers = times.slice(0, times.length - stripAmount);
+  var total = 0;
+  useNumbers.forEach(nr => total = total + nr);
+  return total / useNumbers.length;
+}
+function roundToThree(num) {
+  return Math.round(num * 1000) / 1000;
+}
+async function awaitBetweenTest(waitMs) {
+  await requestIdlePromise();
+  if (waitMs > 0) {
+    await wait(waitMs);
+  }
+  await requestIdlePromise();
+  await requestIdlePromise();
+}
+//# sourceMappingURL=performance.js.map

package/dist/esm/plugins/test-utils/performance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.js","names":["assert","createRxDatabase","randomToken","requestIdlePromise","wait","averageSchemaData","averageSchema","runPerformanceTests","storage","storageDescription","config","runs","collectionsAmount","docsAmount","serialDocsAmount","parallelQueryAmount","insertBatches","waitBetweenTests","log","totalTimes","runsDone","_loop","console","time","performance","now","updateTime","flag","diff","push","awaitBetweenTest","dbName","schema","collection","createDbWithCollections","database","close","db","name","eventReduce","multiInstance","collectionData","collectionNames","Array","fill","forEach","_v","idx","statics","firstCollectionName","collections","addCollections","insert","docIds","docsPerBatch","i","docsData","map","data","var1","var2","id","bulkInsert","idsResult","findByIds","exec","strictEqual","from","keys","length","c","serialIds","query","find","selector","sort","queryResult","parallelResult","Promise","all","subQuery","parallelSum","r","t","countQuery","count","$eq","countQueryResult","ok","sum","doc","deep","deeper","deepNr","remove","result","description","Object","entries","key","times","roundToThree","averageOfTimeValues","JSON","stringify","striphighestXPercent","a","b","stripAmount","Math","floor","useNumbers","slice","total","nr","num","round","waitMs"],"sources":["../../../../src/plugins/test-utils/performance.ts"],"sourcesContent":["import assert from 'assert';\r\nimport {\r\n    createRxDatabase,\r\n    randomToken,\r\n    requestIdlePromise,\r\n    RxCollection,\r\n    RxStorage\r\n} from '../../index.ts';\r\nimport { wait } from 'async-test-util';\r\nimport { averageSchemaData, AverageSchemaDocumentType } from './schema-objects.ts';\r\nimport { averageSchema } from './schemas.ts';\r\n\r\nexport type PerformanceTestConfig = {\r\n    /**\r\n     * How many times the test loop is run.\r\n     * More runs give more stable averages but take longer.\r\n     * @default 40\r\n     */\r\n    runs?: number;\r\n    /**\r\n     * Number of collections created per database.\r\n     * @default 4\r\n     */\r\n    collectionsAmount?: number;\r\n    /**\r\n     * Number of documents inserted in bulk per run.\r\n     * @default 3000\r\n     */\r\n    docsAmount?: number;\r\n    /**\r\n     * Number of documents inserted one-by-one (serial) per run.\r\n     * @default 50\r\n     */\r\n    serialDocsAmount?: number;\r\n    /**\r\n     * Number of parallel queries executed per run.\r\n     * @default 4\r\n     */\r\n    parallelQueryAmount?: number;\r\n    /**\r\n     * Number of batches used when doing bulk inserts.\r\n     * @default 6\r\n     */\r\n    insertBatches?: number;\r\n    /**\r\n     * Milliseconds to wait between test operations.\r\n     * Set to 0 to disable waiting (useful for smoke tests).\r\n     * @default 100\r\n     */\r\n    waitBetweenTests?: number;\r\n    /**\r\n     * Whether to log progress and results to the console.\r\n     * @default true\r\n     */\r\n    log?: boolean;\r\n};\r\n\r\nexport type PerformanceTestResult = {\r\n    description: string;\r\n    collectionsAmount: number;\r\n    docsAmount: number;\r\n    [timingKey: string]: number | string;\r\n};\r\n\r\n/**\r\n * Runs a performance benchmark against the given RxStorage.\r\n * Useful for comparing different RxStorage implementations.\r\n *\r\n * @param storage - The RxStorage to benchmark.\r\n * @param storageDescription - A human-readable description of the storage (used in results).\r\n * @param config - Optional configuration to override the defaults.\r\n * @returns An object with averaged timing values for each measured operation.\r\n */\r\nexport async function runPerformanceTests(\r\n    storage: RxStorage<any, any>,\r\n    storageDescription: string,\r\n    config: PerformanceTestConfig = {}\r\n): Promise<PerformanceTestResult> {\r\n    const {\r\n        runs = 40,\r\n        collectionsAmount = 4,\r\n        docsAmount = 3000,\r\n        serialDocsAmount = 50,\r\n        parallelQueryAmount = 4,\r\n        insertBatches = 6,\r\n        waitBetweenTests = 100,\r\n        log = true\r\n    } = config;\r\n\r\n    const totalTimes: { [k: string]: number[]; } = {};\r\n\r\n    let runsDone = 0;\r\n    while (runsDone < runs) {\r\n        if (log) {\r\n            console.log('runsDone: ' + runsDone + ' of ' + runs);\r\n        }\r\n        runsDone++;\r\n\r\n        let time = performance.now();\r\n        const updateTime = (flag?: string) => {\r\n            if (!flag) {\r\n                time = performance.now();\r\n                return;\r\n            }\r\n            const diff = performance.now() - time;\r\n            if (!totalTimes[flag]) {\r\n                totalTimes[flag] = [diff];\r\n            } else {\r\n                totalTimes[flag].push(diff);\r\n            }\r\n            time = performance.now();\r\n        };\r\n\r\n        await awaitBetweenTest(waitBetweenTests);\r\n        updateTime();\r\n\r\n        // create database\r\n        const dbName = 'test-db-performance-' + randomToken(10);\r\n        const schema = averageSchema();\r\n        let collection: RxCollection<AverageSchemaDocumentType>;\r\n        async function createDbWithCollections() {\r\n            if (collection) {\r\n                await collection.database.close();\r\n            }\r\n            const db = await createRxDatabase({\r\n                name: dbName,\r\n                eventReduce: true,\r\n                /**\r\n                 * A RxStorage implementation\r\n                 * might need a full leader election cycle to be usable.\r\n                 * So we disable multiInstance here because it would make no sense\r\n                 * to measure the leader election time instead of the database\r\n                 * creation time.\r\n                */\r\n                multiInstance: false,\r\n                storage\r\n            });\r\n\r\n            // create collections\r\n            const collectionData: any = {};\r\n            const collectionNames: string[] = [];\r\n            new Array(collectionsAmount)\r\n                .fill(0)\r\n                .forEach((_v, idx) => {\r\n                    const name = dbName + '_col_' + idx;\r\n                    collectionNames.push(name);\r\n                    collectionData[name] = {\r\n                        schema,\r\n                        statics: {}\r\n                    };\r\n                });\r\n            const firstCollectionName: string = collectionNames[0];\r\n            const collections = await db.addCollections(collectionData);\r\n            /**\r\n             * Many storages have a lazy initialization.\r\n             * So it makes no sense to measure the time of database/collection creation.\r\n             * Instead we do a single insert and measure the time to the first insert.\r\n             */\r\n            await collections[collectionNames[1]].insert(averageSchemaData());\r\n            return collections[firstCollectionName];\r\n        }\r\n        collection = await createDbWithCollections();\r\n        updateTime('time-to-first-insert');\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        // insert documents (in batches)\r\n        const docIds: string[] = [];\r\n        const docsPerBatch = docsAmount / insertBatches;\r\n        for (let i = 0; i < insertBatches; i++) {\r\n            const docsData = new Array(docsPerBatch)\r\n                .fill(0)\r\n                .map((_v, idx) => {\r\n                    const data = averageSchemaData({\r\n                        var1: (idx % 2) + '',\r\n                        var2: idx % parallelQueryAmount\r\n                    });\r\n                    docIds.push(data.id);\r\n                    return data;\r\n                });\r\n            updateTime();\r\n            await collection.bulkInsert(docsData);\r\n            updateTime('insert-documents-' + docsPerBatch);\r\n            await awaitBetweenTest(waitBetweenTests);\r\n        }\r\n\r\n        // refresh db to ensure we do not run on caches\r\n        collection = await createDbWithCollections();\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        /**\r\n         * Bulk Find by id\r\n         */\r\n        updateTime();\r\n        const idsResult = await collection.findByIds(docIds).exec();\r\n        updateTime('find-by-ids-' + docsAmount);\r\n        assert.strictEqual(Array.from(idsResult.keys()).length, docsAmount, 'find-by-id amount');\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        /**\r\n         * Serial inserts\r\n         */\r\n        updateTime();\r\n        let c = 0;\r\n        const serialIds: string[] = [];\r\n        while (c < serialDocsAmount) {\r\n            c++;\r\n            const data = averageSchemaData({\r\n                var2: 1000\r\n            });\r\n            serialIds.push(data.id);\r\n            await collection.insert(data);\r\n        }\r\n        updateTime('serial-inserts-' + serialDocsAmount);\r\n\r\n        // refresh db to ensure we do not run on caches\r\n        collection = await createDbWithCollections();\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        /**\r\n         * Serial find-by-id\r\n         */\r\n        updateTime();\r\n        for (const id of serialIds) {\r\n            await collection.findByIds([id]).exec();\r\n        }\r\n        updateTime('serial-find-by-id-' + serialDocsAmount);\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        // find by query\r\n        updateTime();\r\n        const query = collection.find({\r\n            selector: {},\r\n            sort: [\r\n                { var2: 'asc' },\r\n                { var1: 'asc' }\r\n            ]\r\n        });\r\n        const queryResult = await query.exec();\r\n        updateTime('find-by-query');\r\n        assert.strictEqual(queryResult.length, docsAmount + serialDocsAmount, 'find-by-query');\r\n\r\n        // refresh db to ensure we do not run on caches\r\n        collection = await createDbWithCollections();\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        // find by multiple queries in parallel\r\n        updateTime();\r\n        const parallelResult = await Promise.all(\r\n            new Array(parallelQueryAmount).fill(0).map((_v, idx) => {\r\n                const subQuery = collection.find({\r\n                    selector: {\r\n                        var2: idx\r\n                    }\r\n                });\r\n                return subQuery.exec();\r\n            })\r\n        );\r\n        updateTime('find-by-query-parallel-' + parallelQueryAmount);\r\n        let parallelSum = 0;\r\n        parallelResult.forEach(r => parallelSum = parallelSum + r.length);\r\n        assert.strictEqual(parallelSum, docsAmount, 'parallelSum');\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        // run count query\r\n        updateTime();\r\n        let t = 0;\r\n        while (t < parallelQueryAmount) {\r\n            const countQuery = collection.count({\r\n                selector: {\r\n                    var2: {\r\n                        $eq: t\r\n                    }\r\n                }\r\n            });\r\n            const countQueryResult = await countQuery.exec();\r\n            assert.ok(countQueryResult >= ((docsAmount / insertBatches) - 5), 'count A ' + countQueryResult);\r\n            assert.ok(countQueryResult < (docsAmount * 0.8), 'count B ' + countQueryResult);\r\n            t++;\r\n        }\r\n        updateTime('4x-count');\r\n        await awaitBetweenTest(waitBetweenTests);\r\n\r\n        // test property access time\r\n        updateTime();\r\n        let sum = 0;\r\n        for (let i = 0; i < queryResult.length; i++) {\r\n            const doc = queryResult[i];\r\n\r\n            // access the same property exactly 2 times\r\n            sum += doc.deep.deeper.deepNr;\r\n            sum += doc.deep.deeper.deepNr;\r\n        }\r\n        updateTime('property-access');\r\n        assert.ok(sum > 10);\r\n\r\n        await collection.database.remove();\r\n    }\r\n\r\n    const result: PerformanceTestResult = {\r\n        description: storageDescription,\r\n        collectionsAmount,\r\n        docsAmount\r\n    };\r\n    Object.entries(totalTimes).forEach(([key, times]) => {\r\n        result[key] = roundToThree(averageOfTimeValues(times, 95));\r\n    });\r\n\r\n    if (log) {\r\n        console.log('Performance test for ' + storageDescription);\r\n        console.log(JSON.stringify(result, null, 4));\r\n    }\r\n\r\n    return result;\r\n}\r\n\r\nexport function averageOfTimeValues(\r\n    times: number[],\r\n    /**\r\n     * To better account for anomalies\r\n     * during time measurements,\r\n     * we strip the highest x percent.\r\n     */\r\n    striphighestXPercent: number\r\n): number {\r\n    times = times.sort((a, b) => a - b);\r\n    const stripAmount = Math.floor(times.length * (striphighestXPercent * 0.01));\r\n    const useNumbers = times.slice(0, times.length - stripAmount);\r\n    let total = 0;\r\n    useNumbers.forEach(nr => total = total + nr);\r\n    return total / useNumbers.length;\r\n}\r\n\r\nfunction roundToThree(num: number) {\r\n    return Math.round(num * 1000) / 1000;\r\n}\r\n\r\nasync function awaitBetweenTest(waitMs: number) {\r\n    await requestIdlePromise();\r\n    if (waitMs > 0) {\r\n        await wait(waitMs);\r\n    }\r\n    await requestIdlePromise();\r\n    await requestIdlePromise();\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/test-utils/replication-base-test-suite.js

@@ -0,0 +1,170 @@
+/**
+ * Base test suite for replication plugins.
+ * All replication plugins should run these tests
+ * to ensure consistent behavior across different backends.
+ *
+ * The tests use HumanDocumentType (passportId, firstName, lastName, age)
+ * with humansCollection.create() for collection creation.
+ */
+import assert from 'assert';
+import { wait } from 'async-test-util';
+import { ensureNotFalsy } from "../utils/index.js";
+import * as humansCollection from "./humans-collection.js";
+import * as schemaObjects from "./schema-objects.js";
+import { awaitCollectionsHaveEqualState, ensureReplicationHasNoErrors } from "./test-util.js";
+/**
+ * Runs the base test suite for a replication plugin.
+ * Call this inside a describe() block in your replication test file.
+ *
+ * The config callbacks should target a shared server endpoint.
+ * Each test calls cleanUpServer() at the start to ensure a clean state.
+ *
+ * @example
+ * ```ts
+ * describe('replication-nats.test.ts', () => {
+ *     runReplicationBaseTestSuite({
+ *         startReplication: (collection) => syncNats(collection, natsName),
+ *         syncOnce: (collection) => syncOnceNats(collection, natsName),
+ *         getAllServerDocs: () => getAllDocsOfServer(natsName),
+ *         cleanUpServer: async () => { ... },
+ *         softDeletes: true,
+ *         isDeleted: (doc) => doc._deleted,
+ *         getPrimaryOfServerDoc: (doc) => doc.passportId,
+ *     });
+ * });
+ * ```
+ */
+export function runReplicationBaseTestSuite(config) {
+  var waitTime = config.waitTime || 0;
+  describe('base test suite', () => {
+    describe('live replication', () => {
+      it('push replication to client-server', async () => {
+        await config.cleanUpServer();
+        var collection = await humansCollection.create(2, undefined, false);
+        var replicationState = config.startReplication(collection);
+        ensureReplicationHasNoErrors(replicationState);
+        await replicationState.awaitInitialReplication();
+        var docsOnServer = await config.getAllServerDocs();
+        assert.strictEqual(docsOnServer.length, 2);
+
+        // insert another one
+        await collection.insert(schemaObjects.humanData());
+        await replicationState.awaitInSync();
+        docsOnServer = await config.getAllServerDocs();
+        assert.strictEqual(docsOnServer.length, 3);
+
+        // update one
+        var doc = await collection.findOne().exec(true);
+        await doc.incrementalPatch({
+          age: 100
+        });
+        await replicationState.awaitInSync();
+        docsOnServer = await config.getAllServerDocs();
+        assert.strictEqual(docsOnServer.length, 3);
+        var serverDoc = ensureNotFalsy(docsOnServer.find(d => config.getPrimaryOfServerDoc(d) === doc.primary));
+        assert.strictEqual(serverDoc.age, 100);
+
+        // delete one
+        await doc.getLatest().remove();
+        await replicationState.awaitInSync();
+        docsOnServer = await config.getAllServerDocs();
+        if (config.softDeletes) {
+          assert.strictEqual(docsOnServer.length, 3);
+          assert.ok(docsOnServer.find(d => config.isDeleted(d)));
+        } else {
+          assert.strictEqual(docsOnServer.length, 2);
+        }
+        await collection.database.close();
+      });
+      it('two collections', async () => {
+        await config.cleanUpServer();
+        var collectionA = await humansCollection.create(0, undefined, false);
+        await collectionA.insert(schemaObjects.humanData('1aaa'));
+        var collectionB = await humansCollection.create(0, undefined, false);
+        await collectionB.insert(schemaObjects.humanData('1bbb'));
+        var replicationStateA = config.startReplication(collectionA);
+        ensureReplicationHasNoErrors(replicationStateA);
+        await replicationStateA.awaitInitialReplication();
+        var replicationStateB = config.startReplication(collectionB);
+        ensureReplicationHasNoErrors(replicationStateB);
+        await replicationStateB.awaitInitialReplication();
+        if (waitTime) {
+          await wait(waitTime);
+        }
+        await replicationStateA.awaitInSync();
+        await awaitCollectionsHaveEqualState(collectionA, collectionB, 'init sync');
+
+        // insert one
+        await collectionA.insert(schemaObjects.humanData('insert-a'));
+        await replicationStateA.awaitInSync();
+        await replicationStateB.awaitInSync();
+        if (waitTime) {
+          await wait(waitTime);
+        }
+        await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after insert');
+
+        // delete one
+        await collectionB.findOne().remove();
+        await replicationStateB.awaitInSync();
+        await replicationStateA.awaitInSync();
+        if (waitTime) {
+          await wait(waitTime);
+        }
+        await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after deletion');
+
+        // insert many
+        await collectionA.bulkInsert(new Array(10).fill(0).map(() => schemaObjects.humanData(undefined, undefined, 'bulk-insert-A')));
+        await replicationStateA.awaitInSync();
+        await replicationStateB.awaitInSync();
+        if (waitTime) {
+          await wait(waitTime);
+        }
+        await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after insert many');
+
+        // insert at both collections at the same time
+        await Promise.all([collectionA.insert(schemaObjects.humanData('insert-parallel-a')), collectionB.insert(schemaObjects.humanData('insert-parallel-b'))]);
+        await replicationStateA.awaitInSync();
+        await replicationStateB.awaitInSync();
+        await replicationStateA.awaitInSync();
+        await replicationStateB.awaitInSync();
+        if (waitTime) {
+          await wait(waitTime);
+        }
+        await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after insert both at same time');
+        await collectionA.database.close();
+        await collectionB.database.close();
+      });
+    });
+    describe('conflict handling', () => {
+      it('should keep the master state as default conflict handler', async () => {
+        await config.cleanUpServer();
+        var c1 = await humansCollection.create(1);
+        var c2 = await humansCollection.create(0);
+        await config.syncOnce(c1);
+        await config.syncOnce(c2);
+        var doc1 = await c1.findOne().exec(true);
+        var doc2 = await c2.findOne().exec(true);
+
+        // make update on both sides
+        await doc1.incrementalPatch({
+          firstName: 'c1'
+        });
+        await doc2.incrementalPatch({
+          firstName: 'c2'
+        });
+        await config.syncOnce(c2);
+
+        // cause conflict
+        await config.syncOnce(c1);
+
+        /**
+         * Must have kept the master state c2
+         */
+        assert.strictEqual(doc1.getLatest().firstName, 'c2');
+        await c1.database.close();
+        await c2.database.close();
+      });
+    });
+  });
+}
+//# sourceMappingURL=replication-base-test-suite.js.map

package/dist/esm/plugins/test-utils/replication-base-test-suite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication-base-test-suite.js","names":["assert","wait","ensureNotFalsy","humansCollection","schemaObjects","awaitCollectionsHaveEqualState","ensureReplicationHasNoErrors","runReplicationBaseTestSuite","config","waitTime","describe","it","cleanUpServer","collection","create","undefined","replicationState","startReplication","awaitInitialReplication","docsOnServer","getAllServerDocs","strictEqual","length","insert","humanData","awaitInSync","doc","findOne","exec","incrementalPatch","age","serverDoc","find","d","getPrimaryOfServerDoc","primary","getLatest","remove","softDeletes","ok","isDeleted","database","close","collectionA","collectionB","replicationStateA","replicationStateB","bulkInsert","Array","fill","map","Promise","all","c1","c2","syncOnce","doc1","doc2","firstName"],"sources":["../../../../src/plugins/test-utils/replication-base-test-suite.ts"],"sourcesContent":["/**\r\n * Base test suite for replication plugins.\r\n * All replication plugins should run these tests\r\n * to ensure consistent behavior across different backends.\r\n *\r\n * The tests use HumanDocumentType (passportId, firstName, lastName, age)\r\n * with humansCollection.create() for collection creation.\r\n */\r\nimport assert from 'assert';\r\nimport { wait } from 'async-test-util';\r\nimport type { RxCollection } from '../../types/index.d.ts';\r\nimport type { RxReplicationState } from '../replication/index.ts';\r\nimport { ensureNotFalsy } from '../utils/index.ts';\r\nimport * as humansCollection from './humans-collection.ts';\r\nimport * as schemaObjects from './schema-objects.ts';\r\nimport {\r\n    awaitCollectionsHaveEqualState,\r\n    ensureReplicationHasNoErrors\r\n} from './test-util.ts';\r\n\r\nexport type ReplicationBaseTestSuiteConfig = {\r\n    /**\r\n     * Start a live replication for a collection.\r\n     * Must target a shared server endpoint so that multiple\r\n     * collections can replicate to the same backend.\r\n     */\r\n    startReplication(collection: RxCollection<any>): RxReplicationState<any, any>;\r\n\r\n    /**\r\n     * Run a one-shot (non-live) sync and wait for completion.\r\n     * Must target the same server endpoint as startReplication.\r\n     */\r\n    syncOnce(collection: RxCollection<any>): Promise<void>;\r\n\r\n    /**\r\n     * Get all documents from the server,\r\n     * including soft-deleted ones when the backend uses soft deletes.\r\n     */\r\n    getAllServerDocs(): Promise<any[]>;\r\n\r\n    /**\r\n     * Remove all documents from the server.\r\n     */\r\n    cleanUpServer(): Promise<void>;\r\n\r\n    /**\r\n     * Whether the server uses soft deletes\r\n     * (marks docs as deleted instead of removing them).\r\n     */\r\n    softDeletes: boolean;\r\n\r\n    /**\r\n     * Check if a server document is marked as deleted.\r\n     * Required when softDeletes is true.\r\n     */\r\n    isDeleted?(serverDoc: any): boolean;\r\n\r\n    /**\r\n     * Get the client primary key (passportId) from a server document.\r\n     * Different backends store the primary key in different fields.\r\n     */\r\n    getPrimaryOfServerDoc(serverDoc: any): string;\r\n\r\n    /**\r\n     * Additional wait time for eventually consistent backends (ms).\r\n     */\r\n    waitTime?: number;\r\n};\r\n\r\n/**\r\n * Runs the base test suite for a replication plugin.\r\n * Call this inside a describe() block in your replication test file.\r\n *\r\n * The config callbacks should target a shared server endpoint.\r\n * Each test calls cleanUpServer() at the start to ensure a clean state.\r\n *\r\n * @example\r\n * ```ts\r\n * describe('replication-nats.test.ts', () => {\r\n *     runReplicationBaseTestSuite({\r\n *         startReplication: (collection) => syncNats(collection, natsName),\r\n *         syncOnce: (collection) => syncOnceNats(collection, natsName),\r\n *         getAllServerDocs: () => getAllDocsOfServer(natsName),\r\n *         cleanUpServer: async () => { ... },\r\n *         softDeletes: true,\r\n *         isDeleted: (doc) => doc._deleted,\r\n *         getPrimaryOfServerDoc: (doc) => doc.passportId,\r\n *     });\r\n * });\r\n * ```\r\n */\r\nexport function runReplicationBaseTestSuite(config: ReplicationBaseTestSuiteConfig): void {\r\n    const waitTime = config.waitTime || 0;\r\n\r\n    describe('base test suite', () => {\r\n        describe('live replication', () => {\r\n            it('push replication to client-server', async () => {\r\n                await config.cleanUpServer();\r\n                const collection = await humansCollection.create(2, undefined, false);\r\n\r\n                const replicationState = config.startReplication(collection);\r\n                ensureReplicationHasNoErrors(replicationState);\r\n                await replicationState.awaitInitialReplication();\r\n\r\n                let docsOnServer = await config.getAllServerDocs();\r\n                assert.strictEqual(docsOnServer.length, 2);\r\n\r\n                // insert another one\r\n                await collection.insert(schemaObjects.humanData());\r\n                await replicationState.awaitInSync();\r\n\r\n                docsOnServer = await config.getAllServerDocs();\r\n                assert.strictEqual(docsOnServer.length, 3);\r\n\r\n                // update one\r\n                const doc = await collection.findOne().exec(true);\r\n                await doc.incrementalPatch({ age: 100 });\r\n                await replicationState.awaitInSync();\r\n                docsOnServer = await config.getAllServerDocs();\r\n                assert.strictEqual(docsOnServer.length, 3);\r\n                const serverDoc = ensureNotFalsy(\r\n                    docsOnServer.find(d => config.getPrimaryOfServerDoc(d) === doc.primary)\r\n                );\r\n                assert.strictEqual(serverDoc.age, 100);\r\n\r\n                // delete one\r\n                await doc.getLatest().remove();\r\n                await replicationState.awaitInSync();\r\n                docsOnServer = await config.getAllServerDocs();\r\n\r\n                if (config.softDeletes) {\r\n                    assert.strictEqual(docsOnServer.length, 3);\r\n                    assert.ok(docsOnServer.find(d => config.isDeleted!(d)));\r\n                } else {\r\n                    assert.strictEqual(docsOnServer.length, 2);\r\n                }\r\n\r\n                await collection.database.close();\r\n            });\r\n\r\n            it('two collections', async () => {\r\n                await config.cleanUpServer();\r\n\r\n                const collectionA = await humansCollection.create(0, undefined, false);\r\n                await collectionA.insert(schemaObjects.humanData('1aaa'));\r\n                const collectionB = await humansCollection.create(0, undefined, false);\r\n                await collectionB.insert(schemaObjects.humanData('1bbb'));\r\n\r\n                const replicationStateA = config.startReplication(collectionA);\r\n                ensureReplicationHasNoErrors(replicationStateA);\r\n                await replicationStateA.awaitInitialReplication();\r\n\r\n                const replicationStateB = config.startReplication(collectionB);\r\n                ensureReplicationHasNoErrors(replicationStateB);\r\n                await replicationStateB.awaitInitialReplication();\r\n\r\n                if (waitTime) { await wait(waitTime); }\r\n                await replicationStateA.awaitInSync();\r\n\r\n                await awaitCollectionsHaveEqualState(collectionA, collectionB, 'init sync');\r\n\r\n                // insert one\r\n                await collectionA.insert(schemaObjects.humanData('insert-a'));\r\n                await replicationStateA.awaitInSync();\r\n                await replicationStateB.awaitInSync();\r\n                if (waitTime) { await wait(waitTime); }\r\n                await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after insert');\r\n\r\n                // delete one\r\n                await collectionB.findOne().remove();\r\n                await replicationStateB.awaitInSync();\r\n                await replicationStateA.awaitInSync();\r\n                if (waitTime) { await wait(waitTime); }\r\n                await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after deletion');\r\n\r\n                // insert many\r\n                await collectionA.bulkInsert(\r\n                    new Array(10)\r\n                        .fill(0)\r\n                        .map(() => schemaObjects.humanData(undefined, undefined, 'bulk-insert-A'))\r\n                );\r\n                await replicationStateA.awaitInSync();\r\n                await replicationStateB.awaitInSync();\r\n                if (waitTime) { await wait(waitTime); }\r\n                await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after insert many');\r\n\r\n                // insert at both collections at the same time\r\n                await Promise.all([\r\n                    collectionA.insert(schemaObjects.humanData('insert-parallel-a')),\r\n                    collectionB.insert(schemaObjects.humanData('insert-parallel-b'))\r\n                ]);\r\n                await replicationStateA.awaitInSync();\r\n                await replicationStateB.awaitInSync();\r\n                await replicationStateA.awaitInSync();\r\n                await replicationStateB.awaitInSync();\r\n                if (waitTime) { await wait(waitTime); }\r\n                await awaitCollectionsHaveEqualState(collectionA, collectionB, 'after insert both at same time');\r\n\r\n                await collectionA.database.close();\r\n                await collectionB.database.close();\r\n            });\r\n        });\r\n\r\n        describe('conflict handling', () => {\r\n            it('should keep the master state as default conflict handler', async () => {\r\n                await config.cleanUpServer();\r\n\r\n                const c1 = await humansCollection.create(1);\r\n                const c2 = await humansCollection.create(0);\r\n\r\n                await config.syncOnce(c1);\r\n                await config.syncOnce(c2);\r\n\r\n                const doc1 = await c1.findOne().exec(true);\r\n                const doc2 = await c2.findOne().exec(true);\r\n\r\n                // make update on both sides\r\n                await doc1.incrementalPatch({ firstName: 'c1' });\r\n                await doc2.incrementalPatch({ firstName: 'c2' });\r\n\r\n                await config.syncOnce(c2);\r\n\r\n                // cause conflict\r\n                await config.syncOnce(c1);\r\n\r\n                /**\r\n                 * Must have kept the master state c2\r\n                 */\r\n                assert.strictEqual(doc1.getLatest().firstName, 'c2');\r\n\r\n                await c1.database.close();\r\n                await c2.database.close();\r\n            });\r\n        });\r\n    });\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/test-utils/replication.js

@@ -0,0 +1,46 @@
+import { rxStorageInstanceToReplicationHandler } from "../../replication-protocol/index.js";
+import { deepEqual } from "../utils/index.js";
+
+/**
+ * Creates a pull handler that always returns
+ * all documents.
+*/
+export function getPullHandler(remoteCollection) {
+  var helper = rxStorageInstanceToReplicationHandler(remoteCollection.storageInstance, remoteCollection.database.conflictHandler, remoteCollection.database.token);
+  var handler = async (latestPullCheckpoint, batchSize) => {
+    var result = await helper.masterChangesSince(latestPullCheckpoint, batchSize);
+    return result;
+  };
+  return handler;
+}
+export function getPullStream(remoteCollection) {
+  var helper = rxStorageInstanceToReplicationHandler(remoteCollection.storageInstance, remoteCollection.conflictHandler, remoteCollection.database.token);
+  return helper.masterChangeStream$;
+}
+export function getPushHandler(remoteCollection) {
+  var helper = rxStorageInstanceToReplicationHandler(remoteCollection.storageInstance, remoteCollection.conflictHandler, remoteCollection.database.token);
+  var handler = async rows => {
+    var result = await helper.masterWrite(rows);
+    return result;
+  };
+  return handler;
+}
+export async function ensureEqualState(collectionA, collectionB, context) {
+  var [docsA, docsB] = await Promise.all([collectionA.find().exec().then(docs => docs.map(d => d.toJSON(true))), collectionB.find().exec().then(docs => docs.map(d => d.toJSON(true)))]);
+  docsA.forEach((docA, idx) => {
+    var docB = docsB[idx];
+    var cleanDocToCompare = doc => {
+      return Object.assign({}, doc, {
+        _meta: undefined,
+        _rev: undefined
+      });
+    };
+    if (!deepEqual(cleanDocToCompare(docA), cleanDocToCompare(docB))) {
+      console.log('## ERROR: State not equal (context: "' + context + '")');
+      console.log(JSON.stringify(docA, null, 4));
+      console.log(JSON.stringify(docB, null, 4));
+      throw new Error('STATE not equal (context: "' + context + '")');
+    }
+  });
+}
+//# sourceMappingURL=replication.js.map

package/dist/esm/plugins/test-utils/replication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication.js","names":["rxStorageInstanceToReplicationHandler","deepEqual","getPullHandler","remoteCollection","helper","storageInstance","database","conflictHandler","token","handler","latestPullCheckpoint","batchSize","result","masterChangesSince","getPullStream","masterChangeStream$","getPushHandler","rows","masterWrite","ensureEqualState","collectionA","collectionB","context","docsA","docsB","Promise","all","find","exec","then","docs","map","d","toJSON","forEach","docA","idx","docB","cleanDocToCompare","doc","Object","assign","_meta","undefined","_rev","console","log","JSON","stringify","Error"],"sources":["../../../../src/plugins/test-utils/replication.ts"],"sourcesContent":["import { Observable } from 'rxjs';\r\nimport { rxStorageInstanceToReplicationHandler } from '../../replication-protocol/index.ts';\r\nimport type {\r\n    DeepReadonly,\r\n    ReplicationPullHandler,\r\n    ReplicationPushHandler,\r\n    RxCollection,\r\n    RxReplicationPullStreamItem,\r\n    RxReplicationWriteToMasterRow\r\n} from '../../types';\r\nimport { deepEqual } from '../utils/index.ts';\r\n\r\n/**\r\n * Creates a pull handler that always returns\r\n * all documents.\r\n*/\r\nexport function getPullHandler<RxDocType, CheckpointType>(\r\n    remoteCollection: RxCollection<RxDocType, {}, {}, {}>\r\n): ReplicationPullHandler<RxDocType, CheckpointType> {\r\n    const helper = rxStorageInstanceToReplicationHandler<RxDocType, CheckpointType>(\r\n        remoteCollection.storageInstance,\r\n        remoteCollection.database.conflictHandler as any,\r\n        remoteCollection.database.token\r\n    );\r\n    const handler: ReplicationPullHandler<RxDocType, CheckpointType> = async (\r\n        latestPullCheckpoint: CheckpointType | undefined,\r\n        batchSize: number\r\n    ) => {\r\n        const result = await helper.masterChangesSince(latestPullCheckpoint, batchSize);\r\n        return result;\r\n    };\r\n    return handler;\r\n}\r\nexport function getPullStream<RxDocType>(\r\n    remoteCollection: RxCollection<RxDocType, {}, {}, {}>\r\n): Observable<RxReplicationPullStreamItem<RxDocType, any>> {\r\n    const helper = rxStorageInstanceToReplicationHandler(\r\n        remoteCollection.storageInstance,\r\n        remoteCollection.conflictHandler,\r\n        remoteCollection.database.token\r\n    );\r\n    return helper.masterChangeStream$;\r\n}\r\nexport function getPushHandler<RxDocType>(\r\n    remoteCollection: RxCollection<RxDocType, {}, {}, {}>\r\n): ReplicationPushHandler<RxDocType> {\r\n    const helper = rxStorageInstanceToReplicationHandler(\r\n        remoteCollection.storageInstance,\r\n        remoteCollection.conflictHandler,\r\n        remoteCollection.database.token\r\n    );\r\n    const handler: ReplicationPushHandler<RxDocType> = async (\r\n        rows: RxReplicationWriteToMasterRow<RxDocType>[]\r\n    ) => {\r\n        const result = await helper.masterWrite(rows);\r\n        return result;\r\n    };\r\n    return handler;\r\n}\r\n\r\n\r\nexport async function ensureEqualState<RxDocType>(\r\n    collectionA: RxCollection<RxDocType>,\r\n    collectionB: RxCollection<RxDocType>,\r\n    context?: string\r\n) {\r\n    const [\r\n        docsA,\r\n        docsB\r\n    ] = await Promise.all([\r\n        collectionA.find().exec().then(docs => docs.map(d => d.toJSON(true))),\r\n        collectionB.find().exec().then(docs => docs.map(d => d.toJSON(true)))\r\n    ]);\r\n\r\n    docsA.forEach((docA, idx) => {\r\n        const docB = docsB[idx];\r\n        const cleanDocToCompare = (doc: DeepReadonly<RxDocType>) => {\r\n            return Object.assign({}, doc, {\r\n                _meta: undefined,\r\n                _rev: undefined\r\n            });\r\n        };\r\n\r\n\r\n        if (!deepEqual(\r\n            cleanDocToCompare(docA),\r\n            cleanDocToCompare(docB)\r\n        )) {\r\n            console.log('## ERROR: State not equal (context: \"' + context + '\")');\r\n            console.log(JSON.stringify(docA, null, 4));\r\n            console.log(JSON.stringify(docB, null, 4));\r\n            throw new Error('STATE not equal (context: \"' + context + '\")');\r\n        }\r\n    });\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/plugins/test-utils/revisions.js

@@ -0,0 +1,5 @@
+export var EXAMPLE_REVISION_1 = '1-12080c42d471e3d2625e49dcca3b8e1a';
+export var EXAMPLE_REVISION_2 = '2-22080c42d471e3d2625e49dcca3b8e2b';
+export var EXAMPLE_REVISION_3 = '3-32080c42d471e3d2625e49dcca3b8e3c';
+export var EXAMPLE_REVISION_4 = '4-42080c42d471e3d2625e49dcca3b8e3c';
+//# sourceMappingURL=revisions.js.map

package/dist/esm/plugins/test-utils/revisions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revisions.js","names":["EXAMPLE_REVISION_1","EXAMPLE_REVISION_2","EXAMPLE_REVISION_3","EXAMPLE_REVISION_4"],"sources":["../../../../src/plugins/test-utils/revisions.ts"],"sourcesContent":["export const EXAMPLE_REVISION_1 = '1-12080c42d471e3d2625e49dcca3b8e1a';\r\nexport const EXAMPLE_REVISION_2 = '2-22080c42d471e3d2625e49dcca3b8e2b';\r\nexport const EXAMPLE_REVISION_3 = '3-32080c42d471e3d2625e49dcca3b8e3c';\r\nexport const EXAMPLE_REVISION_4 = '4-42080c42d471e3d2625e49dcca3b8e3c';\r\n"],"mappings":"AAAA,OAAO,IAAMA,kBAAkB,GAAG,oCAAoC;AACtE,OAAO,IAAMC,kBAAkB,GAAG,oCAAoC;AACtE,OAAO,IAAMC,kBAAkB,GAAG,oCAAoC;AACtE,OAAO,IAAMC,kBAAkB,GAAG,oCAAoC","ignoreList":[]}