You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by bt...@apache.org on 2025/12/02 07:49:38 UTC

(james-project) 04/12: JAMES-3340 Cassandra implementation for collapseThreads handling with EmailQueryView

This is an automated email from the ASF dual-hosted git repository.

btellier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git

commit ea131cbf16f07654c9782e75d645d0541e779925
Author: Rene Cordier <rc...@linagora.com>
AuthorDate: Wed Sep 3 17:05:24 2025 +0700

    JAMES-3340 Cassandra implementation for collapseThreads handling with EmailQueryView
---
 .../projections/CassandraEmailQueryView.java       | 244 ++++++++++++++---
 .../projections/CassandraEmailQueryViewTest.java   |  12 +-
 .../projections/PostgresEmailQueryViewTest.java    |  12 +-
 .../memory/projections/MemoryEmailQueryView.java   |  29 +-
 .../api/projections/EmailQueryViewContract.java    | 291 +++++++++++++++------
 .../projections/MemoryEmailQueryViewTest.java      | 135 +---------
 6 files changed, 457 insertions(+), 266 deletions(-)

diff --git a/server/data/data-jmap-cassandra/src/main/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryView.java b/server/data/data-jmap-cassandra/src/main/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryView.java
index ab838eb895..de4942a37f 100644
--- a/server/data/data-jmap-cassandra/src/main/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryView.java
+++ b/server/data/data-jmap-cassandra/src/main/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryView.java
@@ -36,12 +36,17 @@ import static org.apache.james.jmap.cassandra.projections.table.CassandraEmailQu
 import java.time.Instant;
 import java.time.ZonedDateTime;
 import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Function;
 
 import jakarta.inject.Inject;
 
-import org.apache.commons.lang3.tuple.Pair;
 import org.apache.james.backends.cassandra.utils.CassandraAsyncExecutor;
 import org.apache.james.jmap.api.projections.EmailQueryView;
+import org.apache.james.jmap.cassandra.projections.table.CassandraEmailQueryViewTable;
 import org.apache.james.mailbox.cassandra.ids.CassandraId;
 import org.apache.james.mailbox.cassandra.ids.CassandraMessageId;
 import org.apache.james.mailbox.model.MailboxId;
@@ -49,18 +54,62 @@ import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.ThreadId;
 import org.apache.james.util.streams.Limit;
 
