@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.0

package/src/rx-database.ts

@@ -562,7 +562,7 @@ export class RxDatabaseBase<
             return this.closePromise;
         }
 
-        const { promise, resolve } = createPromiseWithResolvers<boolean>();
+        const { promise, resolve, reject } = createPromiseWithResolvers<boolean>();
         const resolveClosePromise = (result: boolean) => {
             if (this.onClosed) {
                 this.onClosed();
@@ -598,18 +598,42 @@ export class RxDatabaseBase<
             /**
              * First wait until the database is idle
              */
-            return this.requestIdlePromise()
-                .then(() => Promise.all(this.onClose.map(fn => fn())))
-                // close all collections
-                .then(() => Promise.all(
-                    Object.keys(this.collections as any)
-                        .map(key => (this.collections as any)[key])
-                        .map(col => col.close())
-                ))
-                // close internal storage instances
-                .then(() => this.internalStore.close())
-                .then(() => resolveClosePromise(true));
-        })();
+            await this.requestIdlePromise();
+
+            let closingError: Error | null = null;
+            try {
+                await Promise.all(this.onClose.map(fn => fn()));
+            } catch (err: unknown) {
+                closingError = err as Error;
+            }
+
+            // close all collections
+            await Promise.all(
+                Object.keys(this.collections as any)
+                    .map(key => (this.collections as any)[key])
+                    .map(col => col.close())
+            );
+
+            // close internal storage instances
+            await this.internalStore.close();
+
+            if (closingError) {
+                throw closingError;
+            }
+            resolveClosePromise(true);
+        })().catch((err) => {
+            /**
+             * If an error occurs during closing,
+             * we still have to mark the database as closed
+             * and clean up the instance tracking so that
+             * a new database with the same name can be created.
+             */
+            if (this.onClosed) {
+                this.onClosed();
+            }
+            this.closed = true;
+            reject(err);
+        });
 
         return promise;
     }
@@ -618,10 +642,18 @@ export class RxDatabaseBase<
      * deletes the database and its stored data.
      * Returns the names of all removed collections.
      */
