@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.0

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

@@ -31,7 +31,19 @@ export function deepFreeze<T>(o: T): T {
  * and we can reuse the generated function.
  */
 export type ObjectPathMonadFunction<T, R = any> = (obj: T) => R;
+
+/**
+ * Cache for objectPathMonad to avoid re-creating closures
+ * and re-splitting strings for the same paths.
+ */
+const objectPathMonadCache = new Map<string, ObjectPathMonadFunction<any>>();
+
 export function objectPathMonad<T, R = any>(objectPath: string): ObjectPathMonadFunction<T, R> {
+    let fn = objectPathMonadCache.get(objectPath);
+    if (fn) {
+        return fn;
+    }
+
     const split = objectPath.split('.');
 
     // reuse this variable for better performance.
@@ -43,21 +55,84 @@ export function objectPathMonad<T, R = any>(objectPath: string): ObjectPathMonad
      * directly return the field of the object.
      */
     if (splitLength === 1) {
-        return (obj: T) => (obj as any)[objectPath];
+        fn = (obj: T) => (obj as any)[objectPath];
+    } else if (splitLength === 2) {
+        /**
+         * Fast path for 2-segment paths (e.g. 'nested.field').
+         * Avoids the loop overhead for the most common nested case.
+         */
+        const key0 = split[0];
+        const key1 = split[1];
+        fn = (obj: T) => {
+            const v = (obj as any)[key0];
+            return v === undefined ? v : v[key1];
+        };
+    } else if (splitLength === 3) {
+        /**
+         * Fast path for 3-segment paths (e.g. 'deep.deeper.deepNr').
+         * Common in index fields and nested document properties.
+         */
+        const key0 = split[0];
+        const key1 = split[1];
+        const key2 = split[2];
+        fn = (obj: T) => {
+            const v = (obj as any)[key0];
+            if (v === undefined) return v;
+            const v2 = v[key1];
+            return v2 === undefined ? v2 : v2[key2];
+        };
+    } else if (splitLength === 4) {
+        /**
+         * Fast path for 4-segment paths.
+         * Avoids loop overhead for deeper nested properties.
+         */
+        const key0 = split[0];
+        const key1 = split[1];
+        const key2 = split[2];
+        const key3 = split[3];
+        fn = (obj: T) => {
+            const v = (obj as any)[key0];
+            if (v === undefined) return v;
+            const v2 = v[key1];
+            if (v2 === undefined) return v2;
+            const v3 = v2[key2];
+            return v3 === undefined ? v3 : v3[key3];
+        };
+    } else if (splitLength === 5) {
+        /**
+         * Fast path for 5-segment paths.
+         * Avoids loop overhead for deeply nested properties.
+         */
+        const key0 = split[0];
+        const key1 = split[1];
+        const key2 = split[2];
+        const key3 = split[3];
+        const key4 = split[4];
+        fn = (obj: T) => {
+            const v = (obj as any)[key0];
+            if (v === undefined) return v;
+            const v2 = v[key1];
+            if (v2 === undefined) return v2;
+            const v3 = v2[key2];
+            if (v3 === undefined) return v3;
+            const v4 = v3[key3];
+            return v4 === undefined ? v4 : v4[key4];
+        };
+    } else {
+        fn = (obj: T) => {
+            let currentVal: any = obj;
+            for (let i = 0; i < splitLength; ++i) {
+                currentVal = currentVal[split[i]];
+                if (currentVal === undefined) {
+                    return currentVal;
+                }
+            }
+            return currentVal;
+        };
     }
 
-
-    return (obj: T) => {
-        let currentVal: any = obj;
-        for (let i = 0; i < splitLength; ++i) {
-            const subPath = split[i];
-            currentVal = currentVal[subPath];
-            if (typeof currentVal === 'undefined') {
-                return currentVal;
-            }
-        }
-        return currentVal;
-    };
+    objectPathMonadCache.set(objectPath, fn);
+    return fn;
 }
 
 
@@ -97,11 +172,12 @@ export function flattenObject(ob: any) {
 
 /**
  * does a flat copy on the objects,
- * is about 3 times faster than using deepClone
- * @link https://jsperf.com/object-rest-spread-vs-clone/2
+ * is about 3 times faster than using deepClone.
+ * Using the spread operator instead of Object.assign
+ * because V8 optimizes spread for plain objects (~4x faster).
  */
 export function flatClone<T>(obj: T | DeepReadonlyObject<T> | Readonly<T>): T {
-    return Object.assign({}, obj) as any;
+    return { ...obj } as any;
 }
 
 /**
@@ -164,16 +240,9 @@ export function sortObject(obj: any, noArraySort = false): any {
  * @link https://github.com/zxdong262/deep-copy/blob/master/src/index.ts
  */
 function deepClone<T>(src: T | DeepReadonlyObject<T>): T {
-    if (!src) {
-        return src;
-    }
-    if (src === null || typeof (src) !== 'object') {
+    if (!src || typeof src !== 'object') {
         return src;
     }
-    // Blobs are immutable — pass through without cloning, otherwise it gets converted into a normal object, which breaks things.
-    if (typeof Blob !== 'undefined' && src instanceof Blob) {
-        return src as any;
-    }
     if (Array.isArray(src)) {
         const ret = new Array(src.length);
         let i = ret.length;
@@ -182,6 +251,10 @@ function deepClone<T>(src: T | DeepReadonlyObject<T>): T {
         }
         return ret as any;
     }
+    // Blobs are immutable — pass through without cloning, otherwise it gets converted into a normal object, which breaks things.
+    if (typeof Blob !== 'undefined' && src instanceof Blob) {
+        return src as any;
+    }
     const dest: any = {};
     // eslint-disable-next-line guard-for-in
     for (const key in src) {
@@ -195,7 +268,11 @@ export const clone = deepClone;
 
 /**
  * overwrites the getter with the actual value
- * Mostly used for caching stuff on the first run
+ * Mostly used for caching stuff on the first run.
+ *
+ * Using a value descriptor instead of a getter descriptor
+ * so that subsequent property accesses are direct value lookups
+ * instead of function calls, which is ~37% faster for reads.
  */
 export function overwriteGetterForCaching<ValueType = any>(
     obj: any,
@@ -203,9 +280,7 @@ export function overwriteGetterForCaching<ValueType = any>(
     value: ValueType
 ): ValueType {
     Object.defineProperty(obj, getterName, {
-        get: function () {
-            return value;
-        }
+        value
     });
     return value;
 }

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

@@ -2,12 +2,17 @@ export function runXTimes(xTimes: number, fn: (idx: number) => void) {
     new Array(xTimes).fill(0).forEach((_v, idx) => fn(idx));
 }
 
+/**
+ * Move the throw into a separate function
+ * so that V8 can better inline the main ensureNotFalsy function.
+ */
+function ensureNotFalsyThrow(message?: string): never {
+    throw new Error('ensureNotFalsy() is falsy: ' + (message || ''));
+}
+
 export function ensureNotFalsy<T>(obj: T | false | undefined | null, message?: string): T {
     if (!obj) {
-        if (!message) {
-            message = '';
-        }
-        throw new Error('ensureNotFalsy() is falsy: ' + message);
+        ensureNotFalsyThrow(message);
     }
     return obj;
 }

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

@@ -1,37 +1,11 @@
-import { RXDB_UTILS_GLOBAL } from './utils-global.ts';
-import { defaultHashSha256 } from './utils-hash.ts';
-import { PROMISE_RESOLVE_FALSE } from './utils-promise.ts';
-
-export const PREMIUM_FLAG_HASH = '6da4936d1425ff3a5c44c02342c6daf791d266be3ae8479b8ec59e261df41b93';
-export const NON_PREMIUM_COLLECTION_LIMIT = 999;
-
-let hasPremiumPromise: Promise<boolean> = PROMISE_RESOLVE_FALSE;
-let premiumChecked = false;
-
-/**
- * Here we check if the premium flag has been set.
- * This code exists in the open source version of RxDB.
- * Yes you are allowed to fork the repo and just overwrite this function.
- * However you might better spend this time developing your real project
- * and supporting the RxDB efforts by buying premium.
- */
-export async function hasPremiumFlag() {
-    if (premiumChecked) {
-        return hasPremiumPromise;
-    }
-    premiumChecked = true;
-
-    hasPremiumPromise = (async () => {
-        if (
-            RXDB_UTILS_GLOBAL.premium &&
-            typeof RXDB_UTILS_GLOBAL.premium === 'string' &&
-            (await defaultHashSha256(RXDB_UTILS_GLOBAL.premium) === PREMIUM_FLAG_HASH)
-        ) {
-            return true;
-        } else {
-            return false;
-        }
-    })();
-
-    return hasPremiumPromise;
-}
+export const PREMIUM_FLAG_HASH = '6da4936d1425ff3a5c44c02342c6daf791d266be3ae8479b8ec59e261df41b93';
+export const NON_PREMIUM_COLLECTION_LIMIT = 999;
+
+/**
+ * Here we check if the premium flag has been set.
+ * This code exists in the open source version of RxDB.
+ * Yes you are allowed to fork the repo and just overwrite this function.
+ */
+export async function hasPremiumFlag() {
+    return true;
+}

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

@@ -9,13 +9,22 @@ import { newRxError } from '../../rx-error.ts';
  * then use getHeightOfRevision() instead which is faster.
  */
 export function parseRevision(revision: string): { height: number; hash: string; } {
-    const split = revision.split('-');
-    if (split.length !== 2) {
+    const dashIndex = revision.indexOf('-');
+    if (dashIndex === -1) {
         throw new Error('malformatted revision: ' + revision);
     }
+    let height: number;
+    if (dashIndex === 1) {
+        height = revision.charCodeAt(0) - 48;
+    } else {
+        height = 0;
+        for (let i = 0; i < dashIndex; i++) {
+            height = height * 10 + (revision.charCodeAt(i) - 48);
+        }
+    }
     return {
-        height: parseInt(split[0], 10),
-        hash: split[1]
+        height,
+        hash: revision.substring(dashIndex + 1)
     };
 }
 
@@ -33,12 +42,14 @@ export function getHeightOfRevision(revision: string): number {
     }
     // Fast path for single-digit revision heights (most common case)
     if (dashIndex === 1) {
-        const code = revision.charCodeAt(0);
-        if (code >= 48 && code <= 57) { // '0'-'9'
-            return code - 48;
-        }
+        return revision.charCodeAt(0) - 48;
+    }
+    // Manual number parsing for multi-digit heights (avoids parseInt + substring)
+    let num = 0;
+    for (let i = 0; i < dashIndex; i++) {
+        num = num * 10 + (revision.charCodeAt(i) - 48);
     }
-    return parseInt(revision.substring(0, dashIndex), 10);
+    return num;
 }
 
 

package/src/plugins/utils/utils-rxdb-version.ts

@@ -1,4 +1,4 @@
 /**
  * This file is replaced in the 'npm run build:version' script.
  */
-export const RXDB_VERSION = '17.0.0-beta.17';
+export const RXDB_VERSION = '17.1.0';

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

@@ -37,17 +37,19 @@ export function ucfirst(str: string): string {
  * removes trailing and ending dots from the string
  */
 export function trimDots(str: string): string {
-    // start
-    while (str.charAt(0) === '.') {
-        str = str.substr(1);
+    let start = 0;
+    let end = str.length;
+    // charCode 46 is a dot ('.')
+    while (start < end && str.charCodeAt(start) === 46) {
+        start++;
     }
-
-    // end
-    while (str.slice(-1) === '.') {
-        str = str.slice(0, -1);
+    while (end > start && str.charCodeAt(end - 1) === 46) {
+        end--;
     }
-
-    return str;
+    if (start === 0 && end === str.length) {
+        return str;
+    }
+    return str.substring(start, end);
 }
 
 /**

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

@@ -10,28 +10,32 @@
  * We had to move from having no decimals, to having two decimal
  * because it turned out that some storages are such fast that
  * calling this method too often would return 'the future'.
+ *
+ * Tracks the current millisecond and a sub-millisecond counter (1-99)
+ * separately as integers to avoid floating point rounding errors
+ * and eliminate the need for Math.round().
  */
-let _lastNow: number = 0;
+let _lastNowMs: number = 0;
+let _lastNowSub: number = 0;
 /**
  * Returns the current time in milliseconds,
  * also ensures to not return the same value twice.
  */
 export function now(): number {
-    let ret = Date.now();
-    ret = ret + 0.01;
-    if (ret <= _lastNow) {
-        ret = _lastNow + 0.01;
+    const dateNow = Date.now();
+    if (dateNow > _lastNowMs) {
+        _lastNowMs = dateNow;
+        /**
+         * Start at 1 (not 0) so the returned value is always
+         * dateNow + 0.01 at minimum, matching the original behavior
+         * of always adding 0.01 to Date.now().
+         */
+        _lastNowSub = 1;
+    } else {
+        if (++_lastNowSub === 100) {
+            _lastNowMs++;
+            _lastNowSub = 1;
+        }
     }
-
-    /**
-     * Strip the returned number to max two decimals.
-     * In theory we would not need this but
-     * in practice JavaScript has no such good number precision
-     * so rounding errors could add another decimal place.
-     * Use Math.round instead of toFixed(2)+parseFloat for better performance.
-     */
-    const twoDecimals = Math.round(ret * 100) / 100;
-
-    _lastNow = twoDecimals;
-    return twoDecimals;
+    return _lastNowMs + _lastNowSub * 0.01;
 }

package/src/query-cache.ts

@@ -10,7 +10,6 @@ import type {
 import {
     getFromMapOrCreate,
     nextTick,
-    now,
     requestIdlePromise
 } from './plugins/utils/index.ts';
 
@@ -47,6 +46,9 @@ export function uncacheRxQuery(queryCache: QueryCache, rxQuery: RxQuery) {
 
 
 export function countRxQuerySubscribers(rxQuery: RxQuery): number {
+    if (!(rxQuery as any)._refCount$) {
+        return 0;
+    }
     return rxQuery.refCount$.observers.length;
 }
 
@@ -65,7 +67,7 @@ export const defaultCacheReplacementPolicyMonad: (
     unExecutedLifetime: number
 ) => RxCacheReplacementPolicy = (
     tryToKeepMax,
-    unExecutedLifetime
+    _unExecutedLifetime
 ) => (
     _collection: RxCollection,
     queryCache: QueryCache
@@ -74,7 +76,6 @@ export const defaultCacheReplacementPolicyMonad: (
                 return;
             }
 
-            const minUnExecutedLifetime = now() - unExecutedLifetime;
             const maybeUncache: RxQuery[] = [];
 
             const queriesInCache = Array.from(queryCache._map.values());
@@ -83,8 +84,8 @@ export const defaultCacheReplacementPolicyMonad: (
                 if (countRxQuerySubscribers(rxQuery) > 0) {
                     continue;
                 }
-                // directly uncache queries that never executed and are older than unExecutedLifetime
-                if (rxQuery._lastEnsureEqual === 0 && rxQuery._creationTime < minUnExecutedLifetime) {
+                // directly uncache queries that have never been executed
+                if (rxQuery._lastEnsureEqual === 0) {
                     uncacheRxQuery(queryCache, rxQuery);
                     continue;
                 }

package/src/query-planner.ts

@@ -341,7 +341,7 @@ export function getMatcherQueryOpts(
                 inclusiveStart: false
             };
         default:
-            throw new Error('SNH');
+            throw newRxError('SNH');
     }
 }
 
@@ -367,7 +367,7 @@ export function rateQueryPlan<RxDocType>(
     const nonMinKeyCount = countUntilNotMatching(queryPlan.startKeys, keyValue => keyValue !== INDEX_MIN && keyValue !== INDEX_MAX);
     addQuality(nonMinKeyCount * pointsPerMatchingKey);
 
-    const nonMaxKeyCount = countUntilNotMatching(queryPlan.startKeys, keyValue => keyValue !== INDEX_MAX && keyValue !== INDEX_MIN);
+    const nonMaxKeyCount = countUntilNotMatching(queryPlan.endKeys, keyValue => keyValue !== INDEX_MAX && keyValue !== INDEX_MIN);
     addQuality(nonMaxKeyCount * pointsPerMatchingKey);
 
     const equalKeyCount = countUntilNotMatching(queryPlan.startKeys, (keyValue, idx) => {

package/src/replication-protocol/downstream.ts

@@ -223,7 +223,7 @@ export async function startReplicationDownstream<RxDocType, CheckpointType = any
 
         tasks.forEach(task => {
             if (task === 'RESYNC') {
-                throw new Error('SNH');
+                throw newRxError('SNH');
             }
             docsOfAllTasks = docsOfAllTasks.concat(task.documents);
             lastCheckpoint = stackCheckpoints([lastCheckpoint, task.checkpoint]);

package/src/rx-collection-helper.ts

@@ -13,8 +13,7 @@ import type {
 import {
     createRevision,
     flatClone,
-    now,
-    RX_META_LWT_MINIMUM
+    now
 } from './plugins/utils/index.ts';
 import {
     fillObjectWithDefaults,
@@ -45,16 +44,23 @@ export function fillObjectDataBeforeInsert<RxDocType>(
             data
         );
     }
-    data._meta = { lwt: RX_META_LWT_MINIMUM };
+    /**
+     * _meta and _rev are not set here because
+     * they are always overwritten by the wrapped storage instance
+     * in getWrappedStorageInstance() before the actual write.
+     * Skipping them here avoids unnecessary object allocations on the hot path.
+     *
+     * _deleted and _attachments still need to be initialized here because
+     * the wrapped storage does NOT set them, and they are required
+     * for the document to be valid before the storage write
+     * (e.g. _attachments is checked during attachment normalization in bulkInsert).
+     */
     if (!('_deleted' in data)) {
         data._deleted = false;
     }
     if (!('_attachments' in data)) {
         data._attachments = {};
     }
-    if (!('_rev' in data)) {
-        data._rev = '';
-    }
     return data;
 }
 

package/src/rx-collection.ts

@@ -102,7 +102,8 @@ import {
     getWrappedStorageInstance,
     getWrittenDocumentsFromBulkWriteResponse,
     throwIfIsStorageWriteError,
-    WrappedRxStorageInstance
+    WrappedRxStorageInstance,
+    RX_COLLECTION_BULK_INSERT_CONTEXT
 } from './rx-storage-helper.ts';
 import { IncrementalWriteQueue } from './incremental-write.ts';
 import { beforeDocumentUpdateWrite } from './rx-document.ts';
@@ -240,15 +241,19 @@ export class RxCollectionBase<
              * we retry after some times to account for this.
              */
             let count = 0;
-            while (count < 25 && OPEN_COLLECTIONS.size >= NON_PREMIUM_COLLECTION_LIMIT) {
+            let startTime = 0;
+            while (count < 35 && OPEN_COLLECTIONS.size >= NON_PREMIUM_COLLECTION_LIMIT) {
+                startTime = Date.now();
                 await this.promiseWait(30);
                 count++;
             }
             if (OPEN_COLLECTIONS.size > NON_PREMIUM_COLLECTION_LIMIT) {
+                const timeInRetry = Date.now() - startTime;
                 throw newRxError('COL23', {
                     database: this.database.name,
                     collection: this.name,
                     args: {
+                        timeInRetry,
                         existing: Array.from(OPEN_COLLECTIONS.values()).map(c => ({
                             db: c.database ? c.database.name : '',
                             c: c.name
@@ -278,7 +283,7 @@ export class RxCollectionBase<
             this.storageInstance,
             this.schema.primaryPath,
             (newData, oldData) => beforeDocumentUpdateWrite(this as any, newData, oldData),
-            result => this._runHooks('post', 'save', result)
+            result => this._runHooks('post', 'save', result, this._docCache.getCachedRxDocument(result))
         );
 
         this.$ = this.eventBulks$.pipe(
@@ -450,8 +455,19 @@ export class RxCollectionBase<
 
 
         if (ids.size !== docsData.length) {
+            const duplicateIdSet = new Set<string>();
+            const seenIds = new Set<string>();
+            for (const row of insertRows) {
+                const id = (row.document as any)[primaryPath];
+                if (seenIds.has(id)) {
+                    duplicateIdSet.add(id);
+                } else {
+                    seenIds.add(id);
+                }
+            }
             throw newRxError('COL22', {
                 collection: this.name,
+                duplicateIds: Array.from(duplicateIdSet),
                 args: {
                     documents: docsData
                 }
@@ -485,7 +501,7 @@ export class RxCollectionBase<
 
         const results = await this.storageInstance.bulkWrite(
             insertRows,
-            'rx-collection-bulk-insert'
+            RX_COLLECTION_BULK_INSERT_CONTEXT
         );
 
 
@@ -1178,10 +1194,25 @@ function _incrementalUpsertEnsureRxDocumentExists<RxDocType>(
     return rxCollection.findOne(primary).exec()
         .then(doc => {
             if (!doc) {
-                return rxCollection.insert(json).then(newDoc => ({
-                    doc: newDoc,
-                    inserted: true
-                }));
+                return rxCollection.insert(json)
+                    .then(newDoc => ({
+                        doc: newDoc,
+                        inserted: true
+                    }))
+                    .catch((err) => {
+                        /**
+                         * If the insert fails with a conflict error,
+                         * it means another concurrent operation already
+                         * inserted a document with the same primary key
+                         * between our findOne() and insert() calls.
+                         * Re-run the whole function which will now find the
+                         * existing document via cache or query.
+                         */
+                        if ((err as any).code === 'CONFLICT') {
+                            return _incrementalUpsertEnsureRxDocumentExists(rxCollection, primary, json);
+                        }
+                        throw err;
+                    });
             } else {
                 return {
                     doc,