+import com.datastax.oss.driver.api.core.CqlIdentifier;
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
 import com.datastax.oss.driver.api.core.cql.Row;
 import com.datastax.oss.driver.api.core.type.codec.TypeCodecs;
 import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
 import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
 
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 public class CassandraEmailQueryView implements EmailQueryView {
     private static final String LIMIT_MARKER = "LIMIT_BIND_MARKER";
+    private static final int COLLAPSE_THREADS_LIMIT_MULTIPLIER = 4;
+
+    private class EmailEntry {
+        private final MessageId messageId;
+        private final ThreadId threadId;
+        private final Instant messageDate;
+
+        EmailEntry(MessageId messageId, ThreadId threadId, Instant messageDate) {
+            this.messageId = messageId;
+            this.threadId = threadId;
+            this.messageDate = messageDate;
+        }
+
+        public MessageId getMessageId() {
+            return messageId;
+        }
+
+        public ThreadId getThreadId() {
+            return threadId;
+        }
+
+        public Instant getMessageDate() {
+            return messageDate;
+        }
+
+        @Override
+        public final boolean equals(Object o) {
+            if (o instanceof EmailEntry) {
+                EmailEntry entry = (EmailEntry) o;
+
+                return Objects.equals(this.messageId, entry.messageId)
+                    && Objects.equals(this.threadId, entry.threadId)
+                    && Objects.equals(this.messageDate, entry.messageDate);
+            }
+            return false;
+        }
+
+        @Override
+        public final int hashCode() {
+            return Objects.hash(messageId, threadId, messageDate);
+        }
+    }
 
     private final CassandraAsyncExecutor executor;
     private final PreparedStatement listMailboxContentBySentAt;
@@ -84,21 +133,21 @@ public class CassandraEmailQueryView implements EmailQueryView {
         this.executor = new CassandraAsyncExecutor(session);
 
         listMailboxContentBySentAt = session.prepare(selectFrom(TABLE_NAME_SENT_AT)
-            .column(MESSAGE_ID)
+            .columns(MESSAGE_ID, SENT_AT, THREAD_ID)
             .whereColumn(MAILBOX_ID).isEqualTo(bindMarker(MAILBOX_ID))
             .orderBy(SENT_AT, DESC)
             .limit(bindMarker(LIMIT_MARKER))
             .build());
 
         listMailboxContentByReceivedAt = session.prepare(selectFrom(TABLE_NAME_RECEIVED_AT)
-            .column(MESSAGE_ID)
+            .columns(MESSAGE_ID, RECEIVED_AT, THREAD_ID)
             .whereColumn(MAILBOX_ID).isEqualTo(bindMarker(MAILBOX_ID))
             .orderBy(RECEIVED_AT, DESC)
             .limit(bindMarker(LIMIT_MARKER))
             .build());
 
         listMailboxContentSinceSentAt = session.prepare(selectFrom(TABLE_NAME_SENT_AT)
-            .column(MESSAGE_ID)
+            .columns(MESSAGE_ID, SENT_AT, THREAD_ID)
             .whereColumn(MAILBOX_ID).isEqualTo(bindMarker(MAILBOX_ID))
             .whereColumn(SENT_AT).isGreaterThanOrEqualTo(bindMarker(SENT_AT))
             .orderBy(SENT_AT, DESC)
@@ -106,17 +155,19 @@ public class CassandraEmailQueryView implements EmailQueryView {
             .build());
 
         listMailboxContentSinceReceivedAt = session.prepare(selectFrom(TABLE_NAME_RECEIVED_AT)
-            .columns(MESSAGE_ID, SENT_AT)
+            .columns(MESSAGE_ID, SENT_AT, THREAD_ID)
             .whereColumn(MAILBOX_ID).isEqualTo(bindMarker(MAILBOX_ID))
             .whereColumn(RECEIVED_AT).isGreaterThanOrEqualTo(bindMarker(RECEIVED_AT))
             .orderBy(RECEIVED_AT, DESC)
+            .limit(bindMarker(LIMIT_MARKER))
             .build());
 
         listMailboxContentBeforeReceivedAt = session.prepare(selectFrom(TABLE_NAME_RECEIVED_AT)
-            .columns(MESSAGE_ID, SENT_AT)
+            .columns(MESSAGE_ID, SENT_AT, THREAD_ID)
             .whereColumn(MAILBOX_ID).isEqualTo(bindMarker(MAILBOX_ID))
             .whereColumn(RECEIVED_AT).isLessThanOrEqualTo(bindMarker(RECEIVED_AT))
             .orderBy(RECEIVED_AT, DESC)
+            .limit(bindMarker(LIMIT_MARKER))
             .build());
 
         insertInLookupTable = session.prepare(insertInto(DATE_LOOKUP_TABLE)
@@ -181,22 +232,71 @@ public class CassandraEmailQueryView implements EmailQueryView {
     public Flux<MessageId> listMailboxContentSortedBySentAt(MailboxId mailboxId, Limit limit, boolean collapseThreads) {
         Preconditions.checkArgument(!limit.isUnlimited(), "Limit should be defined");
 
-        CassandraId cassandraId = (CassandraId) mailboxId;
-        return executor.executeRows(listMailboxContentBySentAt.bind()
-                .set(MAILBOX_ID, cassandraId.asUuid(), TypeCodecs.UUID)
-                .setInt(LIMIT_MARKER, limit.getLimit().get()))
-            .map(row -> CassandraMessageId.Factory.of(row.get(0, TypeCodecs.UUID)));
+        Limit backendFetchLimit = backendLimitFetch(limit, collapseThreads);
+        return listMailboxContentSortedBySentAtWithBackendLimit((CassandraId) mailboxId, limit, collapseThreads, backendFetchLimit);
+    }
+
+    private Flux<MessageId> listMailboxContentSortedBySentAtWithBackendLimit(CassandraId mailboxId, Limit limit, boolean collapseThreads, Limit backendFetchLimit) {
+        Flux<EmailEntry> baseEntries = executor.executeRows(listMailboxContentBySentAt.bind()
+            .set(MAILBOX_ID, mailboxId.asUuid(), TypeCodecs.UUID)
+            .setInt(LIMIT_MARKER, backendFetchLimit.getLimit().get()))
+            .map(asEmailEntry(SENT_AT));
+
+        if (collapseThreads) {
+            return messagesWithCollapseThreads(limit, backendFetchLimit, baseEntries,
+                newLimit -> listMailboxContentSortedBySentAtWithBackendLimit(mailboxId, limit, collapseThreads, newLimit));
+        }
+
+        return baseEntries.map(EmailEntry::getMessageId);
+    }
+
+    private Flux<MessageId> messagesWithCollapseThreads(Limit limit, Limit backendFetchLimit, Flux<EmailEntry> baseEntries, Function<Limit, Flux<MessageId>> listMessagesCallbackFunction) {
+        return baseEntries.collectList()
+            .flatMapMany(results -> {
+                List<EmailEntry> distinctByThreadId = distinctByThreadId(results);
+                boolean hasEnoughResults = distinctByThreadId.size() >= limit.getLimit().get();
+                boolean isExhaustive = results.size() < backendFetchLimit.getLimit().get();
+                if (hasEnoughResults || isExhaustive) {
+                    return Flux.fromIterable(distinctByThreadId)
+                        .take(limit.getLimit().get())
+                        .map(EmailEntry::getMessageId);
+                }
+                Limit newBackendFetchLimit = Limit.from(backendFetchLimit.getLimit().get() * COLLAPSE_THREADS_LIMIT_MULTIPLIER);
+                return listMessagesCallbackFunction.apply(newBackendFetchLimit);
+            });
+    }
+
+    private List<EmailEntry> distinctByThreadId(List<EmailEntry> emailEntries) {
+        ImmutableList.Builder<EmailEntry> list = ImmutableList.builder();
+        HashSet<ThreadId> threadIdHashSet = new HashSet<>();
+        emailEntries.forEach(emailEntry -> {
+            if (threadIdHashSet.add(emailEntry.getThreadId())) {
+                list.add(emailEntry);
+            }
+        });
+        return list.build();
     }
 
     @Override
     public Flux<MessageId> listMailboxContentSortedByReceivedAt(MailboxId mailboxId, Limit limit, boolean collapseThreads) {
         Preconditions.checkArgument(!limit.isUnlimited(), "Limit should be defined");
 
-        CassandraId cassandraId = (CassandraId) mailboxId;
-        return executor.executeRows(listMailboxContentByReceivedAt.bind()
-            .set(MAILBOX_ID, cassandraId.asUuid(), TypeCodecs.UUID)
-            .setInt(LIMIT_MARKER, limit.getLimit().get()))
-            .map(row -> CassandraMessageId.Factory.of(row.get(0, TypeCodecs.UUID)));
+        Limit backendFetchLimit = backendLimitFetch(limit, collapseThreads);
+        return listMailboxContentSortedByReceivedAtWithBackendLimit((CassandraId) mailboxId, limit, collapseThreads, backendFetchLimit);
+    }
+
+    private Flux<MessageId> listMailboxContentSortedByReceivedAtWithBackendLimit(CassandraId mailboxId, Limit limit, boolean collapseThreads, Limit backendFetchLimit) {
+        Flux<EmailEntry> baseEntries = executor.executeRows(listMailboxContentByReceivedAt.bind()
+                .set(MAILBOX_ID, mailboxId.asUuid(), TypeCodecs.UUID)
+                .setInt(LIMIT_MARKER, backendFetchLimit.getLimit().get()))
+            .map(asEmailEntry(RECEIVED_AT));
+
+        if (collapseThreads) {
+            return messagesWithCollapseThreads(limit, backendFetchLimit, baseEntries,
+                newLimit -> listMailboxContentSortedByReceivedAtWithBackendLimit(mailboxId, limit, collapseThreads, newLimit));
+        }
+
+        return baseEntries.map(EmailEntry::getMessageId);
     }
 
     @Override
@@ -205,17 +305,21 @@ public class CassandraEmailQueryView implements EmailQueryView {
 
         CassandraId cassandraId = (CassandraId) mailboxId;
 
-        return executor.executeRows(listMailboxContentSinceReceivedAt.bind()
+        Flux<EmailEntry> baseEntries = executor.executeRows(listMailboxContentSinceReceivedAt.bind()
                 .set(MAILBOX_ID, cassandraId.asUuid(), TypeCodecs.UUID)
                 .setInstant(RECEIVED_AT, since.toInstant()))
-            .map(row -> {
-                CassandraMessageId messageId = CassandraMessageId.Factory.of(row.getUuid(MESSAGE_ID));
-                Instant sentAt = row.getInstant(SENT_AT);
-
-                return Pair.of(messageId, sentAt);
-            })
-            .sort(Comparator.<Pair<CassandraMessageId, Instant>, Instant>comparing(Pair::getValue).reversed())
-            .map(pair -> (MessageId) pair.getKey())
+            .map(asEmailEntry(SENT_AT));
+
+        if (collapseThreads) {
+            return baseEntries.groupBy(EmailEntry::getThreadId)
+                .flatMap(group -> group.reduce((e1, e2) ->
+                    e1.getMessageDate().isAfter(e2.getMessageDate()) ? e1 : e2))
+                .sort(Comparator.comparing(EmailEntry::getMessageDate).reversed())
+                .map(EmailEntry::getMessageId)
+                .take(limit.getLimit().get());
+        }
+        return baseEntries.sort(Comparator.comparing(EmailEntry::getMessageDate).reversed())
+            .map(EmailEntry::getMessageId)
             .take(limit.getLimit().get());
     }
 
@@ -223,39 +327,93 @@ public class CassandraEmailQueryView implements EmailQueryView {
     public Flux<MessageId> listMailboxContentSinceAfterSortedByReceivedAt(MailboxId mailboxId, ZonedDateTime since, Limit limit, boolean collapseThreads) {
         Preconditions.checkArgument(!limit.isUnlimited(), "Limit should be defined");
 
-        CassandraId cassandraId = (CassandraId) mailboxId;
+        Limit backendFetchLimit = backendLimitFetch(limit, collapseThreads);
+        return listMailboxContentSinceAfterSortedByReceivedAtWithBackendLimit((CassandraId) mailboxId, since, limit, collapseThreads, backendFetchLimit);
+    }
 
-        return executor.executeRows(listMailboxContentSinceReceivedAt.bind()
-            .set(MAILBOX_ID, cassandraId.asUuid(), TypeCodecs.UUID)
-            .setInstant(RECEIVED_AT, since.toInstant()))
-            .<MessageId>map(row -> CassandraMessageId.Factory.of(row.get(0, TypeCodecs.UUID)))
-            .take(limit.getLimit().get());
+    private Flux<MessageId> listMailboxContentSinceAfterSortedByReceivedAtWithBackendLimit(CassandraId mailboxId, ZonedDateTime since, Limit limit, boolean collapseThreads, Limit backendFetchLimit) {
+        Flux<EmailEntry> baseEntries = executor.executeRows(listMailboxContentSinceReceivedAt.bind()
+                .set(MAILBOX_ID, mailboxId.asUuid(), TypeCodecs.UUID)
+                .setInstant(RECEIVED_AT, since.toInstant())
+                .setInt(LIMIT_MARKER, backendFetchLimit.getLimit().get()))
+            .map(asEmailEntry(SENT_AT));
+
+        if (collapseThreads) {
+            return messagesWithCollapseThreads(limit, backendFetchLimit, baseEntries,
+                newLimit -> listMailboxContentSinceAfterSortedByReceivedAtWithBackendLimit(mailboxId, since, limit, collapseThreads, newLimit));
+        }
+
+        return baseEntries.map(EmailEntry::getMessageId);
     }
 
     @Override
     public Flux<MessageId> listMailboxContentBeforeSortedByReceivedAt(MailboxId mailboxId, ZonedDateTime since, Limit limit, boolean collapseThreads) {
         Preconditions.checkArgument(!limit.isUnlimited(), "Limit should be defined");
 
-        CassandraId cassandraId = (CassandraId) mailboxId;
+        Limit backendFetchLimit = backendLimitFetch(limit, collapseThreads);
+        return listMailboxContentBeforeSortedByReceivedAtWithBackendLimit((CassandraId) mailboxId, since, limit, collapseThreads, backendFetchLimit);
+    }
 
-        return executor.executeRows(listMailboxContentBeforeReceivedAt.bind()
-            .set(MAILBOX_ID, cassandraId.asUuid(), TypeCodecs.UUID)
-            .setInstant(RECEIVED_AT, since.toInstant()))
-            .<MessageId>map(row -> CassandraMessageId.Factory.of(row.get(0, TypeCodecs.UUID)))
-            .take(limit.getLimit().get());
+    private Flux<MessageId> listMailboxContentBeforeSortedByReceivedAtWithBackendLimit(CassandraId mailboxId, ZonedDateTime since, Limit limit, boolean collapseThreads, Limit backendFetchLimit) {
+        Flux<EmailEntry> baseEntries = executor.executeRows(listMailboxContentBeforeReceivedAt.bind()
+                .set(MAILBOX_ID, mailboxId.asUuid(), TypeCodecs.UUID)
+                .setInstant(RECEIVED_AT, since.toInstant())
+                .setInt(LIMIT_MARKER, backendFetchLimit.getLimit().get()))
+            .map(asEmailEntry(SENT_AT));
+
+        if (collapseThreads) {
+            return messagesWithCollapseThreads(limit, backendFetchLimit, baseEntries,
+                newLimit -> listMailboxContentBeforeSortedByReceivedAtWithBackendLimit(mailboxId, since, limit, collapseThreads, newLimit));
+        }
+
+        return baseEntries.map(EmailEntry::getMessageId);
     }
 
     @Override
     public Flux<MessageId> listMailboxContentSinceSentAt(MailboxId mailboxId, ZonedDateTime since, Limit limit, boolean collapseThreads) {
         Preconditions.checkArgument(!limit.isUnlimited(), "Limit should be defined");
 
-        CassandraId cassandraId = (CassandraId) mailboxId;
+        Limit backendFetchLimit = backendLimitFetch(limit, collapseThreads);
+        return listMailboxContentSinceSentAtWithBackendLimit((CassandraId) mailboxId, since, limit, collapseThreads, backendFetchLimit);
+    }
 
-        return executor.executeRows(listMailboxContentSinceSentAt.bind()
-            .set(MAILBOX_ID, cassandraId.asUuid(), TypeCodecs.UUID)
-            .setInt(LIMIT_MARKER, limit.getLimit().get())
-            .setInstant(SENT_AT, since.toInstant()))
-            .map(row -> CassandraMessageId.Factory.of(row.get(0, TypeCodecs.UUID)));
+    private Flux<MessageId> listMailboxContentSinceSentAtWithBackendLimit(CassandraId mailboxId, ZonedDateTime since, Limit limit, boolean collapseThreads, Limit backendFetchLimit) {
+        Flux<EmailEntry> baseEntries = executor.executeRows(listMailboxContentSinceSentAt.bind()
+                .set(MAILBOX_ID, mailboxId.asUuid(), TypeCodecs.UUID)
+                .setInstant(SENT_AT, since.toInstant())
+                .setInt(LIMIT_MARKER, backendFetchLimit.getLimit().get()))
+            .map(asEmailEntry(SENT_AT));
+
+        if (collapseThreads) {
+            return messagesWithCollapseThreads(limit, backendFetchLimit, baseEntries,
+                newLimit -> listMailboxContentSinceSentAtWithBackendLimit(mailboxId, since, limit, collapseThreads, newLimit));
+        }
+
+        return baseEntries.map(EmailEntry::getMessageId);
+    }
+
+    private Limit backendLimitFetch(Limit limit, boolean collapseThreads) {
+        if (collapseThreads) {
+            return Limit.limit(limit.getLimit().get() * COLLAPSE_THREADS_LIMIT_MULTIPLIER);
+        }
+        return limit;
+    }
+
+    private Function<Row, EmailEntry> asEmailEntry(CqlIdentifier dateField) {
+        return (Row row) -> {
+            CassandraMessageId messageId = CassandraMessageId.Factory.of(row.getUuid(MESSAGE_ID));
+            ThreadId threadId = getThreadIdFromRow(row, messageId);
+            Instant messageDate = row.getInstant(dateField);
+            return new EmailEntry(messageId, threadId, messageDate);
+        };
+    }
+
+    private ThreadId getThreadIdFromRow(Row row, MessageId messageId) {
+        UUID threadIdUUID = row.get(CassandraEmailQueryViewTable.THREAD_ID, TypeCodecs.TIMEUUID);
+        if (threadIdUUID == null) {
+            return ThreadId.fromBaseMessageId(messageId);
+        }
+        return ThreadId.fromBaseMessageId(CassandraMessageId.Factory.of(threadIdUUID));
     }
 
     @Override
diff --git a/server/data/data-jmap-cassandra/src/test/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryViewTest.java b/server/data/data-jmap-cassandra/src/test/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryViewTest.java
index 33f0eabada..7d263fe27a 100644
--- a/server/data/data-jmap-cassandra/src/test/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryViewTest.java
+++ b/server/data/data-jmap-cassandra/src/test/java/org/apache/james/jmap/cassandra/projections/CassandraEmailQueryViewTest.java
@@ -81,7 +81,17 @@ public class CassandraEmailQueryViewTest implements EmailQueryViewContract {
     }
 
     @Override
-    public ThreadId threadId() {
+    public ThreadId threadId1() {
         return THREAD_ID;
     }
+
+    @Override
+    public ThreadId threadId2() {
+        return ThreadId.fromBaseMessageId(MESSAGE_ID_FACTORY.generate());
+    }
+
+    @Override
+    public ThreadId threadId3() {
+        return ThreadId.fromBaseMessageId(MESSAGE_ID_FACTORY.generate());
+    }
 }
diff --git a/server/data/data-jmap-postgres/src/test/java/org/apache/james/jmap/postgres/projections/PostgresEmailQueryViewTest.java b/server/data/data-jmap-postgres/src/test/java/org/apache/james/jmap/postgres/projections/PostgresEmailQueryViewTest.java
index 29c366d2ca..147974e052 100644
--- a/server/data/data-jmap-postgres/src/test/java/org/apache/james/jmap/postgres/projections/PostgresEmailQueryViewTest.java
+++ b/server/data/data-jmap-postgres/src/test/java/org/apache/james/jmap/postgres/projections/PostgresEmailQueryViewTest.java
@@ -72,7 +72,17 @@ public class PostgresEmailQueryViewTest implements EmailQueryViewContract {
     }
 
     @Override
-    public ThreadId threadId() {
+    public ThreadId threadId1() {
         return THREAD_ID;
     }
+
+    @Override
+    public ThreadId threadId2() {
+        return ThreadId.fromBaseMessageId(MESSAGE_ID_FACTORY.generate());
+    }
+
+    @Override
+    public ThreadId threadId3() {
+        return ThreadId.fromBaseMessageId(MESSAGE_ID_FACTORY.generate());
+    }
 }
diff --git a/server/data/data-jmap/src/main/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryView.java b/server/data/data-jmap/src/main/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryView.java
index 9097f3c8a2..71d3cb6e1c 100644
--- a/server/data/data-jmap/src/main/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryView.java
+++ b/server/data/data-jmap/src/main/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryView.java
@@ -21,6 +21,7 @@ package org.apache.james.jmap.memory.projections;
 
 import java.time.ZonedDateTime;
 import java.util.Comparator;
+import java.util.function.Function;
 
 import jakarta.inject.Inject;
 
@@ -52,7 +53,7 @@ public class MemoryEmailQueryView implements EmailQueryView {
 
         Flux<Entry> baseEntries = Flux.fromIterable(entries.row(mailboxId).values());
 
-        return maybeCollapseThreads(baseEntries, collapseThreads)
+        return maybeCollapseThreads(Entry::getSentAt, collapseThreads).apply(baseEntries)
             .sort(Comparator.comparing(Entry::getSentAt).reversed())
             .map(Entry::getMessageId)
             .take(limit.getLimit().get());
@@ -65,7 +66,7 @@ public class MemoryEmailQueryView implements EmailQueryView {
         Flux<Entry> baseEntries = Flux.fromIterable(entries.row(mailboxId).values())
             .filter(e -> e.getSentAt().isAfter(since) || e.getSentAt().isEqual(since));
 
-        return maybeCollapseThreads(baseEntries, collapseThreads)
+        return maybeCollapseThreads(Entry::getSentAt, collapseThreads).apply(baseEntries)
             .sort(Comparator.comparing(Entry::getSentAt).reversed())
             .map(Entry::getMessageId)
             .take(limit.getLimit().get());
@@ -78,7 +79,7 @@ public class MemoryEmailQueryView implements EmailQueryView {
         Flux<Entry> baseEntries = Flux.fromIterable(entries.row(mailboxId).values())
             .filter(e -> e.getReceivedAt().isAfter(since) || e.getReceivedAt().isEqual(since));
 
-        return maybeCollapseThreads(baseEntries, collapseThreads)
+        return maybeCollapseThreads(Entry::getSentAt, collapseThreads).apply(baseEntries)
             .sort(Comparator.comparing(Entry::getSentAt).reversed())
             .map(Entry::getMessageId)
             .take(limit.getLimit().get());
@@ -88,7 +89,7 @@ public class MemoryEmailQueryView implements EmailQueryView {
     public Flux<MessageId> listMailboxContentSortedByReceivedAt(MailboxId mailboxId, Limit limit, boolean collapseThreads) {
         Flux<Entry> baseEntries = Flux.fromIterable(entries.row(mailboxId).values());
 
-        return maybeCollapseThreads(baseEntries, collapseThreads)
+        return maybeCollapseThreads(Entry::getReceivedAt, collapseThreads).apply(baseEntries)
             .sort(Comparator.comparing(Entry::getReceivedAt).reversed())
             .map(Entry::getMessageId)
             .take(limit.getLimit().get());
@@ -99,7 +100,7 @@ public class MemoryEmailQueryView implements EmailQueryView {
         Flux<Entry> baseEntries = Flux.fromIterable(entries.row(mailboxId).values())
             .filter(e -> e.getReceivedAt().isAfter(since) || e.getReceivedAt().isEqual(since));
 
-        return maybeCollapseThreads(baseEntries, collapseThreads)
+        return maybeCollapseThreads(Entry::getReceivedAt, collapseThreads).apply(baseEntries)
             .sort(Comparator.comparing(Entry::getReceivedAt).reversed())
             .map(Entry::getMessageId)
             .take(limit.getLimit().get());
@@ -110,19 +111,21 @@ public class MemoryEmailQueryView implements EmailQueryView {
         Flux<Entry> baseEntries = Flux.fromIterable(entries.row(mailboxId).values())
             .filter(e -> e.getReceivedAt().isBefore(before) || e.getReceivedAt().isEqual(before));
 
-        return maybeCollapseThreads(baseEntries, collapseThreads)
+        return maybeCollapseThreads(Entry::getReceivedAt, collapseThreads).apply(baseEntries)
             .sort(Comparator.comparing(Entry::getReceivedAt).reversed())
             .map(Entry::getMessageId)
             .take(limit.getLimit().get());
     }
 
-    private Flux<Entry> maybeCollapseThreads(Flux<Entry> entries, boolean collapseThreads) {
-        if (collapseThreads) {
-            return entries.groupBy(Entry::getThreadId)
-                .flatMap(group -> group.reduce((e1, e2) ->
-                    e1.getReceivedAt().isAfter(e2.getReceivedAt()) ? e1 : e2));
-        }
-        return entries;
+    private Function<Flux<Entry>, Flux<Entry>> maybeCollapseThreads(Function<Entry, ZonedDateTime> dateExtractor, boolean collapseThreads) {
+        return entries -> {
+            if (collapseThreads) {
+                return entries.groupBy(Entry::getThreadId)
+                    .flatMap(group -> group.reduce((e1, e2) ->
+                        dateExtractor.apply(e1).isAfter(dateExtractor.apply(e2)) ? e1 : e2));
+            }
+            return entries;
+        };
     }
 
     @Override
diff --git a/server/data/data-jmap/src/test/java/org/apache/james/jmap/api/projections/EmailQueryViewContract.java b/server/data/data-jmap/src/test/java/org/apache/james/jmap/api/projections/EmailQueryViewContract.java
index ea2b3e7e88..e24e534d95 100644
--- a/server/data/data-jmap/src/test/java/org/apache/james/jmap/api/projections/EmailQueryViewContract.java
+++ b/server/data/data-jmap/src/test/java/org/apache/james/jmap/api/projections/EmailQueryViewContract.java
@@ -32,7 +32,7 @@ import org.apache.james.util.streams.Limit;
 import org.junit.jupiter.api.Test;
 
 public interface EmailQueryViewContract {
-    boolean NO_COLLAPSE_THREAD = false;
+    boolean COLLAPSE_THREAD = true;
     ZonedDateTime DATE_1 = ZonedDateTime.parse("2010-10-30T15:12:00Z");
     ZonedDateTime DATE_2 = ZonedDateTime.parse("2010-10-30T16:12:00Z");
     ZonedDateTime DATE_3 = ZonedDateTime.parse("2010-10-30T17:12:00Z");
@@ -53,211 +53,215 @@ public interface EmailQueryViewContract {
 
     MessageId messageId4();
 
-    ThreadId threadId();
+    ThreadId threadId1();
+    
+    ThreadId threadId2();
+    
+    ThreadId threadId3();
 
     @Test
     default void listMailboxContentShouldReturnEmptyByDefault() {
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .isEmpty();
     }
 
     @Test
     default void listMailboxContentShouldBeOrderedBySentAt() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId2(), messageId3(), messageId1());
     }
 
     @Test
     default void listMailboxContentShouldApplyLimit() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(2), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(2), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId2(), messageId3());
     }
 
     @Test
     default void listMailboxContentSinceReceivedAtShouldExcludeTooOldItems() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3(), messageId2());
     }
 
     @Test
     default void listMailboxContentSinceReceivedAtShouldReturnEmptyWhenNoneMatch() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_7, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_7, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .isEmpty();
     }
 
     @Test
     default void listMailboxContentSinceReceivedAtAtShouldApplyLimit() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_1, Limit.limit(2), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_1, Limit.limit(2), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3(), messageId2());
     }
 
     @Test
     default void listMailboxContentSinceSentdAtShouldExcludeTooOldItems() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_2, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_2, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3(), messageId2());
     }
 
     @Test
     default void listMailboxContentSinceSentAtAtShouldApplyLimit() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_1, Limit.limit(2), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_1, Limit.limit(2), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3(), messageId2());
     }
 
     @Test
     default void listMailboxContentSinceSentAtShouldReturnEmptyWhenNoneMatch() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_7, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_7, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .isEmpty();
     }
 
     @Test
     default void listMailboxContentShouldNotReturnClearedContent() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId1()).block();
 
         testee().delete(mailboxId1()).block();
 
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .isEmpty();
     }
 
     @Test
     default void listMailboxContentShouldNotReturnDeletedContent() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId1()).block();
 
         testee().delete(mailboxId1(), messageId2()).block();
 
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3(), messageId1());
     }
 
     @Test
     default void listMailboxContentSinceReceivedAtShouldNotReturnClearedContent() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
         testee().delete(mailboxId1()).block();
 
