@unwanted/matrix-sdk-mini 34.12.0-8 → 34.12.0-9

package/src/sync-accumulator.ts

@@ -77,7 +77,9 @@ export interface ITimeline {
 
 export interface IJoinedRoom {
     "summary": IRoomSummary;
-    "state": IState;
+    // One of `state` or `state_after` is required.
+    "state"?: IState;
+    "org.matrix.msc4222.state_after"?: IState; // https://github.com/matrix-org/matrix-spec-proposals/pull/4222
     "timeline": ITimeline;
     "ephemeral": IEphemeral;
     "account_data": IAccountData;
@@ -106,9 +108,11 @@ export interface IInvitedRoom {
 }
 
 export interface ILeftRoom {
-    state: IState;
-    timeline: ITimeline;
-    account_data: IAccountData;
+    // One of `state` or `state_after` is required.
+    "state"?: IState;
+    "org.matrix.msc4222.state_after"?: IState;
+    "timeline": ITimeline;
+    "account_data": IAccountData;
 }
 
 export interface IKnockedRoom {
@@ -481,13 +485,18 @@ export class SyncAccumulator {
         // Work out the current state. The deltas need to be applied in the order:
         // - existing state which didn't come down /sync.
         // - State events under the 'state' key.
-        // - State events in the 'timeline'.
+        // - State events under the 'state_after' key OR state events in the 'timeline' if 'state_after' is not present.
         data.state?.events?.forEach((e) => {
             setState(currentData._currentState, e);
         });
-        data.timeline?.events?.forEach((e, index) => {
-            // this nops if 'e' isn't a state event
+        data["org.matrix.msc4222.state_after"]?.events?.forEach((e) => {
             setState(currentData._currentState, e);
+        });
+        data.timeline?.events?.forEach((e, index) => {
+            if (!data["org.matrix.msc4222.state_after"]) {
+                // this nops if 'e' isn't a state event
+                setState(currentData._currentState, e);
+            }
             // append the event to the timeline. The back-pagination token
             // corresponds to the first event in the timeline
             let transformedEvent: TaggedEvent;
@@ -563,17 +572,22 @@ export class SyncAccumulator {
         });
         Object.keys(this.joinRooms).forEach((roomId) => {
             const roomData = this.joinRooms[roomId];
-            const roomJson: IJoinedRoom = {
-                ephemeral: { events: [] },
-                account_data: { events: [] },
-                state: { events: [] },
-                timeline: {
+            const roomJson: IJoinedRoom & {
+                // We track both `state` and `state_after` for downgrade compatibility
+                "state": IState;
+                "org.matrix.msc4222.state_after": IState;
+            } = {
+                "ephemeral": { events: [] },
+                "account_data": { events: [] },
+                "state": { events: [] },
+                "org.matrix.msc4222.state_after": { events: [] },
+                "timeline": {
                     events: [],
                     prev_batch: null,
                 },
-                unread_notifications: roomData._unreadNotifications,
-                unread_thread_notifications: roomData._unreadThreadNotifications,
-                summary: roomData._summary as IRoomSummary,
+                "unread_notifications": roomData._unreadNotifications,
+                "unread_thread_notifications": roomData._unreadThreadNotifications,
+                "summary": roomData._summary as IRoomSummary,
             };
             // Add account data
             Object.keys(roomData._accountData).forEach((evType) => {
@@ -650,8 +664,11 @@ export class SyncAccumulator {
             Object.keys(roomData._currentState).forEach((evType) => {
                 Object.keys(roomData._currentState[evType]).forEach((stateKey) => {
                     let ev = roomData._currentState[evType][stateKey];
+                    // Push to both fields to provide downgrade compatibility in the sync accumulator db
+                    // the code will prefer `state_after` if it is present
+                    roomJson["org.matrix.msc4222.state_after"].events.push(ev);
+                    // Roll the state back to the value at the start of the timeline if it was changed
                     if (rollBackState[evType] && rollBackState[evType][stateKey]) {
-                        // use the reverse clobbered event instead.
                         ev = rollBackState[evType][stateKey];
                     }
                     roomJson.state.events.push(ev);

package/src/sync.ts

@@ -161,14 +161,15 @@ export enum SetPresence {
 }
 
 interface ISyncParams {
-    filter?: string;
-    timeout: number;
-    since?: string;
+    "filter"?: string;
+    "timeout": number;
+    "since"?: string;
     // eslint-disable-next-line camelcase
-    full_state?: boolean;
+    "full_state"?: boolean;
     // eslint-disable-next-line camelcase
-    set_presence?: SetPresence;
-    _cacheBuster?: string | number; // not part of the API itself
+    "set_presence"?: SetPresence;
+    "_cacheBuster"?: string | number; // not part of the API itself
+    "org.matrix.msc4222.use_state_after"?: boolean; // https://github.com/matrix-org/matrix-spec-proposals/pull/4222
 }
 
 type WrappedRoom<T> = T & {
@@ -330,8 +331,9 @@ export class SyncApi {
         );
 
         const qps: ISyncParams = {
-            timeout: 0, // don't want to block since this is a single isolated req
-            filter: filterId,
+            "timeout": 0, // don't want to block since this is a single isolated req
+            "filter": filterId,
+            "org.matrix.msc4222.use_state_after": true,
         };
 
         const data = await client.http.authedRequest<ISyncResponse>(Method.Get, "/sync", qps as any, undefined, {
@@ -361,21 +363,17 @@ export class SyncApi {
                     prev_batch: null,
                     events: [],
                 };
-                const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
-
-                const stateEvents = this.mapSyncEventsFormat(leaveObj.state, room);
-
                 // set the back-pagination token. Do this *before* adding any
                 // events so that clients can start back-paginating.
                 room.getLiveTimeline().setPaginationToken(leaveObj.timeline.prev_batch, EventTimeline.BACKWARDS);
 
-                await this.injectRoomEvents(room, stateEvents, events);
+                const { timelineEvents } = await this.mapAndInjectRoomEvents(leaveObj);
 
                 room.recalculate();
                 client.store.storeRoom(room);
                 client.emit(ClientEvent.Room, room);
 
-                this.processEventsForNotifs(room, events);
+                this.processEventsForNotifs(room, timelineEvents);
                 return room;
             }),
         );
@@ -450,6 +448,7 @@ export class SyncApi {
             this._peekRoom.addEventsToTimeline(
                 messages.reverse(),
                 true,
+                true,
                 this._peekRoom.getLiveTimeline(),
                 response.messages.start,
             );
@@ -537,7 +536,7 @@ export class SyncApi {
                         })
                         .map(this.client.getEventMapper());
 
-                    await peekRoom.addLiveEvents(events);
+                    await peekRoom.addLiveEvents(events, { addToState: true });
                     this.peekPoll(peekRoom, res.end);
                 },
                 (err) => {
@@ -938,7 +937,11 @@ export class SyncApi {
             filter = this.getGuestFilter();
         }
 
-        const qps: ISyncParams = { filter, timeout };
+        const qps: ISyncParams = {
+            filter,
+            timeout,
+            "org.matrix.msc4222.use_state_after": true,
+        };
 
         if (this.opts.disablePresence) {
             qps.set_presence = SetPresence.Offline;
@@ -1200,7 +1203,7 @@ export class SyncApi {
             const room = inviteObj.room;
             const stateEvents = this.mapSyncEventsFormat(inviteObj.invite_state, room);
 
-            await this.injectRoomEvents(room, stateEvents);
+            await this.injectRoomEvents(room, stateEvents, undefined);
 
             if (inviteObj.isBrandNewRoom) {
                 room.recalculate();
@@ -1219,15 +1222,24 @@ export class SyncApi {
         await promiseMapSeries(joinRooms, async (joinObj) => {
             const room = joinObj.room;
             const stateEvents = this.mapSyncEventsFormat(joinObj.state, room);
+            const stateAfterEvents = this.mapSyncEventsFormat(joinObj["org.matrix.msc4222.state_after"], room);
             // Prevent events from being decrypted ahead of time
             // this helps large account to speed up faster
             // room::decryptCriticalEvent is in charge of decrypting all the events
             // required for a client to function properly
-            const events = this.mapSyncEventsFormat(joinObj.timeline, room, false);
+            const timelineEvents = this.mapSyncEventsFormat(joinObj.timeline, room, false);
             const ephemeralEvents = this.mapSyncEventsFormat(joinObj.ephemeral);
             const accountDataEvents = this.mapSyncEventsFormat(joinObj.account_data);
 
-            const encrypted = this.isRoomEncrypted(room, stateEvents, events);
+            // If state_after is present, this is the events that form the state at the end of the timeline block and
+            // regular timeline events do *not* count towards state. If it's not present, then the state is formed by
+            // the state events plus the timeline events. Note mapSyncEventsFormat returns an empty array if the field
+            // is absent so we explicitly check the field on the original object.
+            const eventsFormingFinalState = joinObj["org.matrix.msc4222.state_after"]
+                ? stateAfterEvents
+                : stateEvents.concat(timelineEvents);
+
+            const encrypted = this.isRoomEncrypted(room, eventsFormingFinalState);
             // We store the server-provided value first so it's correct when any of the events fire.
             if (joinObj.unread_notifications) {
                 /**
@@ -1315,8 +1327,8 @@ export class SyncApi {
                 // which we'll try to paginate but not get any new events (which
                 // will stop us linking the empty timeline into the chain).
                 //
-                for (let i = events.length - 1; i >= 0; i--) {
-                    const eventId = events[i].getId()!;
+                for (let i = timelineEvents.length - 1; i >= 0; i--) {
+                    const eventId = timelineEvents[i].getId()!;
                     if (room.getTimelineForEvent(eventId)) {
                         debuglog(`Already have event ${eventId} in limited sync - not resetting`);
                         limited = false;
@@ -1324,7 +1336,7 @@ export class SyncApi {
                         // we might still be missing some of the events before i;
                         // we don't want to be adding them to the end of the
                         // timeline because that would put them out of order.
-                        events.splice(0, i);
+                        timelineEvents.splice(0, i);
 
                         // XXX: there's a problem here if the skipped part of the
                         // timeline modifies the state set in stateEvents, because
@@ -1353,7 +1365,17 @@ export class SyncApi {
             }
 
             try {
-                await this.injectRoomEvents(room, stateEvents, events, syncEventData.fromCache);
+                if ("org.matrix.msc4222.state_after" in joinObj) {
+                    await this.injectRoomEvents(
+                        room,
+                        undefined,
+                        stateAfterEvents,
+                        timelineEvents,
+                        syncEventData.fromCache,
+                    );
+                } else {
+                    await this.injectRoomEvents(room, stateEvents, undefined, timelineEvents, syncEventData.fromCache);
+                }
             } catch (e) {
                 logger.error(`Failed to process events on room ${room.roomId}:`, e);
             }
@@ -1377,11 +1399,11 @@ export class SyncApi {
                 client.emit(ClientEvent.Room, room);
             }
 
-            this.processEventsForNotifs(room, events);
+            this.processEventsForNotifs(room, timelineEvents);
 
             const emitEvent = (e: MatrixEvent): boolean => client.emit(ClientEvent.Event, e);
             stateEvents.forEach(emitEvent);
-            events.forEach(emitEvent);
+            timelineEvents.forEach(emitEvent);
             ephemeralEvents.forEach(emitEvent);
             accountDataEvents.forEach(emitEvent);
         });
@@ -1389,11 +1411,9 @@ export class SyncApi {
         // Handle leaves (e.g. kicked rooms)
         await promiseMapSeries(leaveRooms, async (leaveObj) => {
             const room = leaveObj.room;
-            const stateEvents = this.mapSyncEventsFormat(leaveObj.state, room);
-            const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
+            const { timelineEvents, stateEvents, stateAfterEvents } = await this.mapAndInjectRoomEvents(leaveObj);
             const accountDataEvents = this.mapSyncEventsFormat(leaveObj.account_data);
 
-            await this.injectRoomEvents(room, stateEvents, events);
             room.addAccountData(accountDataEvents);
 
             room.recalculate();
@@ -1402,12 +1422,15 @@ export class SyncApi {
                 client.emit(ClientEvent.Room, room);
             }
 
-            this.processEventsForNotifs(room, events);
+            this.processEventsForNotifs(room, timelineEvents);
 
-            stateEvents.forEach(function (e) {
+            stateEvents?.forEach(function (e) {
                 client.emit(ClientEvent.Event, e);
             });
-            events.forEach(function (e) {
+            stateAfterEvents?.forEach(function (e) {
+                client.emit(ClientEvent.Event, e);
+            });
+            timelineEvents.forEach(function (e) {
                 client.emit(ClientEvent.Event, e);
             });
             accountDataEvents.forEach(function (e) {
@@ -1420,7 +1443,7 @@ export class SyncApi {
             const room = knockObj.room;
             const stateEvents = this.mapSyncEventsFormat(knockObj.knock_state, room);
 
-            await this.injectRoomEvents(room, stateEvents);
+            await this.injectRoomEvents(room, stateEvents, undefined);
 
             if (knockObj.isBrandNewRoom) {
                 room.recalculate();
@@ -1445,7 +1468,7 @@ export class SyncApi {
                 return a.getTs() - b.getTs();
             });
             this.notifEvents.forEach(function (event) {
-                client.getNotifTimelineSet()?.addLiveEvent(event);
+                client.getNotifTimelineSet()?.addLiveEvent(event, { addToState: true });
             });
         }
     }
@@ -1572,7 +1595,7 @@ export class SyncApi {
     }
 
     private mapSyncEventsFormat(
-        obj: IInviteState | ITimeline | IEphemeral,
+        obj: IInviteState | ITimeline | IEphemeral | undefined,
         room?: Room,
         decrypt = true,
     ): MatrixEvent[] {
@@ -1640,28 +1663,69 @@ export class SyncApi {
 
     // When processing the sync response we cannot rely on Room.hasEncryptionStateEvent we actually
     // inject the events into the room object, so we have to inspect the events themselves.
-    private isRoomEncrypted(room: Room, stateEventList: MatrixEvent[], timelineEventList?: MatrixEvent[]): boolean {
-        return (
-            room.hasEncryptionStateEvent() ||
-            !!this.findEncryptionEvent(stateEventList) ||
-            !!this.findEncryptionEvent(timelineEventList)
+    private isRoomEncrypted(room: Room, eventsFormingFinalState: MatrixEvent[]): boolean {
+        return room.hasEncryptionStateEvent() || !!this.findEncryptionEvent(eventsFormingFinalState);
+    }
+
+    private async mapAndInjectRoomEvents(wrappedRoom: WrappedRoom<ILeftRoom>): Promise<{
+        timelineEvents: MatrixEvent[];
+        stateEvents?: MatrixEvent[];
+        stateAfterEvents?: MatrixEvent[];
+    }> {
+        const stateEvents = this.mapSyncEventsFormat(wrappedRoom.state, wrappedRoom.room);
+        const stateAfterEvents = this.mapSyncEventsFormat(
+            wrappedRoom["org.matrix.msc4222.state_after"],
+            wrappedRoom.room,
         );
+        const timelineEvents = this.mapSyncEventsFormat(wrappedRoom.timeline, wrappedRoom.room);
+
+        if ("org.matrix.msc4222.state_after" in wrappedRoom) {
+            await this.injectRoomEvents(wrappedRoom.room, undefined, stateAfterEvents, timelineEvents);
+        } else {
+            await this.injectRoomEvents(wrappedRoom.room, stateEvents, undefined, timelineEvents);
+        }
+
+        return { timelineEvents, stateEvents, stateAfterEvents };
     }
 
     /**
      * Injects events into a room's model.
      * @param stateEventList - A list of state events. This is the state
      * at the *START* of the timeline list if it is supplied.
+     * @param stateAfterEventList - A list of state events. This is the state
+     * at the *END* of the timeline list if it is supplied.
      * @param timelineEventList - A list of timeline events, including threaded. Lower index
      * is earlier in time. Higher index is later.
      * @param fromCache - whether the sync response came from cache
+     *
+     * No more than one of stateEventList and stateAfterEventList must be supplied. If
+     * stateEventList is supplied, the events in timelineEventList are added to the state
+     * after stateEventList. If stateAfterEventList is supplied, the events in timelineEventList
+     * are not added to the state.
      */
     public async injectRoomEvents(
         room: Room,
         stateEventList: MatrixEvent[],
+        stateAfterEventList: undefined,
+        timelineEventList?: MatrixEvent[],
+        fromCache?: boolean,
+    ): Promise<void>;
+    public async injectRoomEvents(
+        room: Room,
+        stateEventList: undefined,
+        stateAfterEventList: MatrixEvent[],
+        timelineEventList?: MatrixEvent[],
+        fromCache?: boolean,
+    ): Promise<void>;
+    public async injectRoomEvents(
+        room: Room,
+        stateEventList: MatrixEvent[] | undefined,
+        stateAfterEventList: MatrixEvent[] | undefined,
         timelineEventList?: MatrixEvent[],
         fromCache = false,
     ): Promise<void> {
+        const eitherStateEventList = stateAfterEventList ?? stateEventList!;
+
         // If there are no events in the timeline yet, initialise it with
         // the given state events
         const liveTimeline = room.getLiveTimeline();
@@ -1675,10 +1739,11 @@ export class SyncApi {
             // push actions cache elsewhere so we can freeze MatrixEvents, or otherwise
             // find some solution where MatrixEvents are immutable but allow for a cache
             // field.
-            for (const ev of stateEventList) {
+
+            for (const ev of eitherStateEventList) {
                 this.client.getPushActionsForEvent(ev);
             }
-            liveTimeline.initialiseState(stateEventList, {
+            liveTimeline.initialiseState(eitherStateEventList, {
                 timelineWasEmpty,
             });
         }
@@ -1710,17 +1775,18 @@ export class SyncApi {
             // XXX: As above, don't do this...
             //room.addLiveEvents(stateEventList || []);
             // Do this instead...
-            room.oldState.setStateEvents(stateEventList || []);
-            room.currentState.setStateEvents(stateEventList || []);
+            room.oldState.setStateEvents(eitherStateEventList);
+            room.currentState.setStateEvents(eitherStateEventList);
         }
 
-        // Execute the timeline events. This will continue to diverge the current state
-        // if the timeline has any state events in it.
+        // Execute the timeline events. If addToState is true the timeline has any state
+        // events in it, this will continue to diverge the current state.
         // This also needs to be done before running push rules on the events as they need
         // to be decorated with sender etc.
         await room.addLiveEvents(timelineEventList || [], {
             fromCache,
             timelineWasEmpty,
+            addToState: stateAfterEventList === undefined,
         });
         this.client.processBeaconEvents(room, timelineEventList);
     }