Apply edits discovered from sync after thread is initialised (#3002)

spec/unit/event-timeline-set.spec.ts

@@ -24,10 +24,13 @@ import {
     MatrixClient,
     MatrixEvent,
     MatrixEventEvent,
+    RelationType,
     Room,
+    RoomEvent,
 } from "../../src";
-import { Thread } from "../../src/models/thread";
+import { FeatureSupport, Thread } from "../../src/models/thread";
 import { ReEmitter } from "../../src/ReEmitter";
+import { eventMapperFor } from "../../src/event-mapper";
 
 describe("EventTimelineSet", () => {
     const roomId = "!foo:bar";
@@ -202,6 +205,88 @@ describe("EventTimelineSet", () => {
             expect(liveTimeline.getEvents().length).toStrictEqual(0);
         });
 
+        it("should allow edits to be added to thread timeline", async () => {
+            jest.spyOn(client, "supportsExperimentalThreads").mockReturnValue(true);
+            jest.spyOn(client, "getEventMapper").mockReturnValue(eventMapperFor(client, {}));
+            Thread.hasServerSideSupport = FeatureSupport.Stable;
+
+            const sender = "@alice:matrix.org";
+
+            const root = utils.mkEvent({
+                event: true,
+                content: {
+                    body: "Thread root",
+                },
+                type: EventType.RoomMessage,
+                sender,
+            });
+            room.addLiveEvents([root]);
+
+            const threadReply = utils.mkEvent({
+                event: true,
+                content: {
+                    "body": "Thread reply",
+                    "m.relates_to": {
+                        event_id: root.getId()!,
+                        rel_type: RelationType.Thread,
+                    },
+                },
+                type: EventType.RoomMessage,
+                sender,
+            });
+
+            root.setUnsigned({
+                "m.relations": {
+                    [RelationType.Thread]: {
+                        count: 1,
+                        latest_event: {
+                            content: threadReply.getContent(),
+                            origin_server_ts: 5,
+                            room_id: room.roomId,
+                            sender,
+                            type: EventType.RoomMessage,
+                            event_id: threadReply.getId()!,
+                            user_id: sender,
+                            age: 1,
+                        },
+                        current_user_participated: true,
+                    },
+                },
+            });
+
+            const editToThreadReply = utils.mkEvent({
+                event: true,
+                content: {
+                    "body": " * edit",
+                    "m.new_content": {
+                        "body": "edit",
+                        "msgtype": "m.text",
+                        "org.matrix.msc1767.text": "edit",
+                    },
+                    "m.relates_to": {
+                        event_id: threadReply.getId()!,
+                        rel_type: RelationType.Replace,
+                    },
+                },
+                type: EventType.RoomMessage,
+                sender,
+            });
+
+            jest.spyOn(client, "paginateEventTimeline").mockImplementation(async () => {
+                thread.timelineSet.getLiveTimeline().addEvent(threadReply, { toStartOfTimeline: true });
+                return true;
+            });
+            jest.spyOn(client, "relations").mockResolvedValue({
+                events: [],
+            });
+
+            const thread = room.createThread(root.getId()!, root, [threadReply, editToThreadReply], false);
+            thread.once(RoomEvent.TimelineReset, () => {
+                const lastEvent = thread.timeline.at(-1)!;
+                expect(lastEvent.getContent().body).toBe(" * edit");
+            });
+        });
+
         describe("non-room timeline", () => {
             it("Adds event to timeline", () => {
                 const nonRoomEventTimelineSet = new EventTimelineSet(

src/models/thread.ts

@@ -97,6 +97,11 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
     private readonly pendingEventOrdering: PendingEventOrdering;
 
     public initialEventsFetched = !Thread.hasServerSideSupport;
+    /**
+     * An array of events to add to the timeline once the thread has been initialised
+     * with server suppport.
+     */
+    public replayEvents: MatrixEvent[] | null = [];
 
     public constructor(public readonly id: string, public rootEvent: MatrixEvent | undefined, opts: IThreadOpts) {
         super();
@@ -266,6 +271,20 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             this.addEventToTimeline(event, false);
             this.fetchEditsWhereNeeded(event);
         } else if (event.isRelation(RelationType.Annotation) || event.isRelation(RelationType.Replace)) {
+            if (!this.initialEventsFetched) {
+                /**
+                 * A thread can be fully discovered via a single sync response
+                 * And when that's the case we still ask the server to do an initialisation
+                 * as it's the safest to ensure we have everything.
+                 * However when we are in that scenario we might loose annotation or edits
+                 *
+                 * This fix keeps a reference to those events and replay them once the thread
+                 * has been initialised properly.
+                 */
+                this.replayEvents?.push(event);
+            } else {
+                this.addEventToTimeline(event, toStartOfTimeline);
+            }
             // Apply annotations and replace relations to the relations of the timeline only
             this.timelineSet.relations?.aggregateParentEvent(event);
             this.timelineSet.relations?.aggregateChildEvent(event, this.timelineSet);
@@ -375,6 +394,10 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
                         limit: Math.max(1, this.length),
                     });
                 }
+                for (const event of this.replayEvents!) {
+                    this.addEvent(event, false);
+                }
+                this.replayEvents = null;
                 // just to make sure that, if we've created a timeline window for this thread before the thread itself
                 // existed (e.g. when creating a new thread), we'll make sure the panel is force refreshed correctly.
                 this.emit(RoomEvent.TimelineReset, this.room, this.timelineSet, true);