-        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_4, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_4, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .isEmpty();
     }
 
     @Test
     default void listMailboxContentSinceSentAtShouldNotReturnClearedContent() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
         testee().delete(mailboxId1()).block();
 
-        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_4, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_4, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .isEmpty();
     }
 
     @Test
     default void saveShouldBeIdempotent() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId1());
     }
 
     @Test
     default void datesCanBeDuplicated() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId2(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId2(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactlyInAnyOrder(messageId1(), messageId2());
     }
 
     @Test
     default void listMailboxContentSinceReceivedAtShouldNotReturnDeletedContent() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
         testee().delete(mailboxId1(), messageId2()).block();
 
-        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3());
     }
 
     @Test
     default void listMailboxContentSinceSentAtShouldNotReturnDeletedContent() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
         testee().delete(mailboxId1(), messageId2()).block();
 
-        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_3, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_3, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3());
     }
 
     @Test
     default void listMailboxContentSortedByReceivedAtShouldBeSortedByReceivedAt() {
-        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSortedByReceivedAt(mailboxId1(), Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSortedByReceivedAt(mailboxId1(), Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3(), messageId1(), messageId2());
     }
 
     @Test
     default void listMailboxContentSinceSortedByReceivedAtShouldBeSortedByReceivedAt() {
-        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentSinceAfterSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentSinceAfterSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId3(), messageId1());
     }
 
     @Test
     default void listMailboxContentBeforeSortedByReceivedAtShouldBeSortedByReceivedAt() {
-        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
+        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
 
-        assertThat(testee().listMailboxContentBeforeSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), NO_COLLAPSE_THREAD).collectList().block())
+        assertThat(testee().listMailboxContentBeforeSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), !COLLAPSE_THREAD).collectList().block())
             .containsExactly(messageId1(), messageId2());
     }
 
