@signaldb/svelte 2.0.0-beta.17 → 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/WorkerDataAdapter.d.ts

@@ -44,10 +44,15 @@ export default class WorkerDataAdapter implements DataAdapter {
     private execInBackground;
     private queryItemsById;
     private flattenPendingWrites;
+    private static pushPendingEntry;
+    private static dropPendingEntry;
+    private static writeFlatEntry;
     private static providesFullItems;
     private observableItems;
     private observableItemsByIds;
     private servedResult;
+    private advanceServedResult;
+    private changesetForIds;
     private computeServedResult;
     /**
      * Registers a write's effect locally and notifies every active query it

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

@@ -62,6 +62,11 @@ class WorkerDataAdapter {
     // own `queryUpdate` has already landed (it is posted before the write's
     // response, and message order is preserved), on failure dropping it is the
     // rollback.
+    //
+    // Held in three shapes, because each answers a different question cheaply and none of them
+    // answers all three: `writes` says which ids a settling write touched, `byId` says what an id
+    // looked like before the newest write touched it, and `flat` is the collapsed view every reader
+    // actually wants. They are maintained together, as writes arrive and settle.
     pendingWrites = new Map();
     pendingWriteSeq = 0;
     // Bumped whenever a collection's pending writes change, in either direction. Anything derived
@@ -261,27 +266,51 @@ class WorkerDataAdapter {
     }
     // The pending writes of a collection collapsed into one upsert/delete view, newest write winning.
     // `null` when there are none, which is the overwhelmingly common case and the one every caller
-    // below short-circuits on. Pending sets are tiny — a write or two in flight — so this is cheap in
-    // a way that touching each query's items is not.
+    // below short-circuits on. Maintained by the two helpers under it rather than rebuilt here, so
+    // this is a lookup whatever the size of the pending set — see `PendingWriteState`. The returned
+    // view is the live one: callers read it, never mutate it.
     flattenPendingWrites(collectionName) {
-        const pending = this.pendingWrites.get(collectionName);
-        if (!pending || pending.size === 0)
+        const state = this.pendingWrites.get(collectionName);
+        if (!state || state.writes.size === 0)
             return null;
-        const upserts = new Map();
-        const deletes = new Set();
-        [...pending.entries()]
-            .sort(([a], [b]) => a - b) // eslint-disable-line unicorn/no-array-sort -- unavailable on Hermes
-            .forEach(([, write]) => {
-            write.upserts.forEach((item, id) => {
-                upserts.set(id, item);
-                deletes.delete(id);
-            });
-            write.deletes.forEach((id) => {
-                deletes.add(id);
-                upserts.delete(id);
-            });
-        });
-        return { upserts, deletes };
+        return state.flat;
+    }
+    // Records one id's contribution from the write being registered. `seq` only ever grows, so the
+    // new entry is by construction the newest one for this id and therefore the one that wins.
+    static pushPendingEntry(state, id, item, seq) {
+        const stack = state.byId.get(id);
+        if (stack)
+            stack.push({ seq, item });
+        else
+            state.byId.set(id, [{ seq, item }]);
+        WorkerDataAdapter.writeFlatEntry(state, id, item);
+    }
+    // Takes one id's contribution back out as its write settles, and restores whatever the write
+    // below it said — or removes the id entirely when that was the only one.
+    static dropPendingEntry(state, id, seq) {
+        const stack = state.byId.get(id);
+        if (!stack)
+            return;
+        const index = stack.findIndex(entry => entry.seq === seq);
+        if (index !== -1)
+            stack.splice(index, 1);
+        const top = stack.at(-1);
+        if (!top) {
+            state.byId.delete(id);
+            state.flat.upserts.delete(id);
+            state.flat.deletes.delete(id);
+            return;
+        }
+        WorkerDataAdapter.writeFlatEntry(state, id, top.item);
+    }
+    static writeFlatEntry(state, id, item) {
+        if (item === null) {
+            state.flat.deletes.add(id);
+            state.flat.upserts.delete(id);
+            return;
+        }
+        state.flat.upserts.set(id, item);
+        state.flat.deletes.delete(id);
     }
     // The items an active query currently holds, deduplicated by id, plus whatever the pending writes
     // add or remove — the only items this adapter knows about, and the set a selector-based write is
@@ -355,10 +384,60 @@ class WorkerDataAdapter {
             && query.served.pendingVersion === pendingVersion) {
             return query.served.items;
         }
-        const items = this.computeServedResult(collectionName, query);
+        const items = this.advanceServedResult(collectionName, query, pendingVersion)
+            ?? this.computeServedResult(collectionName, query);
         query.served = { items, fromItems: query.items, pendingVersion };
         return items;
     }
+    // One step forward from the answer this query already had, instead of rebuilding it from every
+    // pending write. Only the ids the newest change touched are looked at, so a burst of writes costs
+    // each of them the size of that write — where rebuilding re-matched and re-projected the whole
+    // pending set per write, which is quadratic in the burst and was measured at twelve seconds for
+    // four thousand unsettled inserts against a single matching query.
+    //
+    // `null` means the step is not available and the caller has to rebuild: nothing to step from, a
+    // gap of more than one version, or a query shape whose result cannot be derived from itself — a
+    // projection cannot be re-matched against a selector naming fields it dropped, and a limited
+    // query is a window whose content can depend on rows it does not hold.
+    advanceServedResult(collectionName, query, pendingVersion) {
+        const served = query.served;
+        if (!served || served.fromItems !== query.items)
+            return null;
+        if (served.pendingVersion !== pendingVersion - 1)
+            return null;
+        if (!WorkerDataAdapter.providesFullItems(query) || query.options?.limit != null)
+            return null;
+        const state = this.pendingWrites.get(collectionName);
+        if (state?.lastChange == null || state.lastChange.version !== pendingVersion)
+            return null;
+        return (0, incrementalQueryUpdate_1.mergeChangesetIntoResult)(served.items, query.selector, query.options, this.changesetForIds(collectionName, query, state.lastChange.ids));
+    }
+    // What the named ids look like now — the pending value if one is still in flight for them, and
+    // otherwise whatever the last confirmed result said, which is what a settling write reverts to.
+    // The same rule answers a write arriving and a write settling, so both take the step above.
+    changesetForIds(collectionName, query, ids) {
+        const pending = this.flattenPendingWrites(collectionName);
+        const stored = this.queryItemsById(query);
+        const upserts = [];
+        const deletes = [];
+        ids.forEach((id) => {
+            const pendingItem = pending?.upserts.get(id);
+            if (pendingItem) {
+                upserts.push(pendingItem);
+                return;
+            }
+            if (pending?.deletes.has(id)) {
+                deletes.push(id);
+                return;
+            }
+            const storedItem = stored.get(id);
+            if (storedItem)
+                upserts.push(storedItem);
+            else
+                deletes.push(id);
+        });
+        return { upserts, deletes };
+    }
     computeServedResult(collectionName, query) {
         const pending = this.flattenPendingWrites(collectionName);
         if (!pending)
@@ -404,25 +483,49 @@ class WorkerDataAdapter {
         // changed for a reader rather than just that something did.
         const servedBefore = this.servedResults(collectionName, affected);
         const seq = this.pendingWriteSeq += 1;
-        const pending = this.pendingWrites.get(collectionName)
-            ?? new Map();
-        pending.set(seq, {
+        const state = this.pendingWrites.get(collectionName)
+            ?? {
+                writes: new Map(),
+                byId: new Map(),
+                flat: { upserts: new Map(), deletes: new Set() },
+                lastChange: null,
+            };
+        const write = {
             upserts: new Map(upserts.map(item => [item.id, item])),
             deletes: new Set(deletes),
-        });
-        this.pendingWrites.set(collectionName, pending);
+        };
+        state.writes.set(seq, write);
+        // Upserts first, then deletes, so a write naming the same id in both ends as a delete — the
+        // order the collapsed view was folded in when it was still rebuilt from scratch.
+        write.upserts.forEach((item, id) => WorkerDataAdapter.pushPendingEntry(state, id, item, seq));
+        write.deletes.forEach(id => WorkerDataAdapter.pushPendingEntry(state, id, null, seq));
+        this.pendingWrites.set(collectionName, state);
         this.bumpPendingWriteVersion(collectionName);
+        const addedVersion = this.pendingWriteVersions.get(collectionName) ?? 0;
+        state.lastChange = { version: addedVersion, ids: [...affectedIds] };
         this.notifyWithDeltas(collectionName, affected, servedBefore);
         return () => {
             const current = this.pendingWrites.get(collectionName);
             if (!current)
                 return;
+            const settled = current.writes.get(seq);
+            // Already dropped: settling twice must not take a *later* write's contribution back out.
+            if (!settled)
+                return;
             const affectedOnDrop = this.affectedQueries(collectionName, upserts, affectedIds);
             const beforeDrop = this.servedResults(collectionName, affectedOnDrop);
-            current.delete(seq);
-            if (current.size === 0)
+            current.writes.delete(seq);
+            settled.upserts.forEach((item, id) => WorkerDataAdapter.dropPendingEntry(current, id, seq));
+            settled.deletes.forEach(id => WorkerDataAdapter.dropPendingEntry(current, id, seq));
+            // With nothing left in flight the state is dropped entirely, and a query's served result is
+            // its stored one again — which `computeServedResult` answers without looking at anything.
+            if (current.writes.size === 0)
                 this.pendingWrites.delete(collectionName);
             this.bumpPendingWriteVersion(collectionName);
+            if (current.writes.size > 0) {
+                const droppedVersion = this.pendingWriteVersions.get(collectionName) ?? 0;
+                current.lastChange = { version: droppedVersion, ids: [...affectedIds] };
+            }
             // By the time a write settles the host's own answer has usually already landed, so dropping
             // the optimistic copy changes nothing a reader can see and produces no notification at all.
             this.notifyWithDeltas(collectionName, affectedOnDrop, beforeDrop);

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.17",
+  "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",