From fe7cc08287e0f76cb3807244475d6117334e6a23 Mon Sep 17 00:00:00 2001
From: Bruno Windels <brunow@matrix.org>
Date: Wed, 19 Aug 2020 18:25:49 +0200
Subject: [PATCH] add _selectWhile with proper "while" semantics

the existing _selectWhile method was more like _selectUntil,
which is what we want for _selectLimit but not for selectWhile(Reverse)

The changes we had made before also broke _selectLimit as it would
look at the results length before the value got added so you
always got 1 value more than requested, breaking sync.
---
 src/matrix/storage/idb/QueryTarget.js | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/matrix/storage/idb/QueryTarget.js b/src/matrix/storage/idb/QueryTarget.js
index 8a542710..0738df60 100644
--- a/src/matrix/storage/idb/QueryTarget.js
+++ b/src/matrix/storage/idb/QueryTarget.js
@@ -62,11 +62,11 @@ export class QueryTarget {
     }
 
     selectWhile(range, predicate) {
-        return this._selectWhile(range, predicate, "next", false);
+        return this._selectWhile(range, predicate, "next");
     }
 
     selectWhileReverse(range, predicate) {
-        return this._selectWhile(range, predicate, "prev", false);
+        return this._selectWhile(range, predicate, "prev");
     }
 
     async selectAll(range, direction) {
@@ -151,20 +151,31 @@ export class QueryTarget {
     }
 
     _selectLimit(range, amount, direction) {
-        return this._selectWhile(range, (results) => {
+        return this._selectUntil(range, (results) => {
             return results.length === amount;
-        }, direction, true);
+        }, direction);
     }
 
-    async _selectWhile(range, predicate, direction, includeFailingPredicateResult) {
+    async _selectUntil(range, predicate, direction) {
         const cursor = this._openCursor(range, direction);
         const results = [];
         await iterateCursor(cursor, (value) => {
-            const passesPredicate = predicate(results, value);
-            if (passesPredicate || includeFailingPredicateResult) {
+            results.push(value);
+            return {done: predicate(results, value)};
+        });
+        return results;
+    }
+
+    // allows you to fetch one too much that won't get added when the predicate fails
+    async _selectWhile(range, predicate, direction) {
+        const cursor = this._openCursor(range, direction);
+        const results = [];
+        await iterateCursor(cursor, (value) => {
+            const passesPredicate = predicate(value);
+            if (passesPredicate) {
                 results.push(value);
             }
-            return {done: passesPredicate};
+            return {done: !passesPredicate};
         });
         return results;
     }