@@ -273,19 +277,146 @@ public interface EmailQueryViewContract {
 
     @Test
     default void listMailboxContentShouldThrowOnUndefinedLimit() {
-        assertThatThrownBy(() -> testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.unlimited(), NO_COLLAPSE_THREAD).blockLast())
+        assertThatThrownBy(() -> testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.unlimited(), !COLLAPSE_THREAD).blockLast())
             .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     default void listMailboxContentSinceSentAtShouldThrowOnUndefinedLimit() {
-        assertThatThrownBy(() -> testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_3, Limit.unlimited(), NO_COLLAPSE_THREAD).blockLast())
+        assertThatThrownBy(() -> testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_3, Limit.unlimited(), !COLLAPSE_THREAD).blockLast())
             .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     default void listMailboxContentSinceReceivedAtShouldThrowOnUndefinedLimit() {
-        assertThatThrownBy(() -> testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.unlimited(), NO_COLLAPSE_THREAD).blockLast())
+        assertThatThrownBy(() -> testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.unlimited(), !COLLAPSE_THREAD).blockLast())
             .isInstanceOf(IllegalArgumentException.class);
     }
+
+
+    @Test
+    default void listMailboxContentSortedBySentAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId2());
+    }
+
+    @Test
+    default void listMailboxContentSortedBySentAtShouldApplyLimitWithCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId2()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId3()).block();
+        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(2), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId4(), messageId3());
+    }
+
+    @Test
+    default void listMailboxContentSinceReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3());
+    }
+
+    @Test
+    default void listMailboxContentSinceReceivedAtShouldApplyLimitWithCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId2()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId3()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_1, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3(), messageId2());
+    }
+
+    @Test
+    default void listMailboxContentSinceSentdAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_2, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3());
+    }
+
+    @Test
+    default void listMailboxContentSinceSentAtShouldApplyLimitWithCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId2()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId3()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_1, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3(), messageId2());
+    }
+
+    @Test
+    default void listMailboxContentSortedByReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSortedByReceivedAt(mailboxId1(), Limit.limit(12), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3());
+    }
+
+    @Test
+    default void listMailboxContentSortedByReceivedAtShouldApplyLimitWithCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId2()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId3()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSortedByReceivedAt(mailboxId1(), Limit.limit(2), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3(), messageId2());
+    }
+
+    @Test
+    default void listMailboxContentSinceSortedByReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSinceAfterSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3());
+    }
+
+    @Test
+    default void listMailboxContentSinceSortedByReceivedAtShouldApplyLimitWithCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId2()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId3()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentSinceAfterSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId3(), messageId2());
+    }
+
+    @Test
+    default void listMailboxContentBeforeSortedByReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentBeforeSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId1());
+    }
+
+    @Test
+    default void listMailboxContentBeforeSortedByReceivedAtShouldApplyLimitWithCollapseThreads() {
+        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId2()).block();
+        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId1()).block();
+        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId3()).block();
+        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId1()).block();
+
+        assertThat(testee().listMailboxContentBeforeSortedByReceivedAt(mailboxId1(), DATE_5, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
+            .containsExactly(messageId4(), messageId1());
+    }
 }