-    remove(): Promise<string[]> {
-        return this
-            .close()
-            .then(() => removeRxDatabase(this.name, this.storage, this.multiInstance, this.password));
+    async remove(): Promise<string[]> {
+        /**
+         * Collect all collection onRemove handlers before closing,
+         * because close() will clear the collections and unsubscribe
+         * all listeners, making it impossible to trigger onRemove afterwards.
+         */
+        const collections = Object.values(this.collections as any) as RxCollection[];
+        await this.close();
+        await Promise.all(
+            collections.map(col => Promise.all(col.onRemove.map(fn => fn())))
+        );
+        return removeRxDatabase(this.name, this.storage, this.multiInstance, this.password);
     }
 
     get asRxDatabase(): RxDatabase<

package/src/rx-document.ts

@@ -13,6 +13,7 @@ import {
     trimDots,
     pluginMissing,
     flatClone,
+    deepEqual,
     PROMISE_RESOLVE_NULL,
     RXJS_SHARE_REPLAY_DEFAULTS,
     getProperty,
@@ -69,7 +70,8 @@ export const basePrototype = {
             return undefined;
         }
         return _this.$.pipe(
-            map((d: any) => d._data._deleted)
+            map((d: any) => d._data._deleted),
+            distinctUntilChanged()
         );
     },
     get deleted$$() {
@@ -159,7 +161,14 @@ export const basePrototype = {
         return this.$
             .pipe(
                 map((data: any) => getProperty(data, path)),
-                distinctUntilChanged()
+                distinctUntilChanged((prev: any, curr: any) => {
+                    /**
+                     * Use deepEqual for non-primitive values (objects/arrays)
+                     * because the default === comparison always fails across
+                     * document revisions since each revision creates new object references.
+                     */
+                    return deepEqual(prev, curr);
+                })
             );
     },
     get$$(this: RxDocument, path: string) {
@@ -276,7 +285,7 @@ export const basePrototype = {
         _context?: string
     ): Promise<RxDocument> {
         const oldData = this._data;
-        const newData: RxDocumentData<RxDocType> = await modifierFromPublicToInternal<RxDocType>(mutationFunction)(oldData) as any;
+        const newData: RxDocumentData<RxDocType> = await modifierFromPublicToInternal<RxDocType>(mutationFunction)(clone(oldData)) as any;
         return this._saveData(newData, oldData) as any;
     },
 

package/src/rx-query-helper.ts

@@ -64,19 +64,10 @@ export function normalizeMangoQuery<RxDocType>(
          * For normalization, we have to normalize this
          * so our checks can perform properly.
          *
-         *
-         * TODO this must work recursive with nested queries that
-         * contain multiple selectors via $and or $or etc.
+         * This works recursively for nested queries that
+         * contain multiple selectors via $and, $or, $nor or $not.
          */
-        Object
-            .entries(normalizedMangoQuery.selector)
-            .forEach(([field, matcher]) => {
-                if (typeof matcher !== 'object' || matcher === null) {
-                    (normalizedMangoQuery as any).selector[field] = {
-                        $eq: matcher
-                    };
-                }
-            });
+        normalizeQuerySelectorShorthands(normalizedMangoQuery.selector);
     }
 
     /**
@@ -144,11 +135,12 @@ export function normalizeMangoQuery<RxDocType>(
                 schema.indexes.forEach(index => {
                     const useIndex = isMaybeReadonlyArray(index) ? index : [index];
                     const firstWrongIndex = useIndex.findIndex(indexField => !fieldsWithLogicalOperator.has(indexField));
+                    const matchingFieldCount = firstWrongIndex === -1 ? useIndex.length : firstWrongIndex;
                     if (
-                        firstWrongIndex > 0 &&
-                        firstWrongIndex > currentFieldsAmount
+                        matchingFieldCount > 0 &&
+                        matchingFieldCount > currentFieldsAmount
                     ) {
-                        currentFieldsAmount = firstWrongIndex;
+                        currentFieldsAmount = matchingFieldCount;
                         currentBestIndexForSort = useIndex;
                     }
                 });
@@ -287,6 +279,35 @@ export async function runQueryUpdateFunction<RxDocType, RxQueryResult>(
     }
 }
 
+/**
+ * Normalizes selector shorthand values recursively.
+ * Converts `{field: value}` to `{field: {$eq: value}}`
+ * and recurses into $and, $or, $nor arrays and $not objects.
+ */
+const SELECTOR_ARRAY_OPERATORS = new Set(['$and', '$or', '$nor']);
+function normalizeQuerySelectorShorthands(selector: any): void {
+    Object
+        .entries(selector)
+        .forEach(([field, matcher]) => {
+            if (typeof matcher !== 'object' || matcher === null) {
+                selector[field] = { $eq: matcher };
+            } else if (SELECTOR_ARRAY_OPERATORS.has(field) && Array.isArray(matcher)) {
+                (matcher as any[]).forEach(subSelector => normalizeQuerySelectorShorthands(subSelector));
+            } else if (field === '$not' && typeof matcher === 'object') {
+                normalizeQuerySelectorShorthands(matcher);
+            } else if (!field.startsWith('$') && typeof matcher === 'object') {
+                /**
+                 * Recurse into field-level operator objects to normalize
+                 * sub-selectors like $elemMatch which contain nested selectors.
+                 */
+                const matcherObj = matcher as any;
+                if (matcherObj.$elemMatch && typeof matcherObj.$elemMatch === 'object') {
+                    normalizeQuerySelectorShorthands(matcherObj.$elemMatch);
+                }
+            }
+        });
+}
+
 /**
  * @returns a format of the query that can be used with the storage
  * when calling RxStorageInstance().query()

package/src/rx-query-single-result.ts

@@ -1,5 +1,5 @@
 import { mapDocumentsDataToCacheDocs } from './doc-cache.ts';
-import { now, overwriteGetterForCaching } from './plugins/utils/index.ts';
+import { overwriteGetterForCaching } from './plugins/utils/index.ts';
 import { newRxError } from './rx-error.ts';
 import { RxQueryBase } from './rx-query.ts';
 import type {
@@ -7,6 +7,13 @@ import type {
     RxDocumentData
 } from './types';
 
+/**
+ * Counter to create unique result IDs cheaply.
+ * Used instead of now() to avoid expensive timestamp computation
+ * when we only need uniqueness for change detection.
+ */
+let _resultIdCounter = 0;
+
 /**
  * RxDB needs the query results in multiple formats.
  * Sometimes as a Map or an array with only the documentData.
@@ -16,11 +23,11 @@ import type {
  */
 export class RxQuerySingleResult<RxDocType> {
     /**
-     * Time at which the current _result state was created.
+     * Unique identifier for this result state.
      * Used to determine if the result set has changed since X
      * so that we do not emit the same result multiple times on subscription.
      */
-    public readonly time = now();
+    public readonly time = ++_resultIdCounter;
     public readonly documents: RxDocument<RxDocType>[];
     constructor(
         public readonly query: RxQueryBase<RxDocType, unknown>,

package/src/rx-query.ts

@@ -93,12 +93,20 @@ export class RxQueryBase<
     public _creationTime = Date.now();
 
     // used in the query-cache to determine if the RxQuery can be cleaned up.
+    // 0 means never executed. Updated to an incrementing counter on each _ensureEqual call.
     public _lastEnsureEqual = 0;
 
     public uncached = false;
 
     // used to count the subscribers to the query
-    public refCount$ = new BehaviorSubject(null);
+    // Lazy-initialized to avoid BehaviorSubject overhead for .exec()-only queries
+    public _refCount$: BehaviorSubject<null> | null = null;
+    public get refCount$(): BehaviorSubject<null> {
+        if (!this._refCount$) {
+            this._refCount$ = new BehaviorSubject<null>(null);
+        }
+        return this._refCount$;
+    }
 
     public isFindOneByIdQuery: false | string | string[];
 
@@ -395,12 +403,26 @@ export class RxQueryBase<
      * @overwrites itself with the actual value
      */
     toString(): string {
-        const stringObj = sortObject({
-            op: this.op,
-            query: this.normalizedQuery,
-            other: this.other
-        }, true);
-        const value = JSON.stringify(stringObj);
+        /**
+         * For findByIds queries, build the cache key directly from the IDs
+         * to avoid the expensive normalizeMangoQuery + sortObject + JSON.stringify.
+         * The selector structure is guaranteed by findByIds() which always creates
+         * { [primaryPath]: { $in: ids } }
+         */
+        let value: string;
+        if (this.op === 'findByIds') {
+            const ids: string[] = (this.mangoQuery.selector as any)[this.collection.schema.primaryPath].$in;
+            // slice() is needed because sort() mutates the array in-place
+            const sortedIds = ids.slice().sort();
+            value = '|findByIds|' + JSON.stringify(sortedIds);
+        } else {
+            const stringObj = sortObject({
+                op: this.op,
+                query: this.normalizedQuery,
+                other: this.other
+            }, true);
+            value = JSON.stringify(stringObj);
+        }
         this.toString = () => value;
         return value;
     }
@@ -448,7 +470,14 @@ export class RxQueryBase<
      * deletes all found documents
      * @return promise with deleted documents
      */
-    async remove(): Promise<RxQueryResult> {
+    async remove(throwIfMissing?: boolean): Promise<RxQueryResult> {
+        if (throwIfMissing && this.op !== 'findOne') {
+            throw newRxError('QU9', {
+                collection: this.collection.name,
+                query: this.mangoQuery,
+                op: this.op
+            });
+        }
         const docs = await this.exec();
         if (Array.isArray(docs)) {
             const result = await this.collection.bulkRemove(docs);
@@ -458,6 +487,17 @@ export class RxQueryBase<
                 return result.success as any;
             }
         } else {
+            // findOne() can return null when no document matches
+            if (!docs) {
+                if (throwIfMissing) {
+                    throw newRxError('QU10', {
+                        collection: this.collection.name,
+                        query: this.mangoQuery,
+                        op: this.op
+                    });
+                }
+                return null as any;
+            }
             return (docs as any).remove();
         }
     }

package/src/rx-schema-helper.ts

@@ -291,7 +291,7 @@ export function fillWithDefaultSettings<T = any>(
 
     // make indexes unique
     const hasIndex = new Set<string>();
-    useIndexes.filter(index => {
+    schemaObj.indexes = useIndexes.filter(index => {
         const indexStr = index.join(',');
         if (hasIndex.has(indexStr)) {
             return false;
@@ -301,8 +301,6 @@ export function fillWithDefaultSettings<T = any>(
         }
     });
 
-    schemaObj.indexes = useIndexes;
-
     return schemaObj as any;
 }
 
@@ -367,7 +365,12 @@ export function fillObjectWithDefaults(rxSchema: RxSchema<any>, obj: any): any {
     for (let i = 0; i < defaultKeys.length; ++i) {
         const key = defaultKeys[i];
         if (obj[key] === undefined) {
-            obj[key] = rxSchema.defaultValues[key];
+            const val = rxSchema.defaultValues[key];
+            if (typeof val === 'object' && val !== null) {
+                obj[key] = Array.isArray(val) ? val.slice() : { ...val };
+            } else {
+                obj[key] = val;
+            }
         }
     }
     return obj;

package/src/rx-schema.ts

@@ -78,6 +78,7 @@ export class RxSchema<RxDocType = any> {
         const jsonSchema: any = flatClone(this.jsonSchema);
         jsonSchema.properties = flatClone(jsonSchema.properties);
         delete jsonSchema.properties._deleted;
+        delete jsonSchema.properties._rev;
         delete jsonSchema.properties._meta;
         delete jsonSchema.properties._attachments;