Fix initial sync fail when event fetching unsuccessful (#2150)

src/models/room.ts

@@ -1372,14 +1372,25 @@ export class Room extends EventEmitter {
             let rootEvent = this.findEventById(event.threadRootId);
             // If the rootEvent does not exist in the current sync, then look for
             // it over the network
-            const eventData = await this.client.fetchRoomEvent(this.roomId, event.threadRootId);
+            try {
+                let eventData;
+                if (event.threadRootId) {
+                    eventData = await this.client.fetchRoomEvent(this.roomId, event.threadRootId);
+                }
+
                 if (!rootEvent) {
                     rootEvent = new MatrixEvent(eventData);
                 } else {
                     rootEvent.setUnsigned(eventData.unsigned);
                 }
+            } finally {
+                // The root event might be not be visible to the person requesting
+                // it. If it wasn't fetched successfully the thread will work
+                // in "limited" mode and won't benefit from all the APIs a homeserver
+                // can provide to enhance the thread experience
                 thread = this.createThread(rootEvent, events);
             }
+        }
 
         if (event.getUnsigned().transaction_id) {
             const existingEvent = this.txnToEvent[event.getUnsigned().transaction_id];
@@ -1393,12 +1404,15 @@ export class Room extends EventEmitter {
         this.emit(ThreadEvent.Update, thread);
     }
 
-    public createThread(rootEvent: MatrixEvent, events?: MatrixEvent[]): Thread {
+    public createThread(rootEvent: MatrixEvent, events?: MatrixEvent[]): Thread | undefined {
         const thread = new Thread(rootEvent, {
             initialEvents: events,
             room: this,
             client: this.client,
         });
+        // If we managed to create a thread and figure out its `id`
+        // then we can use it
+        if (thread.id) {
             this.threads.set(thread.id, thread);
             this.reEmitter.reEmit(thread, [
                 ThreadEvent.Update,
@@ -1414,6 +1428,7 @@ export class Room extends EventEmitter {
             this.emit(ThreadEvent.New, thread);
             return thread;
         }
+    }
 
     /**
      * Add an event to the end of this room's live timelines. Will fire

src/models/thread.ts

@@ -60,8 +60,10 @@ export class Thread extends TypedEventEmitter<ThreadEvent> {
 
     public initialEventsFetched = false;
 
+    public readonly id: string;
+
     constructor(
-        public readonly rootEvent: MatrixEvent,
+        public readonly rootEvent: MatrixEvent | undefined,
         opts: IThreadOpts,
     ) {
         super();
@@ -82,6 +84,15 @@ export class Thread extends TypedEventEmitter<ThreadEvent> {
             "Room.timelineReset",
         ]);
 
+        // If we weren't able to find the root event, it's probably missing
+        // and we define the thread ID from one of the thread relation
+        if (!rootEvent) {
+            this.id = opts?.initialEvents
+                ?.find(event => event.isThreadRelation)?.relationEventId;
+        } else {
+            this.id = rootEvent.getId();
+        }
+
         opts?.initialEvents?.forEach(event => this.addEvent(event));
 
         this.room.on("Room.localEchoUpdated", this.onEcho);
@@ -177,9 +188,9 @@ export class Thread extends TypedEventEmitter<ThreadEvent> {
         this.emit(ThreadEvent.Update, this);
     }
 
-    private initialiseThread(rootEvent: MatrixEvent): void {
+    private initialiseThread(rootEvent: MatrixEvent | undefined): void {
         const bundledRelationship = rootEvent
-            .getServerAggregatedRelation<IThreadBundledRelationship>(RelationType.Thread);
+            ?.getServerAggregatedRelation<IThreadBundledRelationship>(RelationType.Thread);
 
         if (this.hasServerSideSupport && bundledRelationship) {
             this.replyCount = bundledRelationship.count;
@@ -190,7 +201,7 @@ export class Thread extends TypedEventEmitter<ThreadEvent> {
             this.lastEvent = event;
         }
 
-        if (!bundledRelationship) {
+        if (!bundledRelationship && rootEvent) {
             this.addEvent(rootEvent);
         }
     }
@@ -229,15 +240,8 @@ export class Thread extends TypedEventEmitter<ThreadEvent> {
         }
     }
 
-    /**
-     * The thread ID, which is the same as the root event ID
-     */
-    public get id(): string {
-        return this.rootEvent.getId();
-    }
-
     public get roomId(): string {
-        return this.rootEvent.getRoomId();
+        return this.room.roomId;
     }
 
     /**