Merge branch 'develop' into voice-rooms

Author: robintown

spec/unit/content-helpers.spec.ts

@@ -59,6 +59,18 @@ describe('Beacon content helpers', () => {
             }));
         });
 
+        it('uses timestamp when provided', () => {
+            expect(makeBeaconInfoContent(
+                1234,
+                true,
+                'nice beacon_info',
+                LocationAssetType.Pin,
+                99999,
+            )).toEqual(expect.objectContaining({
+                [M_TIMESTAMP.name]: 99999,
+            }));
+        });
+
         it('defaults asset type to self when not set', () => {
             expect(makeBeaconInfoContent(
                 1234,

spec/unit/matrix-client.spec.ts

@@ -14,6 +14,8 @@ import { MEGOLM_ALGORITHM } from "../../src/crypto/olmlib";
 import { EventStatus, MatrixEvent } from "../../src/models/event";
 import { Preset } from "../../src/@types/partials";
 import * as testUtils from "../test-utils/test-utils";
+import { makeBeaconInfoContent } from "../../src/content-helpers";
+import { M_BEACON_INFO } from "../../src/@types/beacon";
 
 jest.useFakeTimers();
 
@@ -969,4 +971,43 @@ describe("MatrixClient", function() {
             client.supportsExperimentalThreads = supportsExperimentalThreads;
         });
     });
+
+    describe("beacons", () => {
+        const roomId = '!room:server.org';
+        const content = makeBeaconInfoContent(100, true);
+
+        beforeEach(() => {
+            client.http.authedRequest.mockClear().mockResolvedValue({});
+        });
+
+        it("creates new beacon info", async () => {
+            await client.unstable_createLiveBeacon(roomId, content, '123');
+
+            // event type combined
+            const expectedEventType = `${M_BEACON_INFO.name}.${userId}.123`;
+            const [callback, method, path, queryParams, requestContent] = client.http.authedRequest.mock.calls[0];
+            expect(callback).toBeFalsy();
+            expect(method).toBe('PUT');
+            expect(path).toEqual(
+                `/rooms/${encodeURIComponent(roomId)}/state/` +
+                `${encodeURIComponent(expectedEventType)}/${encodeURIComponent(userId)}`,
+            );
+            expect(queryParams).toBeFalsy();
+            expect(requestContent).toEqual(content);
+        });
+
+        it("updates beacon info with specific event type", async () => {
+            const eventType = `${M_BEACON_INFO.name}.${userId}.456`;
+
+            await client.unstable_setLiveBeacon(roomId, eventType, content);
+
+            // event type combined
+            const [, , path, , requestContent] = client.http.authedRequest.mock.calls[0];
+            expect(path).toEqual(
+                `/rooms/${encodeURIComponent(roomId)}/state/` +
+                `${encodeURIComponent(eventType)}/${encodeURIComponent(userId)}`,
+            );
+            expect(requestContent).toEqual(content);
+        });
+    });
 });

spec/unit/models/beacon.spec.ts

