Update delayed events via widget

Author: AndrewFerr

spec/unit/embedded.spec.ts

@@ -32,7 +32,7 @@ import {
     IOpenIDCredentials,
 } from "matrix-widget-api";
 
-import { createRoomWidgetClient, MsgType } from "../../src/matrix";
+import { createRoomWidgetClient, MsgType, UpdateDelayedEventAction } from "../../src/matrix";
 import { MatrixClient, ClientEvent, ITurnServer as IClientTurnServer } from "../../src/client";
 import { SyncState } from "../../src/sync";
 import { ICapabilities } from "../../src/embedded";
@@ -78,6 +78,7 @@ class MockWidgetApi extends EventEmitter {
                 ? { event_id: `$${Math.random()}` }
                 : { delay_id: `id-${Math.random()}` },
     );
+    public updateDelayedEvent = jest.fn();
     public sendToDevice = jest.fn();
     public requestOpenIDConnectToken = jest.fn(() => {
         return testOIDCToken;
@@ -192,9 +193,8 @@ describe("RoomWidgetClient", () => {
             });
 
             it("sends delayed message events", async () => {
-                await makeClient({ sendEvent: ["org.matrix.rageshake_request"] });
-                expect(widgetApi.requestCapabilityForRoomTimeline).toHaveBeenCalledWith("!1:example.org");
-                expect(widgetApi.requestCapabilityToSendEvent).toHaveBeenCalledWith("org.matrix.rageshake_request");
+                await makeClient({ sendDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
+                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
                 await client._unstable_sendDelayedEvent(
                     "!1:example.org",
                     { delay: 2000 },
@@ -212,9 +212,8 @@ describe("RoomWidgetClient", () => {
             });
 
             it("sends child action delayed message events", async () => {
-                await makeClient({ sendEvent: ["org.matrix.rageshake_request"] });
-                expect(widgetApi.requestCapabilityForRoomTimeline).toHaveBeenCalledWith("!1:example.org");
-                expect(widgetApi.requestCapabilityToSendEvent).toHaveBeenCalledWith("org.matrix.rageshake_request");
+                await makeClient({ sendDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
+                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
                 const parentDelayId = `id-${Math.random()}`;
                 await client._unstable_sendDelayedEvent(
                     "!1:example.org",
@@ -233,9 +232,8 @@ describe("RoomWidgetClient", () => {
             });
 
             it("sends delayed state events", async () => {
-                await makeClient({ sendState: [{ eventType: "org.example.foo", stateKey: "bar" }] });
-                expect(widgetApi.requestCapabilityForRoomTimeline).toHaveBeenCalledWith("!1:example.org");
-                expect(widgetApi.requestCapabilityToSendState).toHaveBeenCalledWith("org.example.foo", "bar");
+                await makeClient({ sendDelayedEvents: true, sendState: [{ eventType: "org.example.foo", stateKey: "bar" }] });
+                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
                 await client._unstable_sendDelayedStateEvent(
                     "!1:example.org",
                     { delay: 2000 },
@@ -254,9 +252,8 @@ describe("RoomWidgetClient", () => {
             });
 
             it("sends child action delayed state events", async () => {
-                await makeClient({ sendState: [{ eventType: "org.example.foo", stateKey: "bar" }] });
-                expect(widgetApi.requestCapabilityForRoomTimeline).toHaveBeenCalledWith("!1:example.org");
-                expect(widgetApi.requestCapabilityToSendState).toHaveBeenCalledWith("org.example.foo", "bar");
+                await makeClient({ sendDelayedEvents: true, sendState: [{ eventType: "org.example.foo", stateKey: "bar" }] });
+                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157SendDelayedEvent);
                 const parentDelayId = `fg-${Math.random()}`;
                 await client._unstable_sendDelayedStateEvent(
                     "!1:example.org",
@@ -274,6 +271,19 @@ describe("RoomWidgetClient", () => {
                     parentDelayId,
                 );
             });
+
+            it("updates delayed events", async () => {
+                await makeClient({ updateDelayedEvents: true, sendEvent: ["org.matrix.rageshake_request"] });
+                expect(widgetApi.requestCapability).toHaveBeenCalledWith(MatrixCapabilities.MSC4157UpdateDelayedEvent);
+                for (const action of [
+                    UpdateDelayedEventAction.Cancel,
+                    UpdateDelayedEventAction.Restart,
+                    UpdateDelayedEventAction.Send,
+                ]) {
+                    await client._unstable_updateDelayedEvent("id", action);
+                    expect(widgetApi.updateDelayedEvent).toHaveBeenCalledWith("id", action);
+                }
+            });
         });
 
         describe("when unsupported", () => {
@@ -302,6 +312,19 @@ describe("RoomWidgetClient", () => {
                     ),
                 ).rejects.toThrow("Server does not support");
             });
+
+            it("fails to update delayed state events", async () => {
+                await makeClient({});
+                for (const action of [
+                    UpdateDelayedEventAction.Cancel,
+                    UpdateDelayedEventAction.Restart,
+                    UpdateDelayedEventAction.Send,
+                ]) {
+                    await expect(
+                        client._unstable_updateDelayedEvent("id", action),
+                    ).rejects.toThrow("Server does not support");
+                }
+            });
         });
     });
 

src/embedded.ts

@@ -26,7 +26,12 @@ import {
 } from "matrix-widget-api";
 
 import { MatrixEvent, IEvent, IContent, EventStatus } from "./models/event";
-import { ISendEventResponse, SendDelayedEventRequestOpts, SendDelayedEventResponse } from "./@types/requests";
+import {
+    ISendEventResponse,
+    SendDelayedEventRequestOpts,
+    SendDelayedEventResponse,
+    UpdateDelayedEventAction,
+} from "./@types/requests";
 import { EventType, StateEvents } from "./@types/event";
 import { logger } from "./logger";
 import {
@@ -96,6 +101,20 @@ export interface ICapabilities {
      * @defaultValue false
      */
     turnServers?: boolean;
+
+    /**
+     * Whether this client needs to be able to send delayed events.
+     * @experimental Part of MSC4140 & MSC4157
+     * @defaultValue false
+     */
+    sendDelayedEvents?: boolean;
+
+    /**
+     * Whether this client needs to be able to update delayed events.
+     * @experimental Part of MSC4140 & MSC4157
+     * @defaultValue false
+     */
+    updateDelayedEvents?: boolean;
 }
 
 /**
@@ -163,6 +182,19 @@ export class RoomWidgetClient extends MatrixClient {
         );
         capabilities.sendToDevice?.forEach((eventType) => widgetApi.requestCapabilityToSendToDevice(eventType));
         capabilities.receiveToDevice?.forEach((eventType) => widgetApi.requestCapabilityToReceiveToDevice(eventType));
+        if (
+            capabilities.sendDelayedEvents && (
+                capabilities.sendEvent?.length ||
+                capabilities.sendMessage === true ||
+                (Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length) ||
+                capabilities.sendState?.length
+            )
+        ) {
+            widgetApi.requestCapability(MatrixCapabilities.MSC4157SendDelayedEvent);
+        }
+        if (capabilities.updateDelayedEvents) {
+            widgetApi.requestCapability(MatrixCapabilities.MSC4157UpdateDelayedEvent);
+        }
         if (capabilities.turnServers) {
             widgetApi.requestCapability(MatrixCapabilities.MSC3846TurnServers);
         }
@@ -320,6 +352,18 @@ export class RoomWidgetClient extends MatrixClient {
         return this.validateSendDelayedEventResponse(response);
     }
 
+    /**
+     * @experimental This currently relies on an unstable MSC (MSC4140).
+     */
+    // eslint-disable-next-line
+    public async _unstable_updateDelayedEvent(delayId: string, action: UpdateDelayedEventAction): Promise<{}> {
+        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+            throw Error("Server does not support the delayed events API");
+        }
+
+        return await this.widgetApi.updateDelayedEvent(delayId, action);
+    }
+
     private validateSendEventResponse(response: ISendEventFromWidgetResponseData): ISendEventResponse {
         if (response.event_id === undefined) {
             throw new Error("'event_id' absent from response to an event request");