liwi-mongo 14.1.0 → 15.0.0

package/README.md

@@ -290,13 +290,31 @@ const subscription = query.fetchAndSubscribe((error, changes) => {
 subscription.stop();
 ```
 
-`createQuerySingleItem` behaves the same but resolves a single item. Without `sort`, its criteria must match at most one document: when one update moves several matching documents, the subscription reports the error `should not match more than 1, use sort if you can have multiple match` through its callback. With `sort`, it refetches on every relevant update.
+`createQuerySingleItem` behaves the same but resolves a single item. It keeps the key of the item its client holds: a write concerns it when it is about that key or the written document matches. Without `sort`, its criteria must match at most one document: when one update moves several matching documents, the subscription reports the error `should not match more than 1, use sort if you can have multiple match` through its callback. With `sort`, it refetches on every relevant update, and when its item is deleted.
 
 Subscriptions are driven in-process: writes going through the subscribe store are matched against the query criteria with [mingo](https://github.com/kofrasa/mingo).
 
+Each collection subscription keeps the keys its client holds, and decides from them and the stored document, not from the write's `prev`:
+
+| Held by the client | Document matches the criteria | Sent       |
+| ------------------ | ----------------------------- | ---------- |
+| yes                | yes                           | `updated`  |
+| yes                | no, or deleted                | `deleted`  |
+| no                 | yes                           | `inserted` |
+| no                 | no, or deleted                | nothing    |
+
+A `changed` notification ([writes from another process](../liwi-subscribe-store#writes-from-another-process)) is re-read by each concerned subscription, in its order, so a repeated or late one is harmless.
+
+With `limit` or `skip`, a document entering or leaving the result refetches it (`find` and `count`) and sends `initial` instead: only the server knows which document fills or leaves the window. With `limit`, when more documents match than the query shows (a 101st matching document exists for `limit: 100`), and with `skip`, a write to any document the client does not hold refetches, matching or not: a matching one may enter the window, and one that left the criteria may have shifted a skipped page or changed `meta.total`, which neither its key nor its new state shows. When a limited result holds every match, only a write making a document match refetches. Each such write costs one refetch per open subscription of that query.
+
+`resync()` on the store refetches every subscription and sends `initial`, also to one opened with `subscribe`. Such a subscription (no initial result) still fetches once, to know the keys: its thenable resolves after that fetch, and rejects when it fails. When a write happens during that fetch, it sends the fetch result as `initial` anyway: the client's own earlier result may hold a document the fetch no longer sees, or miss one it does. Until a fetch succeeded, writes are ignored; a `resync` retries.
+
+Changes are computed one action at a time per subscription, so a refetch is never overtaken by an older change. While nothing is pending they reach the callback during the write call, as before; behind a refetch (and the initial fetch) they wait for it.
+
 Caveats:
 
-- Writes performed outside this process (other services, mongo shell, migrations) are not detected.
+- Writes performed outside a subscribe store (mongo shell, migrations) are not detected. Another process writing through its own subscribe store can relay its keys.
+- Updated rows of a sorted query are sent as `updated`: the client keeps their position.
 - `$text` criteria cannot be matched in memory: such queries fetch correctly but never emit updates.
 - Queries returned by the subscribe store are fixed — `changeParams` throws; build a new query when parameters change.
 

package/dist/definitions/MongoQueryCollection.d.ts

@@ -11,7 +11,21 @@ export default class MongoQueryCollection<Model extends MongoBaseModel<KeyValue>
     constructor(store: MongoStore<Model, KeyValue>, options: QueryOptions<Model>, transformer?: Transformer<Model, Item>);
     createTestCriteria(): TestCriteria;
     fetch<T>(onFulfilled: (result: QueryResult<Item[]>) => T): Promise<T>;
+    /**
+     * Each subscription keeps the keys its client holds, and decides from them and
+     * the stored document alone, never from the emitted `prev`. A `changed`
+     * notification (written by another process) is re-read here, in this
+     * subscription's order, if it concerns it: a repeated, late or crossing
+     * notification leaves the client equal to a fresh fetch. A subscription opened
+     * without its initial result still fetches it, to know those keys, and sends it
+     * when a write raced with that fetch. With `limit` or `skip`, a document
+     * entering or leaving refetches instead: only the server knows what fills or
+     * leaves the window.
+     */
     _subscribe(callback: SubscribeCallback<KeyValue, Item[]>, _includeInitial: boolean): QuerySubscription;
+    private canTestCriteria;
+    private isWindowed;
+    private computeMemberships;
     private createMongoCursor;
 }
 export {};

package/dist/definitions/MongoQueryCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MongoQueryCollection.d.ts","sourceRoot":"","sources":["../../src/MongoQueryCollection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EAEf,YAAY,EACZ,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACb,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAS3C,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,oBAAoB,CACvC,KAAK,SAAS,cAAc,CAAC,QAAQ,CAAC,EACtC,MAAM,SAAS,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,EAC1C,QAAQ,SAAS,eAAe,GAAG,KAAK,CAAC,KAAK,CAAC,EAC/C,IAAI,SAAS,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,KAAK,CACnD,SAAQ,8BAA8B,CACtC,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,EAChC,MAAM,EACN,IAAI,EAAE,CACP;IACC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IAEpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2B;IAEvD,YACE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,EAClC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,EAC5B,WAAW,GAAE,WAAW,CAAC,KAAK,EAAE,IAAI,CAAuB,EAM5D;IAED,kBAAkB,IAAI,YAAY,CAejC;IAEK,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAe1E;IAED,UAAU,CACR,QAAQ,EAAE,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,EAC7C,eAAe,EAAE,OAAO,GACvB,iBAAiB,CA+GnB;YAEa,iBAAiB;CAmBhC"}
+{"version":3,"file":"MongoQueryCollection.d.ts","sourceRoot":"","sources":["../../src/MongoQueryCollection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EAGf,YAAY,EACZ,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACb,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAU3C,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;AAkD1C,MAAM,CAAC,OAAO,OAAO,oBAAoB,CACvC,KAAK,SAAS,cAAc,CAAC,QAAQ,CAAC,EACtC,MAAM,SAAS,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,EAC1C,QAAQ,SAAS,eAAe,GAAG,KAAK,CAAC,KAAK,CAAC,EAC/C,IAAI,SAAS,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,KAAK,CACnD,SAAQ,8BAA8B,CACtC,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,EAChC,MAAM,EACN,IAAI,EAAE,CACP;IACC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IAEpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2B;IAEvD,YACE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,EAClC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,EAC5B,WAAW,GAAE,WAAW,CAAC,KAAK,EAAE,IAAI,CAAuB,EAM5D;IAED,kBAAkB,IAAI,YAAY,CAejC;IAEK,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAe1E;IAED;;;;;;;;;;OAUG;IACH,UAAU,CACR,QAAQ,EAAE,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,EAC7C,eAAe,EAAE,OAAO,GACvB,iBAAiB,CAkHnB;IAED,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,kBAAkB;YA0BZ,iBAAiB;CAmBhC"}

package/dist/definitions/MongoQuerySingleItem.d.ts

@@ -11,6 +11,10 @@ export default class MongoQuerySingleItem<Model extends MongoBaseModel<KeyValue>
     constructor(store: MongoStore<Model, KeyValue>, options: QueryOptions<Model>, transformer?: Transformer<Model, Result>);
     createMingoTestCriteria(): TestCriteria;
     fetch<T>(onFulfilled: (result: QueryResult<Result>) => T): Promise<T>;
+    /**
+     * From the key the client holds and the written documents, not from `prev`.
+     * `refetch` when the result can only be known by querying again.
+     */
     private computeChanges;
     _subscribe(callback: SubscribeCallback<KeyValue, Result>, _includeInitial: boolean): QuerySubscription;
     private createMongoCursor;

package/dist/definitions/MongoQuerySingleItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MongoQuerySingleItem.d.ts","sourceRoot":"","sources":["../../src/MongoQuerySingleItem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEf,YAAY,EACZ,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACb,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAS3C,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,oBAAoB,CACvC,KAAK,SAAS,cAAc,CAAC,QAAQ,CAAC,EACtC,MAAM,SAAS,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,EAC1C,MAAM,SAAS,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,EACnE,QAAQ,SAAS,eAAe,GAAG,KAAK,CAAC,KAAK,CAAC,CAC/C,SAAQ,8BAA8B,CACtC,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,EAChC,MAAM,EACN,MAAM,CACP;IACC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IAEpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IAEzD,YACE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,EAClC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,EAC5B,WAAW,GAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAuB,EAM9D;IAED,uBAAuB,IAAI,YAAY,CAWtC;IAEK,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAe1E;YAEa,cAAc;IAkD5B,UAAU,CACR,QAAQ,EAAE,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,EAC7C,eAAe,EAAE,OAAO,GACvB,iBAAiB,CAuCnB;YAEa,iBAAiB;CAehC"}
+{"version":3,"file":"MongoQuerySingleItem.d.ts","sourceRoot":"","sources":["../../src/MongoQuerySingleItem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAGf,YAAY,EACZ,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACb,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAU3C,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,oBAAoB,CACvC,KAAK,SAAS,cAAc,CAAC,QAAQ,CAAC,EACtC,MAAM,SAAS,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,EAC1C,MAAM,SAAS,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,EACnE,QAAQ,SAAS,eAAe,GAAG,KAAK,CAAC,KAAK,CAAC,CAC/C,SAAQ,8BAA8B,CACtC,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,EAChC,MAAM,EACN,MAAM,CACP;IACC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IAEpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IAEzD,YACE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,EAClC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,EAC5B,WAAW,GAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAuB,EAM9D;IAED,uBAAuB,IAAI,YAAY,CAWtC;IAEK,KAAK,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAe1E;IAED;;;OAGG;IACH,OAAO,CAAC,cAAc;IAgDtB,UAAU,CACR,QAAQ,EAAE,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,EAC7C,eAAe,EAAE,OAAO,GACvB,iBAAiB,CAiGnB;YAEa,iBAAiB;CAehC"}

package/dist/definitions/MongoQuerySubscription.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MongoQuerySubscription.test.d.ts.map

package/dist/definitions/MongoQuerySubscription.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MongoQuerySubscription.test.d.ts","sourceRoot":"","sources":["../../src/MongoQuerySubscription.test.ts"],"names":[],"mappings":""}

package/dist/definitions/createActionQueue.d.ts

@@ -0,0 +1,9 @@
+export type ActionRunner = () => Promise<void> | undefined;
+/**
+ * Runs a subscription's actions in order: synchronously while nothing
+ * asynchronous is pending, so a change reaches the subscriber during the write
+ * call; behind the pending work otherwise (the initial fetch, a refetch), so a
+ * refetch is never overtaken by an older change.
+ */
+export declare const createActionQueue: (initial: Promise<unknown>, onError: (error: unknown) => void) => ((run: ActionRunner) => void);
+//# sourceMappingURL=createActionQueue.d.ts.map

package/dist/definitions/createActionQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createActionQueue.d.ts","sourceRoot":"","sources":["../../src/createActionQueue.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,YACnB,OAAO,CAAC,OAAO,CAAC,WAChB,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,KAChC,CAAC,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAgC9B,CAAC"}

package/dist/definitions/createActionQueue.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createActionQueue.test.d.ts.map

package/dist/definitions/createActionQueue.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createActionQueue.test.d.ts","sourceRoot":"","sources":["../../src/createActionQueue.test.ts"],"names":[],"mappings":""}

package/dist/index-node.mjs

@@ -45,7 +45,64 @@ class MongoCursor extends AbstractStoreCursor {
   }
 }
 
+const createActionQueue = (initial, onError) => {
+  let tail;
+  const track = (promise, isReported) => {
+    const current = promise.then(
+      () => {
+      },
+      (error) => {
+        if (isReported) onError(error);
+      }
+    ).then(() => {
+      if (tail === current) tail = void 0;
+    });
+    tail = current;
+  };
+  track(initial, false);
+  return (run) => {
+    if (tail) {
+      track(tail.then(run), true);
+      return;
+    }
+    try {
+      const pending = run();
+      if (pending) track(pending, true);
+    } catch (error) {
+      onError(error);
+    }
+  };
+};
+
 const identityTransformer$1 = (model) => model;
+const getWrittenStates = (action, keyPath) => {
+  const states = /* @__PURE__ */ new Map();
+  switch (action.type) {
+    case "inserted":
+      action.next.forEach((next) => states.set(next[keyPath], next));
+      break;
+    case "deleted":
+      action.prev.forEach((prev) => states.set(prev[keyPath], void 0));
+      break;
+    case "updated":
+      action.changes.forEach(([, next]) => states.set(next[keyPath], next));
+      break;
+    default:
+      throw new Error("Unsupported type");
+  }
+  return states;
+};
+const toCollectionChanges = ({
+  deleted,
+  updated,
+  inserted
+}) => {
+  const changes = [];
+  if (deleted.length > 0) changes.push({ type: "deleted", keys: deleted });
+  if (updated.length > 0) changes.push({ type: "updated", result: updated });
+  if (inserted.length > 0) changes.push({ type: "inserted", result: inserted });
+  return changes;
+};
 class MongoQueryCollection extends AbstractSubscribableStoreQuery {
   store;
   options;
@@ -85,81 +142,122 @@ class MongoQueryCollection extends AbstractSubscribableStoreQuery {
       }
     });
   }
+  /**
+   * Each subscription keeps the keys its client holds, and decides from them and
+   * the stored document alone, never from the emitted `prev`. A `changed`
+   * notification (written by another process) is re-read here, in this
+   * subscription's order, if it concerns it: a repeated, late or crossing
+   * notification leaves the client equal to a fresh fetch. A subscription opened
+   * without its initial result still fetches it, to know those keys, and sends it
+   * when a write raced with that fetch. With `limit` or `skip`, a document
+   * entering or leaving refetches instead: only the server knows what fills or
+   * leaves the window.
+   */
   _subscribe(callback, _includeInitial) {
     const store = super.getSubscribeStore();
+    const keyPath = this.store.keyPath;
     const testCriteria = this.createTestCriteria();
-    const promise = _includeInitial ? this.fetch(({ result, meta, info }) => {
-      callback(null, [
-        {
-          type: "initial",
-          initial: result,
-          queryInfo: info,
-          meta
-        }
-      ]);
-    }) : Promise.resolve();
-    const unsubscribe = store.subscribe((action) => {
-      const changes = [];
-      switch (action.type) {
-        case "inserted": {
-          const filtered = action.next.filter(testCriteria);
-          if (filtered.length > 0) {
-            changes.push({
-              type: "inserted",
-              result: filtered.map(this.transformer)
-            });
-          }
-          break;
-        }
-        case "deleted": {
-          const filtered = action.prev.filter(testCriteria);
-          if (filtered.length > 0) {
-            changes.push({
-              type: "deleted",
-              keys: filtered.map((object) => object[this.store.keyPath])
-            });
-          }
-          break;
-        }
-        case "updated": {
-          const {
-            deleted,
-            updated,
-            inserted
-          } = { deleted: [], updated: [], inserted: [] };
-          action.changes.forEach(([prevObject, nextObject]) => {
-            if (testCriteria(prevObject)) {
-              if (!testCriteria(nextObject)) {
-                deleted.push(prevObject[this.store.keyPath]);
-              } else {
-                updated.push(this.transformer(nextObject));
-              }
-            } else if (testCriteria(nextObject)) {
-              inserted.push(this.transformer(nextObject));
-            }
-          });
-          if (deleted.length > 0) {
-            changes.push({ type: "deleted", keys: deleted });
-          }
-          if (updated.length > 0) {
-            changes.push({ type: "updated", result: updated });
-          }
-          if (inserted.length > 0) {
-            changes.push({ type: "inserted", result: inserted });
-          }
-          break;
+    let sentKeys = /* @__PURE__ */ new Set();
+    let total = 0;
+    let isReady = false;
+    let isInitializing = true;
+    let hasActionDuringInit = false;
+    let isStopped = false;
+    const send = (changes) => {
+      if (!isStopped && changes.length > 0) callback(null, changes);
+    };
+    const refetch = () => this.fetch(({ result, meta, info }) => {
+      sentKeys = new Set(result.map((item) => item[keyPath]));
+      total = meta.total;
+      isReady = true;
+      return [{ type: "initial", initial: result, queryInfo: info, meta }];
+    });
+    const initialPromise = refetch().then((changes) => {
+      isInitializing = false;
+      if (_includeInitial || hasActionDuringInit) send(changes);
+    });
+    const applyStates = (states) => {
+      const memberships = this.computeMemberships(states, sentKeys);
+      if (this.isWindowed() && (memberships.inserted.length > 0 || memberships.deleted.length > 0)) {
+        return refetch().then(send);
+      }
+      memberships.deleted.forEach((key) => sentKeys.delete(key));
+      memberships.inserted.forEach((item) => sentKeys.add(item[keyPath]));
+      send(toCollectionChanges(memberships));
+      return void 0;
+    };
+    const rereadAndApply = async (keys) => {
+      const states = new Map(
+        keys.map((key) => [key, void 0])
+      );
+      const byKeys = { [keyPath]: { $in: keys } };
+      const stored = await this.store.findAll(byKeys);
+      stored.forEach((model) => states.set(model[keyPath], model));
+      if (!isStopped) await applyStates(states);
+    };
+    const handleAction = (action) => {
+      if (isStopped) return void 0;
+      if (action.type === "resync") return refetch().then(send);
+      if (!isReady || !this.canTestCriteria()) return void 0;
+      if (this.options.skip || this.options.limit && total > sentKeys.size) {
+        const keys = action.type === "changed" ? action.keys : [...getWrittenStates(action, keyPath).keys()];
+        if (keys.some((key) => !sentKeys.has(key))) {
+          return refetch().then(send);
         }
-        default:
-          throw new Error("Unsupported type");
       }
-      if (changes.length === 0) return;
-      callback(null, changes);
+      if (action.type === "changed") {
+        const matchingKeys = new Set(
+          action.next.filter(testCriteria).map((model) => model[keyPath])
+        );
+        const concernedKeys = action.keys.filter(
+          (key) => sentKeys.has(key) || matchingKeys.has(key)
+        );
+        return concernedKeys.length > 0 ? rereadAndApply(concernedKeys) : void 0;
+      }
+      return applyStates(getWrittenStates(action, keyPath));
+    };
+    const enqueue = createActionQueue(initialPromise, (error) => {
+      if (!isStopped) callback(error, []);
     });
+    const unsubscribe = store.subscribe((action) => {
+      if (isInitializing) hasActionDuringInit = true;
+      enqueue(() => handleAction(action));
+    });
+    const stop = () => {
+      isStopped = true;
+      unsubscribe();
+    };
     return {
-      stop: unsubscribe,
-      cancel: unsubscribe,
-      then: (onFulfilled, onRejected) => promise.then(onFulfilled, onRejected)
+      stop,
+      cancel: stop,
+      then: (onFulfilled, onRejected) => initialPromise.then(onFulfilled, onRejected)
+    };
+  }
+  canTestCriteria() {
+    return !this.options.criteria || !("$text" in this.options.criteria);
+  }
+  isWindowed() {
+    return !!this.options.limit || !!this.options.skip;
+  }
+  computeMemberships(states, sentKeys) {
+    const testCriteria = this.createTestCriteria();
+    const memberships = {
+      deleted: [],
+      updated: [],
+      inserted: []
     };
+    states.forEach((next, key) => {
+      const isSent = sentKeys.has(key);
+      const isMatching = next !== void 0 && testCriteria(next);
+      if (isSent && isMatching) {
+        memberships.updated.push(this.transformer(next));
+      } else if (isSent) {
+        memberships.deleted.push(key);
+      } else if (isMatching) {
+        memberships.inserted.push(this.transformer(next));
+      }
+    });
+    return memberships;
   }
   async createMongoCursor() {
     const cursor = await this.store.cursor(
@@ -214,7 +312,12 @@ class MongoQuerySingleItem extends AbstractSubscribableStoreQuery {
       });
     });
   }
-  async computeChanges(action, testCriteria) {
+  /**
+   * From the key the client holds and the written documents, not from `prev`.
+   * `refetch` when the result can only be known by querying again.
+   */
+  computeChanges(action, testCriteria, currentKey) {
+    const keyPath = this.store.keyPath;
     switch (action.type) {
       case "inserted": {
         const filtered = action.next.filter(testCriteria);
@@ -222,24 +325,17 @@ class MongoQuerySingleItem extends AbstractSubscribableStoreQuery {
         return [{ type: "updated", result: this.transformer(filtered[0]) }];
       }
       case "deleted": {
-        const filtered = action.prev.filter(testCriteria);
-        if (filtered.length === 0) return [];
-        return [
-          {
-            type: "deleted",
-            keys: filtered.map((object) => object[this.store.keyPath])
-          }
-        ];
+        const isCurrentDeleted = currentKey !== null && action.prev.some((prev) => prev[keyPath] === currentKey);
+        if (!isCurrentDeleted) return [];
+        if (this.options.sort) return "refetch";
+        return [{ type: "deleted", keys: [currentKey] }];
       }
       case "updated": {
         const filtered = action.changes.filter(
-          ([prev, next2]) => testCriteria(prev) || testCriteria(next2)
+          ([, next2]) => next2[keyPath] === currentKey || testCriteria(next2)
         );
         if (filtered.length === 0) return [];
-        if (this.options.sort) {
-          const { result } = await this.fetch((res) => res);
-          return [{ type: "updated", result }];
-        }
+        if (this.options.sort) return "refetch";
         if (filtered.length > 1) {
           throw new Error(
             "should not match more than 1, use sort if you can have multiple match"
@@ -260,31 +356,78 @@ class MongoQuerySingleItem extends AbstractSubscribableStoreQuery {
   _subscribe(callback, _includeInitial) {
     const store = super.getSubscribeStore();
     const testCriteria = this.createMingoTestCriteria();
-    const promise = _includeInitial ? this.fetch(({ result, meta, info }) => {
-      callback(null, [
-        {
-          type: "initial",
-          initial: result,
-          queryInfo: info,
-          meta
-        }
-      ]);
-    }) : Promise.resolve();
-    const unsubscribe = store.subscribe(async (action) => {
-      let changes;
-      try {
-        changes = await this.computeChanges(action, testCriteria);
-      } catch (error) {
-        callback(error, []);
-        return;
+    const keyPath = this.store.keyPath;
+    let currentKey = null;
+    let isReady = false;
+    let isStopped = false;
+    const getKeyAfter = (change) => {
+      switch (change.type) {
+        case "initial":
+          return change.initial?.[keyPath] ?? null;
+        case "inserted":
+        case "updated":
+          return change.result?.[keyPath] ?? null;
+        case "deleted":
+          return null;
+        default:
+          throw new Error("Unsupported type");
       }
-      if (changes.length === 0) return;
+    };
+    const send = (changes) => {
+      if (isStopped || changes.length === 0) return;
+      currentKey = getKeyAfter(changes.at(-1));
       callback(null, changes);
+    };
+    const refetch = () => this.fetch((result) => {
+      isReady = true;
+      return result;
+    });
+    let isInitializing = true;
+    let hasActionDuringInit = false;
+    const initialPromise = refetch().then(
+      ({ result, meta, info }) => {
+        isInitializing = false;
+        currentKey = result?.[keyPath] ?? null;
+        if (_includeInitial || hasActionDuringInit) {
+          send([{ type: "initial", initial: result, queryInfo: info, meta }]);
+        }
+      }
+    );
+    const refetchAsUpdated = () => refetch().then(({ result }) => {
+      send([{ type: "updated", result }]);
+    });
+    const handleAction = (action) => {
+      if (isStopped) return void 0;
+      if (action.type === "resync") {
+        return refetch().then(({ result, meta, info }) => {
+          send([{ type: "initial", initial: result, queryInfo: info, meta }]);
+        });
+      }
+      if (!isReady) return void 0;
+      if (action.type === "changed") {
+        const isConcerned = currentKey !== null && action.keys.includes(currentKey) || action.next.some(testCriteria);
+        return isConcerned ? refetchAsUpdated() : void 0;
+      }
+      const changes = this.computeChanges(action, testCriteria, currentKey);
+      if (changes === "refetch") return refetchAsUpdated();
+      send(changes);
+      return void 0;
+    };
+    const enqueue = createActionQueue(initialPromise, (error) => {
+      if (!isStopped) callback(error, []);
     });
+    const unsubscribe = store.subscribe((action) => {
+      if (isInitializing) hasActionDuringInit = true;
+      enqueue(() => handleAction(action));
+    });
+    const stop = () => {
+      isStopped = true;
+      unsubscribe();
+    };
     return {
-      stop: unsubscribe,
-      cancel: unsubscribe,
-      then: (onFulfilled, onRejected) => promise.then(onFulfilled, onRejected)
+      stop,
+      cancel: stop,
+      then: (onFulfilled, onRejected) => initialPromise.then(onFulfilled, onRejected)
     };
   }
   async createMongoCursor() {