add upsert function for updating beacon events (#2247)

* add upsert function for updating beacon events

Signed-off-by: Kerry Archibald <[email protected]>

* expose event type on beacon model

Signed-off-by: Kerry Archibald <[email protected]>

* allow setting timestamp in beaconinfo content helper

Signed-off-by: Kerry Archibald <[email protected]>

* expose parsed beacon info

Signed-off-by: Kerry Archibald <[email protected]>

Author: Kerry

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()', () => {

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

@@ -44,7 +44,7 @@ export const isBeaconInfoEventType = (type: string) =>
 // https://github.com/matrix-org/matrix-spec-proposals/pull/3489
 export class Beacon extends TypedEventEmitter<BeaconEvent, BeaconEventHandlerMap> {
     public readonly roomId: string;
-    private beaconInfo: BeaconInfoState;
+    private _beaconInfo: BeaconInfoState;
     private _isLive: boolean;
     private livenessWatchInterval: number;
 
@@ -69,6 +69,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 +103,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);