Send/receive error details with widgets

spec/unit/embedded.spec.ts

@@ -90,7 +90,11 @@ class MockWidgetApi extends EventEmitter {
     public getTurnServers = jest.fn(() => []);
     public sendContentLoaded = jest.fn();
 
-    public transport = { reply: jest.fn() };
+    public transport = {
+        reply: jest.fn(),
+        send: jest.fn(),
+        sendComplete: jest.fn(),
+    };
 }
 
 declare module "../../src/types" {

src/embedded.ts

@@ -17,12 +17,17 @@
 import {
     WidgetApi,
     WidgetApiToWidgetAction,
+    WidgetApiResponseError,
     MatrixCapabilities,
     IWidgetApiRequest,
     IWidgetApiAcknowledgeResponseData,
     ISendEventToWidgetActionRequest,
     ISendToDeviceToWidgetActionRequest,
     ISendEventFromWidgetResponseData,
+    IWidgetApiRequestData,
+    WidgetApiAction,
+    IWidgetApiResponse,
+    IWidgetApiResponseData,
 } from "matrix-widget-api";
 
 import { MatrixEvent, IEvent, IContent, EventStatus } from "./models/event.ts";
@@ -45,6 +50,7 @@
 } from "./client.ts";
 import { SyncApi, SyncState } from "./sync.ts";
 import { SlidingSyncSdk } from "./sliding-sync-sdk.ts";
+import { MatrixError } from "./http-api/errors.ts";
 import { User } from "./models/user.ts";
 import { Room } from "./models/room.ts";
 import { ToDeviceBatch, ToDevicePayload } from "./models/ToDeviceMessage.ts";
@@ -147,6 +153,33 @@
     ) {
         super(opts);
 
+        const transportSend = this.widgetApi.transport.send.bind(this.widgetApi.transport);
+        this.widgetApi.transport.send = async <
+            T extends IWidgetApiRequestData,
+            R extends IWidgetApiResponseData = IWidgetApiAcknowledgeResponseData,
+        >(
+            action: WidgetApiAction,
+            data: T,
+        ): Promise<R> => {
+            try {
+                return await transportSend<T, R>(action, data);
+            } catch (error) {
+                processAndThrow(error);
+            }
+        };
+
+        const transportSendComplete = this.widgetApi.transport.sendComplete.bind(this.widgetApi.transport);
+        this.widgetApi.transport.sendComplete = async <T extends IWidgetApiRequestData, R extends IWidgetApiResponse>(
+            action: WidgetApiAction,
+            data: T,
+        ): Promise<R> => {
+            try {
+                return await transportSendComplete<T, R>(action, data);
+            } catch (error) {
+                processAndThrow(error);
+            }
+        };
+
         this.widgetApiReady = new Promise<void>((resolve) => this.widgetApi.once("ready", resolve));
 
         // Request capabilities for the functionality this client needs to support
@@ -523,3 +556,11 @@
         }
     }
 }
+
+function processAndThrow(error: unknown): never {
+    if (error instanceof WidgetApiResponseError && error.data.matrix_api_error) {
+        throw MatrixError.fromWidgetApiErrorData(error.data.matrix_api_error);
+    } else {
+        throw error;
+    }
+}

src/http-api/errors.ts

@@ -14,6 +14,8 @@
 limitations under the License.
 */
 
+import { IMatrixApiError as IWidgetMatrixError } from "matrix-widget-api";
+
 import { IUsageLimit } from "../@types/partials.ts";
 import { MatrixEvent } from "../models/event.ts";
 
@@ -131,6 +133,33 @@
         }
         return null;
     }
+
+    /**
+     * @returns this error expressed as a {@link IWidgetMatrixError}
+     * for use by Widget API error responses.
+     */
+    public asWidgetApiErrorData(): IWidgetMatrixError {
+        const headers: Record<string, string> = {};
+        if (this.httpHeaders) {
+            for (const [name, value] of this.httpHeaders) {
+                headers[name] = value;
+            }
+        }
+        return {
+            http_status: this.httpStatus ?? 400,
+            http_headers: headers,
+            url: this.url ?? "",
+            response: {
+                errcode: this.errcode ?? "M_UNKNOWN",
+                error: this.name,
+                ...this.data,
+            },
+        };
+    }
+
+    public static fromWidgetApiErrorData(data: IWidgetMatrixError): MatrixError {
+        return new MatrixError(data.response, data.http_status, data.url, undefined, new Headers(data.http_headers));
+    }
 }
 
 /**