@@ -122,6 +122,7 @@ describe('Beacon', () => {
             expect(beacon.roomId).toEqual(roomId);
             expect(beacon.isLive).toEqual(true);
             expect(beacon.beaconInfoOwner).toEqual(userId);
+            expect(beacon.beaconInfoEventType).toEqual(liveBeaconEvent.getType());
         });
 
         describe('isLive()', () => {

spec/unit/room-state.spec.js

@@ -2,6 +2,7 @@ import * as utils from "../test-utils/test-utils";
 import { makeBeaconInfoEvent } from "../test-utils/beacon";
 import { filterEmitCallsByEventType } from "../test-utils/emitter";
 import { RoomState, RoomStateEvent } from "../../src/models/room-state";
+import { BeaconEvent } from "../../src/models/beacon";
 
 describe("RoomState", function() {
     const roomId = "!foo:bar";
@@ -251,13 +252,16 @@ describe("RoomState", function() {
             );
         });
 
-        it('adds new beacon info events to state', () => {
+        it('adds new beacon info events to state and emits', () => {
             const beaconEvent = makeBeaconInfoEvent(userA, roomId);
+            const emitSpy = jest.spyOn(state, 'emit');
 
             state.setStateEvents([beaconEvent]);
 
             expect(state.beacons.size).toEqual(1);
-            expect(state.beacons.get(beaconEvent.getId())).toBeTruthy();
+            const beaconInstance = state.beacons.get(beaconEvent.getId());
+            expect(beaconInstance).toBeTruthy();
+            expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.New, beaconEvent, beaconInstance);
         });
 
         it('updates existing beacon info events in state', () => {

src/client.ts

@@ -3686,14 +3686,32 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns {ISendEventResponse}
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    unstable_createLiveBeacon(
+    public async unstable_createLiveBeacon(
         roomId: Room["roomId"],
         beaconInfoContent: MBeaconInfoEventContent,
         eventTypeSuffix: string,
     ) {
         const userId = this.getUserId();
         const eventType = M_BEACON_INFO_VARIABLE.name.replace('*', `${userId}.${eventTypeSuffix}`);
-        return this.sendStateEvent(roomId, eventType, beaconInfoContent, userId);
+        return this.unstable_setLiveBeacon(roomId, eventType, beaconInfoContent);
+    }
+
+    /**
+     * Upsert a live beacon event
+     * using a specific m.beacon_info.* event variable type
+     * @param {string} roomId string
+     * @param {string} beaconInfoEventType event type including variable suffix
+     * @param {MBeaconInfoEventContent} beaconInfoContent
+     * @returns {ISendEventResponse}
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public async unstable_setLiveBeacon(
+        roomId: string,
+        beaconInfoEventType: string,
+        beaconInfoContent: MBeaconInfoEventContent,
+    ) {
+        const userId = this.getUserId();
+        return this.sendStateEvent(roomId, beaconInfoEventType, beaconInfoContent, userId);
     }
 
     /**

src/content-helpers.ts

@@ -198,20 +198,22 @@ export type MakeBeaconInfoContent = (
     isLive?: boolean,
     description?: string,
     assetType?: LocationAssetType,
+    timestamp?: number
 ) => MBeaconInfoEventContent;
 
 export const makeBeaconInfoContent: MakeBeaconInfoContent = (
     timeout,
     isLive,
     description,
     assetType,
+    timestamp,
 ) => ({
     [M_BEACON_INFO.name]: {
         description,
         timeout,
         live: isLive,
     },
-    [M_TIMESTAMP.name]: Date.now(),
+    [M_TIMESTAMP.name]: timestamp || Date.now(),
     [M_ASSET.name]: {
         type: assetType ?? LocationAssetType.Self,
     },

src/models/beacon.ts

@@ -26,7 +26,6 @@ export enum BeaconEvent {
 }
 
 export type BeaconEventHandlerMap = {
-    [BeaconEvent.New]: (event: MatrixEvent, beacon: Beacon) => void;
     [BeaconEvent.Update]: (event: MatrixEvent, beacon: Beacon) => void;
     [BeaconEvent.LivenessChange]: (isLive: boolean, beacon: Beacon) => void;
 };
@@ -42,9 +41,9 @@ export const isBeaconInfoEventType = (type: string) =>
     type.startsWith(M_BEACON_INFO.altName);
 
 // https://github.com/matrix-org/matrix-spec-proposals/pull/3489
-export class Beacon extends TypedEventEmitter<BeaconEvent, BeaconEventHandlerMap> {
+export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.New>, BeaconEventHandlerMap> {
     public readonly roomId: string;
-    private beaconInfo: BeaconInfoState;
+    private _beaconInfo: BeaconInfoState;
     private _isLive: boolean;
     private livenessWatchInterval: number;
 
@@ -54,7 +53,6 @@ export class Beacon extends TypedEventEmitter<BeaconEvent, BeaconEventHandlerMap
         super();
         this.setBeaconInfo(this.rootEvent);
         this.roomId = this.rootEvent.getRoomId();
-        this.emit(BeaconEvent.New, this.rootEvent, this);
     }
 
     public get isLive(): boolean {
@@ -69,6 +67,14 @@ export class Beacon extends TypedEventEmitter<BeaconEvent, BeaconEventHandlerMap
         return this.rootEvent.getStateKey();
     }
 
+    public get beaconInfoEventType(): string {
+        return this.rootEvent.getType();
+    }
+
+    public get beaconInfo(): BeaconInfoState {
+        return this._beaconInfo;
+    }
+
     public update(beaconInfoEvent: MatrixEvent): void {
         if (beaconInfoEvent.getId() !== this.beaconInfoId) {
             throw new Error('Invalid updating event');
@@ -95,22 +101,22 @@ export class Beacon extends TypedEventEmitter<BeaconEvent, BeaconEventHandlerMap
         }
 
         if (this.isLive) {
-            const expiryInMs = (this.beaconInfo?.timestamp + this.beaconInfo?.timeout + 1) - Date.now();
+            const expiryInMs = (this._beaconInfo?.timestamp + this._beaconInfo?.timeout + 1) - Date.now();
             if (expiryInMs > 1) {
                 this.livenessWatchInterval = setInterval(this.checkLiveness.bind(this), expiryInMs);
             }
         }
     }
 
     private setBeaconInfo(event: MatrixEvent): void {
-        this.beaconInfo = parseBeaconInfoContent(event.getContent());
+        this._beaconInfo = parseBeaconInfoContent(event.getContent());
         this.checkLiveness();
     }
 
     private checkLiveness(): void {
         const prevLiveness = this.isLive;
-        this._isLive = this.beaconInfo?.live &&
-            isTimestampInDuration(this.beaconInfo?.timestamp, this.beaconInfo?.timeout, Date.now());
+        this._isLive = this._beaconInfo?.live &&
+            isTimestampInDuration(this._beaconInfo?.timestamp, this._beaconInfo?.timeout, Date.now());
 
         if (prevLiveness !== this.isLive) {
             this.emit(BeaconEvent.LivenessChange, this.isLive, this);

src/models/room-state.ts

@@ -26,7 +26,8 @@ import { MatrixEvent } from "./event";
 import { MatrixClient } from "../client";
 import { GuestAccess, HistoryVisibility, IJoinRuleEventContent, JoinRule } from "../@types/partials";
 import { TypedEventEmitter } from "./typed-event-emitter";
-import { Beacon, BeaconEvent, isBeaconInfoEventType } from "./beacon";
+import { Beacon, BeaconEvent, isBeaconInfoEventType, BeaconEventHandlerMap } from "./beacon";
+import { TypedReEmitter } from "../ReEmitter";
 
 // possible statuses for out-of-band member loading
 enum OobStatus {
@@ -49,9 +50,14 @@ export type RoomStateEventHandlerMap = {
     [RoomStateEvent.NewMember]: (event: MatrixEvent, state: RoomState, member: RoomMember) => void;
     [RoomStateEvent.Update]: (state: RoomState) => void;
     [RoomStateEvent.BeaconLiveness]: (state: RoomState, hasLiveBeacons: boolean) => void;
+    [BeaconEvent.New]: (event: MatrixEvent, beacon: Beacon) => void;
 };
 
-export class RoomState extends TypedEventEmitter<RoomStateEvent, RoomStateEventHandlerMap> {
+type EmittedEvents = RoomStateEvent | BeaconEvent;
+type EventHandlerMap = RoomStateEventHandlerMap & BeaconEventHandlerMap;
+
+export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
+    public readonly reEmitter = new TypedReEmitter<EmittedEvents, EventHandlerMap>(this);
     private sentinels: Record<string, RoomMember> = {}; // userId: RoomMember
     // stores fuzzy matches to a list of userIDs (applies utils.removeHiddenChars to keys)
     private displayNameToUserIds: Record<string, string[]> = {};
@@ -436,6 +442,14 @@ export class RoomState extends TypedEventEmitter<RoomStateEvent, RoomStateEventH
         }
 
         const beacon = new Beacon(event);
+
+        this.reEmitter.reEmit<BeaconEvent, BeaconEvent>(beacon, [
+            BeaconEvent.New,
+            BeaconEvent.Update,
+            BeaconEvent.LivenessChange,
+        ]);
+
+        this.emit(BeaconEvent.New, event, beacon);
         beacon.on(BeaconEvent.LivenessChange, this.onBeaconLivenessChange.bind(this));
         this.beacons.set(beacon.beaconInfoId, beacon);
     }