@signaldb/svelte 2.0.0-beta.18 → 2.0.0-beta.19

package/dist/base/core/src/AsyncDataAdapter.js

@@ -10,7 +10,8 @@ const modify_1 = __importDefault(require("./utils/modify"));
 const queryId_1 = __importDefault(require("./utils/queryId"));
 const isEqual_1 = __importDefault(require("./utils/isEqual"));
 const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
-const getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
+const storageIndexQuery_1 = __importDefault(require("./utils/storageIndexQuery"));
+const idIndexQuery_1 = __importDefault(require("./utils/idIndexQuery"));
 const sortItems_1 = __importDefault(require("./utils/sortItems"));
 const projectItems_1 = __importDefault(require("./utils/projectItems"));
 const incrementalQueryUpdate_1 = __importDefault(require("./utils/incrementalQueryUpdate"));
@@ -343,15 +344,15 @@ class AsyncDataAdapter {
         const storageAdapter = this.storageAdapters.get(collectionName);
         if (!storageAdapter)
             throw new Error(`No persistence adapter for collection ${collectionName}`);
-        if (selector != null
-            && Object.keys(selector).length === 1
-            && 'id' in selector
-            && typeof selector.id !== 'object') {
-            return {
-                matched: true,
-                ids: [selector.id].filter(Boolean),
-                optimizedSelector: {},
-            };
+        if (selector != null && Object.keys(selector).length === 1 && 'id' in selector) {
+            const idResult = (0, idIndexQuery_1.default)(selector);
+            if (idResult.matched) {
+                return {
+                    matched: true,
+                    ids: idResult.ids.filter(Boolean),
+                    optimizedSelector: {},
+                };
+            }
         }
         if (selector == null) {
             return {
@@ -361,45 +362,7 @@ class AsyncDataAdapter {
             };
         }
         const indices = this.collectionIndices.get(collectionName) ?? [];
-        return (0, getIndexInfo_1.default)(indices.map(field => async (flatSelector) => {
-            if (!Object.hasOwnProperty.call(flatSelector, field))
-                return { matched: false };
-            const index = await storageAdapter.readIndex(field);
-            const fieldSelector = flatSelector[field];
-            const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
-            const keys = filtersForNull
-                ? { include: null, exclude: [...index.keys()].filter(key => key != null) }
-                : (0, getMatchingKeys_1.default)(field, flatSelector);
-            if (keys.include == null && keys.exclude == null)
-                return { matched: false };
-            // Build included ids
-            let includedIds = [];
-            if (keys.include == null) {
-                for (const set of index.values())
-                    for (const pos of set)
-                        includedIds.push(pos);
-            }
-            else {
-                for (const key of keys.include) {
-                    const idSet = index.get(key);
-                    if (idSet)
-                        for (const id of idSet)
-                            includedIds.push(id);
-                }
-            }
-            // Apply exclusions
-            if (keys.exclude != null) {
-                const excludeIds = new Set();
-                for (const key of keys.exclude) {
-                    const idSet = index.get(key);
-                    if (idSet)
-                        for (const id of idSet)
-                            excludeIds.add(id);
-                }
-                includedIds = includedIds.filter(pos => !excludeIds.has(pos));
-            }
-            return { matched: true, ids: includedIds, fields: [field], keepSelector: filtersForNull };
-        }), selector);
+        return (0, getIndexInfo_1.default)(indices.map(field => (0, storageIndexQuery_1.default)(storageAdapter, field)), selector);
     }
     async queryItems(collectionName, selector) {
         const storage = this.storageAdapters.get(collectionName);

package/dist/base/core/src/AutoFetchDataAdapter.js

@@ -9,7 +9,8 @@ const modify_1 = __importDefault(require("./utils/modify"));
 const queryId_1 = __importDefault(require("./utils/queryId"));
 const isEqual_1 = __importDefault(require("./utils/isEqual"));
 const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
-const getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
+const storageIndexQuery_1 = __importDefault(require("./utils/storageIndexQuery"));
+const idIndexQuery_1 = __importDefault(require("./utils/idIndexQuery"));
 const sortItems_1 = __importDefault(require("./utils/sortItems"));
 const project_1 = __importDefault(require("./utils/project"));
 /**
@@ -388,58 +389,17 @@ class AutoFetchDataAdapter {
         const storage = this.storageAdapters.get(collectionName);
         if (!storage)
             throw new Error(`No persistence adapter for collection ${collectionName}`);
-        // Fast path: { id: <scalar> }
-        if (selector != null && Object.keys(selector).length === 1 && 'id' in selector && typeof selector.id !== 'object') {
-            return { matched: true, ids: [selector.id], optimizedSelector: {} };
+        // `id` needs no declared index — `readIds` is exactly that lookup.
+        if (selector != null && Object.keys(selector).length === 1 && 'id' in selector) {
+            const idResult = (0, idIndexQuery_1.default)(selector);
+            if (idResult.matched)
+                return { matched: true, ids: idResult.ids, optimizedSelector: {} };
         }
         if (selector == null) {
             return { matched: false, ids: [], optimizedSelector: {} };
         }
         const indices = this.collectionIndices.get(collectionName) ?? [];
-        return (0, getIndexInfo_1.default)(indices.map(field => async (flatSelector) => {
-            if (!Object.hasOwnProperty.call(flatSelector, field))
-                return { matched: false };
-            const index = await storage.readIndex(field);
-            const fieldSelector = flatSelector[field];
-            const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
-            const keys = filtersForNull
-                ? { include: null, exclude: [...index.keys()].filter(key => key != null) }
-                : (0, getMatchingKeys_1.default)(field, flatSelector);
-            if (keys.include == null && keys.exclude == null)
-                return { matched: false };
-            // Build included ids
-            let includedIds = [];
-            if (keys.include == null) {
-                for (const set of index.values())
-                    for (const pos of set)
-                        includedIds.push(pos);
-            }
-            else {
-                for (const key of keys.include) {
-                    const idSet = index.get(key);
-                    if (idSet)
-                        for (const id of idSet)
-                            includedIds.push(id);
-                }
-            }
-            // Apply exclusions
-            if (keys.exclude != null) {
-                const excludeIds = new Set();
-                for (const key of keys.exclude) {
-                    const idSet = index.get(key);
-                    if (idSet)
-                        for (const id of idSet)
-                            excludeIds.add(id);
-                }
-                includedIds = includedIds.filter(pos => !excludeIds.has(pos));
-            }
-            return {
-                matched: true,
-                ids: includedIds,
-                fields: [field],
-                keepSelector: filtersForNull,
-            };
-        }), selector);
+        return (0, getIndexInfo_1.default)(indices.map(field => (0, storageIndexQuery_1.default)(storage, field)), selector);
     }
     async queryItems(collectionName, selector) {
         const storage = this.storageAdapters.get(collectionName);

package/dist/base/core/src/DefaultDataAdapter.js

@@ -15,6 +15,7 @@ const incrementalQueryUpdate_1 = __importDefault(require("./utils/incrementalQue
 const queryDelta_1 = require("./utils/queryDelta");
 const queryId_1 = __importDefault(require("./utils/queryId"));
 const serializeValue_1 = __importDefault(require("./utils/serializeValue"));
+const idIndexQuery_1 = __importDefault(require("./utils/idIndexQuery"));
 const sortItems_1 = __importDefault(require("./utils/sortItems"));
 /**
  * Checks if there are any pending updates in the given changeset.
@@ -77,15 +78,16 @@ class DefaultDataAdapter {
         });
     }
     getIndexInfo(collection, selector) {
-        if (selector != null
-            && Object.keys(selector).length === 1
-            && 'id' in selector
-            && typeof selector.id !== 'object') {
-            return {
-                matched: true,
-                ids: [(0, serializeValue_1.default)(selector.id)],
-                optimizedSelector: {},
-            };
+        if (selector != null && Object.keys(selector).length === 1 && 'id' in selector) {
+            const idResult = (0, idIndexQuery_1.default)(selector);
+            if (idResult.matched) {
+                return {
+                    // This adapter keys its in-memory map by `serializeValue(id)`.
+                    matched: true,
+                    ids: idResult.ids.map(id => (0, serializeValue_1.default)(id)),
+                    optimizedSelector: {},
+                };
+            }
         }
         if (selector == null) {
             return {

package/dist/base/core/src/WorkerDataAdapterHost.js

@@ -9,7 +9,8 @@ const modify_1 = __importDefault(require("./utils/modify"));
 const queryId_1 = __importDefault(require("./utils/queryId"));
 const isEqual_1 = __importDefault(require("./utils/isEqual"));
 const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
-const getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
+const idIndexQuery_1 = __importDefault(require("./utils/idIndexQuery"));
+const storageIndexQuery_1 = __importDefault(require("./utils/storageIndexQuery"));
 const sortItems_1 = __importDefault(require("./utils/sortItems"));
 const projectItems_1 = __importDefault(require("./utils/projectItems"));
 const compact_1 = __importDefault(require("./utils/compact"));
@@ -96,15 +97,18 @@ class WorkerDataAdapterHost {
         const storageAdapter = this.storageAdapters.get(collectionName);
         if (!storageAdapter)
             throw new Error(`No persistence adapter for collection ${collectionName}`);
-        if (selector != null
-            && Object.keys(selector).length === 1
-            && 'id' in selector
-            && typeof selector.id !== 'object') {
-            return {
-                matched: true,
-                ids: (0, compact_1.default)([selector.id]),
-                optimizedSelector: {},
-            };
+        // `id` needs no declared index: `readIds` is exactly the lookup it
+        // describes, so every inclusive form of it is answered here rather than by
+        // reading the whole collection (utils/idIndexQuery.ts).
+        if (selector != null && Object.keys(selector).length === 1 && 'id' in selector) {
+            const idResult = (0, idIndexQuery_1.default)(selector);
+            if (idResult.matched) {
+                return {
+                    matched: true,
+                    ids: (0, compact_1.default)(idResult.ids),
+                    optimizedSelector: {},
+                };
+            }
         }
         if (selector == null) {
             return {
@@ -114,59 +118,9 @@ class WorkerDataAdapterHost {
             };
         }
         const indices = this.collectionIndices.get(collectionName) ?? [];
-        return (0, getIndexInfo_1.default)(indices.map(field => async (flatSelector) => {
-            if (!Object.hasOwnProperty.call(flatSelector, field)) {
-                // If the field is not present in the selector, we can't optimize
-                return { matched: false };
-            }
-            const index = await storageAdapter.readIndex(field);
-            const fieldSelector = flatSelector[field];
-            const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
-            const keys = filteresForNull
-                ? { include: null, exclude: [...index.keys()].filter(key => key != null) }
-                : (0, getMatchingKeys_1.default)(field, flatSelector);
-            if (keys.include == null && keys.exclude == null)
-                return { matched: false };
-            // Accumulate included positions
-            let includedIds = [];
-            if (keys.include == null) {
-                for (const set of index.values()) {
-                    for (const pos of set) {
-                        includedIds.push(pos);
-                    }
-                }
-            }
-            else {
-                for (const key of keys.include) {
-                    const idSet = index.get(key);
-                    if (idSet) {
-                        for (const id of idSet) {
-                            includedIds.push(id);
-                        }
-                    }
-                }
-            }
-            // If exclusion is specified, build a single set of all positions to exclude.
-            if (keys.exclude != null) {
-                const excludeIds = new Set();
-                for (const key of keys.exclude) {
-                    const idSet = index.get(key);
-                    if (idSet) {
-                        for (const id of idSet) {
-                            excludeIds.add(id);
-                        }
-                    }
-                }
-                // Filter out any position that exists in the exclude set.
-                includedIds = includedIds.filter(pos => !excludeIds.has(pos));
-            }
-            return {
-                matched: true,
-                ids: includedIds,
-                fields: [field],
-                keepSelector: filteresForNull,
-            };
-        }), selector);
+        // `id` first, and always present: it needs no declared index, because
+        // `readIds` is exactly the lookup it describes (utils/idIndexQuery.ts).
+        return (0, getIndexInfo_1.default)(indices.map(field => (0, storageIndexQuery_1.default)(storageAdapter, field)), selector);
     }
     async queryItems(collectionName, selector) {
         const storageAdapter = this.storageAdapters.get(collectionName);

package/dist/base/core/src/getIndexInfo.js

@@ -135,12 +135,24 @@ function getIndexInfo(queryFunctions, selector) {
             let hasNonIndexField = false;
             const matchedBefore = matched;
             const idsBefore = ids;
+            // The branches of an $or union with each other, but the $or as a whole
+            // *intersects* with what the flat fields and $and already narrowed down
+            // to. Collecting the branches separately is what keeps those two apart —
+            // folding them into `ids` turns `{ a: 1, $or: [...] }` into a union and
+            // returns items matching neither half of the selector, with an empty
+            // optimized selector that leaves nothing to filter them out again.
+            let orIds = [];
+            let orMatched = false;
             const process$or = ($orNew) => {
                 if (hasNonIndexField || ($orNew && $orNew.length > 0)) {
                     newSelector.$or = $or;
                     matched = matchedBefore;
                     ids = idsBefore;
                 }
+                else if (orMatched) {
+                    ids = matchedBefore ? (0, intersection_1.default)(idsBefore, orIds) : orIds;
+                    matched = true;
+                }
                 return {
                     matched,
                     ids: ids || [],
@@ -150,8 +162,8 @@ function getIndexInfo(queryFunctions, selector) {
             const $orNewOrPromise = Array.isArray($or)
                 ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
                     if (match) {
-                        ids = [...new Set([...ids, ...selIds])];
-                        matched = true;
+                        orIds = [...new Set([...orIds, ...selIds])];
+                        orMatched = true;
                     }
                     else {
                         hasNonIndexField = true;

package/dist/base/core/src/types/StorageAdapter.d.ts

@@ -12,7 +12,15 @@ export default interface StorageAdapter<T extends {
     readIds(positions: I[]): Promise<T[]>;
     createIndex(field: string): Promise<void>;
     dropIndex(field: string): Promise<void>;
-    readIndex(field: string): Promise<Map<any, Set<I>>>;
+    /**
+     * The index, keyed by `serializeValue(value)` — not by the raw field value.
+     *
+     * SignalDB looks an index up with the serialized form, because that is what
+     * makes `3`, `'3'` and `new Date(...)` comparable as map keys at all. An
+     * adapter that stores its backend's own keys instead answers nothing for
+     * every non-string field, and everything for a `$ne` on one.
+     */
+    readIndex(field: string): Promise<Map<string | null, Set<I>>>;
     insert(items: T[]): Promise<void>;
     replace(items: T[]): Promise<void>;
     remove(items: T[]): Promise<void>;

package/dist/base/core/src/utils/idIndexQuery.d.ts

@@ -0,0 +1,20 @@
+import type { BaseItem } from '../Collection/types';
+import type { IndexResult } from '../types/IndexProvider';
+import type { FlatSelector } from '../types/Selector';
+/**
+ * Resolves a selector on `id` into the ids it names, without consulting an index.
+ *
+ * `id` is the one field every storage adapter can look up directly — that is what
+ * `readIds` is — so a query on it never needs an index to be declared and never
+ * needs the whole collection to be read. This behaves like an index provider that
+ * happens to need no stored index, because the ids are already in the selector.
+ *
+ * Only inclusive forms can be answered this way. `$ne`/`$nin` describe everything
+ * except* something, which cannot be enumerated without knowing every id, so they
+ * report no match and take the ordinary path.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param selector - The flat selector to resolve.
+ * @returns An index result naming the matched ids, or `{ matched: false }`.
+ */
+export default function idIndexQuery<T extends BaseItem<I> = BaseItem, I = any>(selector: FlatSelector<T>): IndexResult<I>;

package/dist/base/core/src/utils/idIndexQuery.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = idIndexQuery;
+const isFieldExpression_1 = __importDefault(require("./isFieldExpression"));
+/**
+ * Resolves a selector on `id` into the ids it names, without consulting an index.
+ *
+ * `id` is the one field every storage adapter can look up directly — that is what
+ * `readIds` is — so a query on it never needs an index to be declared and never
+ * needs the whole collection to be read. This behaves like an index provider that
+ * happens to need no stored index, because the ids are already in the selector.
+ *
+ * Only inclusive forms can be answered this way. `$ne`/`$nin` describe everything
+ * except* something, which cannot be enumerated without knowing every id, so they
+ * report no match and take the ordinary path.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param selector - The flat selector to resolve.
+ * @returns An index result naming the matched ids, or `{ matched: false }`.
+ */
+function idIndexQuery(selector) {
+    if (selector == null || !Object.hasOwnProperty.call(selector, 'id'))
+        return { matched: false };
+    const fieldSelector = selector.id;
+    if (fieldSelector == null || fieldSelector instanceof RegExp)
+        return { matched: false };
+    if ((0, isFieldExpression_1.default)(fieldSelector)) {
+        const values = fieldSelector.$in;
+        if (!Array.isArray(values) || values.length <= 0)
+            return { matched: false };
+        return {
+            matched: true,
+            ids: values,
+            fields: ['id'],
+            keepSelector: false,
+        };
+    }
+    if (typeof fieldSelector === 'object')
+        return { matched: false };
+    return {
+        matched: true,
+        ids: [fieldSelector],
+        fields: ['id'],
+        keepSelector: false,
+    };
+}

package/dist/base/core/src/utils/storageIndexQuery.d.ts

@@ -0,0 +1,20 @@
+import type { BaseItem } from '../Collection/types';
+import type StorageAdapter from '../types/StorageAdapter';
+import type { AsynchronousQueryFunction } from '../types/IndexProvider';
+/**
+ * Builds the index provider a data adapter uses to narrow a selector down through
+ * a storage adapter's index.
+ *
+ * Every adapter that keeps its data in a `StorageAdapter` needs exactly this, and
+ * each of them used to carry its own copy — three transcriptions of one set of
+ * rules about null, `$exists`, inclusion and exclusion, which is how they drift
+ * apart without anyone noticing. The index is keyed by `serializeValue(value)`,
+ * which is what `getMatchingKeys` produces, so the two only agree while they stay
+ * in one place.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param storage - The storage adapter holding the index.
+ * @param field - The indexed field this provider answers for.
+ * @returns A query function for `getIndexInfo`.
+ */
+export default function storageIndexQuery<T extends BaseItem<I>, I = any>(storage: Pick<StorageAdapter<T, I>, 'readIndex'>, field: string): AsynchronousQueryFunction<T, I>;

package/dist/base/core/src/utils/storageIndexQuery.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = storageIndexQuery;
+const getMatchingKeys_1 = __importDefault(require("./getMatchingKeys"));
+/**
+ * Builds the index provider a data adapter uses to narrow a selector down through
+ * a storage adapter's index.
+ *
+ * Every adapter that keeps its data in a `StorageAdapter` needs exactly this, and
+ * each of them used to carry its own copy — three transcriptions of one set of
+ * rules about null, `$exists`, inclusion and exclusion, which is how they drift
+ * apart without anyone noticing. The index is keyed by `serializeValue(value)`,
+ * which is what `getMatchingKeys` produces, so the two only agree while they stay
+ * in one place.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param storage - The storage adapter holding the index.
+ * @param field - The indexed field this provider answers for.
+ * @returns A query function for `getIndexInfo`.
+ */
+function storageIndexQuery(storage, field) {
+    return async (flatSelector) => {
+        if (!Object.hasOwnProperty.call(flatSelector, field)) {
+            // The field is not in the selector, so this index says nothing about it.
+            return { matched: false };
+        }
+        const index = await storage.readIndex(field);
+        const fieldSelector = flatSelector[field];
+        // A query for null, or for the field being absent, is the one case the index
+        // cannot answer by naming keys — it is answered by naming every key it is
+        // *not*, and the selector has to stay for the matcher to confirm it.
+        const filtersForNull = fieldSelector == null || fieldSelector.$exists === false;
+        const keys = filtersForNull
+            ? { include: null, exclude: [...index.keys()].filter(key => key != null) }
+            : (0, getMatchingKeys_1.default)(field, flatSelector);
+        if (keys.include == null && keys.exclude == null)
+            return { matched: false };
+        let includedIds = [];
+        if (keys.include == null) {
+            for (const set of index.values()) {
+                for (const id of set)
+                    includedIds.push(id);
+            }
+        }
+        else {
+            for (const key of keys.include) {
+                const idSet = index.get(key);
+                if (idSet) {
+                    for (const id of idSet)
+                        includedIds.push(id);
+                }
+            }
+        }
+        if (keys.exclude != null) {
+            const excludedIds = new Set();
+            for (const key of keys.exclude) {
+                const idSet = index.get(key);
+                if (idSet) {
+                    for (const id of idSet)
+                        excludedIds.add(id);
+                }
+            }
+            includedIds = includedIds.filter(id => !excludedIds.has(id));
+        }
+        return {
+            matched: true,
+            ids: includedIds,
+            fields: [field],
+            keepSelector: filtersForNull,
+        };
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@signaldb/svelte",
   "type": "module",
-  "version": "2.0.0-beta.18",
+  "version": "2.0.0-beta.19",
   "scripts": {
     "build": "tsc -d --noEmit false",
     "analyze-bundle": "bundle-analyzer ./dist --upload-token=$BUNDLE_ANALYZER_UPLOAD_TOKEN --bundle-name=@signaldb/svelte",