diff --git a/server/data/data-jmap/src/test/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryViewTest.java b/server/data/data-jmap/src/test/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryViewTest.java
index dfd48ce7ab..cbbdbaa453 100644
--- a/server/data/data-jmap/src/test/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryViewTest.java
+++ b/server/data/data-jmap/src/test/java/org/apache/james/jmap/memory/projections/MemoryEmailQueryViewTest.java
@@ -19,8 +19,6 @@
 
 package org.apache.james.jmap.memory.projections;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import org.apache.james.jmap.api.projections.EmailQueryView;
 import org.apache.james.jmap.api.projections.EmailQueryViewContract;
 import org.apache.james.mailbox.model.MailboxId;
@@ -28,12 +26,9 @@ import org.apache.james.mailbox.model.MessageId;
 import org.apache.james.mailbox.model.TestId;
 import org.apache.james.mailbox.model.TestMessageId;
 import org.apache.james.mailbox.model.ThreadId;
-import org.apache.james.util.streams.Limit;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
 
 public class MemoryEmailQueryViewTest implements EmailQueryViewContract {
-    private static final boolean COLLAPSE_THREAD = true;
 
     private MemoryEmailQueryView testee;
 
@@ -73,133 +68,17 @@ public class MemoryEmailQueryViewTest implements EmailQueryViewContract {
     }
 
     @Override
-    public ThreadId threadId() {
+    public ThreadId threadId1() {
         return ThreadId.fromBaseMessageId(TestMessageId.of(1));
     }
 
-    @Test
-    public void listMailboxContentSortedBySentAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(12), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3());
-    }
-
-    @Test
-    public void listMailboxContentSortedBySentAtShouldApplyLimitWithCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), ThreadId.fromBaseMessageId(TestMessageId.of(2))).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_6, messageId3(), ThreadId.fromBaseMessageId(TestMessageId.of(3))).block();
-        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSortedBySentAt(mailboxId1(), Limit.limit(2), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId4(), messageId3());
-    }
-
-    @Test
-    public void listMailboxContentSinceReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_3, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3());
-    }
-
-    @Test
-    public void listMailboxContentSinceReceivedAtShouldApplyLimitWithCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), ThreadId.fromBaseMessageId(TestMessageId.of(2))).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), ThreadId.fromBaseMessageId(TestMessageId.of(3))).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSinceAfterSortedBySentAt(mailboxId1(), DATE_1, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3(), messageId2());
-    }
-
-    @Test
-    public void listMailboxContentSinceSentdAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_2, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3());
-    }
-
-    @Test
-    public void listMailboxContentSinceSentAtShouldApplyLimitWithCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), ThreadId.fromBaseMessageId(TestMessageId.of(2))).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), ThreadId.fromBaseMessageId(TestMessageId.of(3))).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSinceSentAt(mailboxId1(), DATE_1, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3(), messageId2());
-    }
-
-    @Test
-    public void listMailboxContentSortedByReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSortedByReceivedAt(mailboxId1(), Limit.limit(12), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3());
-    }
-
-    @Test
-    public void listMailboxContentSortedByReceivedAtShouldApplyLimitWithCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), ThreadId.fromBaseMessageId(TestMessageId.of(2))).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), ThreadId.fromBaseMessageId(TestMessageId.of(3))).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSortedByReceivedAt(mailboxId1(), Limit.limit(2), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3(), messageId2());
-    }
-
-    @Test
-    public void listMailboxContentSinceSortedByReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSinceAfterSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3());
-    }
-
-    @Test
-    public void listMailboxContentSinceSortedByReceivedAtShouldApplyLimitWithCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), ThreadId.fromBaseMessageId(TestMessageId.of(2))).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), ThreadId.fromBaseMessageId(TestMessageId.of(3))).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId()).block();
-
-        assertThat(testee().listMailboxContentSinceAfterSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId3(), messageId2());
-    }
-
-    @Test
-    public void listMailboxContentBeforeSortedByReceivedAtShouldReturnLatestMessageOfThreadWhenCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_4, messageId1(), threadId()).block();
-        testee().save(mailboxId1(), DATE_2, DATE_3, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), threadId()).block();
-
-        assertThat(testee().listMailboxContentBeforeSortedByReceivedAt(mailboxId1(), DATE_4, Limit.limit(12), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId1());
+    @Override
+    public ThreadId threadId2() {
+        return ThreadId.fromBaseMessageId(TestMessageId.of(2));
     }
 
-    @Test
-    public void listMailboxContentBeforeSortedByReceivedAtShouldApplyLimitWithCollapseThreads() {
-        testee().save(mailboxId1(), DATE_1, DATE_2, messageId1(), ThreadId.fromBaseMessageId(TestMessageId.of(2))).block();
-        testee().save(mailboxId1(), DATE_3, DATE_4, messageId2(), threadId()).block();
-        testee().save(mailboxId1(), DATE_5, DATE_6, messageId3(), ThreadId.fromBaseMessageId(TestMessageId.of(3))).block();
-        testee().save(mailboxId1(), DATE_4, DATE_5, messageId4(), threadId()).block();
-
-        assertThat(testee().listMailboxContentBeforeSortedByReceivedAt(mailboxId1(), DATE_5, Limit.limit(2), COLLAPSE_THREAD).collectList().block())
-            .containsExactly(messageId4(), messageId1());
+    @Override
+    public ThreadId threadId3() {
+        return ThreadId.fromBaseMessageId(TestMessageId.of(3));
     }
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org