WIP

Author: rekmarks

src/engine.test.ts renamed to src/JsonRpcEngine.test.ts

@@ -1,6 +1,6 @@
 import SafeEventEmitter from '@metamask/safe-event-emitter';
 import { errorCodes, EthereumRpcError, serializeError } from 'eth-rpc-errors';
-import { isJsonRpcRequest } from './utils';
+import { isJsonRpcNotification, isJsonRpcRequest } from './utils';
 
 type Maybe<T> = Partial<T> | null | undefined;
 
@@ -128,7 +128,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
   }
 
   /**
-   * Add a middleware function to the engine's notification middleware stack.
+   * Adds a middleware function to the engine's notification middleware stack.
    *
    * @param middleware - The notification middleware function to add.
    */
@@ -228,8 +228,17 @@ export class JsonRpcEngine extends SafeEventEmitter {
   asMiddleware(): JsonRpcMiddleware<unknown, unknown> {
     return async (req, res, next, end) => {
       try {
+        if (isJsonRpcNotification(req)) {
+          // This will invoke the end callback.
+          return await JsonRpcEngine._processNotification(
+            req,
+            this._notificationMiddleware,
+            () => end(),
+          );
+        }
+
         const [middlewareError, isComplete, returnHandlers] =
-          await JsonRpcEngine._runAllMiddleware(
+          await JsonRpcEngine._runAllRequestMiddleware(
             req,
             res,
             this._requestMiddleware,
@@ -334,7 +343,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
    */
   private async _handle(
     callerReq: JsonRpcRequest<unknown> | JsonRpcNotification<unknown>,
-    callback: (error: unknown, response?: JsonRpcResponse<unknown>) => void,
+    callback: (error?: unknown, response?: JsonRpcResponse<unknown>) => void,
   ): Promise<void> {
     if (
       !callerReq ||
@@ -355,30 +364,32 @@ export class JsonRpcEngine extends SafeEventEmitter {
         `Must specify a string method. Received: ${typeof callerReq.method}`,
         { request: callerReq },
       );
-      return callback(error, {
-        id: (callerReq as any).id ?? null,
-        jsonrpc: '2.0',
-        error,
-      });
-    }
 
-    let error: JsonRpcEngineCallbackError = null;
+      if (isJsonRpcRequest(callerReq)) {
+        return callback(error, {
+          id: (callerReq as any).id ?? null,
+          jsonrpc: '2.0',
+          error,
+        });
+      }
+      // Do not reply to notifications, even malformed ones.
+      return callback(null);
+    }
 
     // Handle notifications.
     // We can't use isJsonRpcNotification here because that narrows callerReq to
     // "never" after the if clause for unknown reasons.
     if (!isJsonRpcRequest(callerReq)) {
-      try {
-        await JsonRpcEngine._processNotification(
-          { ...callerReq },
-          this._notificationMiddleware,
-        );
-      } catch (_error) {
-        error = _error;
-      }
-      return callback(error);
+      // This will invoke the callback.
+      return await JsonRpcEngine._processNotification(
+        { ...callerReq },
+        this._notificationMiddleware,
+        callback,
+      );
     }
 
+    let error: JsonRpcEngineCallbackError = null;
+
     // Handle requests.
     const req: JsonRpcRequest<unknown> = { ...callerReq };
     const res: PendingJsonRpcResponse<unknown> = {
@@ -407,17 +418,28 @@ export class JsonRpcEngine extends SafeEventEmitter {
 
   /**
    * Runs all notification middleware on the specified notification.
+   * Does not throw.
    *
    * @param notification - The notification object to process.
-   * @param notificationMiddlewares - The stack of notification middleware functions.
+   * @param notificationMiddlewares - The stack of notification middleware
+   * functions.
+   * @param callback - Callback from {@link JsonRpcEngine._handle} or
+   * {@link JsonRpcEngineEndCallback}. Will always be invoked with nothing,
+   * because notifications must not be responded to.
    */
   private static async _processNotification(
     notification: JsonRpcNotification<unknown>,
     notificationMiddlewares: JsonRpcNotificationMiddleware<unknown>[],
+    callback: (error?: unknown, response?: JsonRpcResponse<unknown>) => void,
   ): Promise<void> {
-    for (const middleware of notificationMiddlewares) {
-      await middleware(notification);
+    try {
+      for (const middleware of notificationMiddlewares) {
+        await middleware(notification);
+      }
+    } catch (middlewareError) {
+      console.error(middlewareError);
     }
+    callback(null);
   }
 
   /**
@@ -435,7 +457,11 @@ export class JsonRpcEngine extends SafeEventEmitter {
     requestMiddlewares: JsonRpcMiddleware<unknown, unknown>[],
   ): Promise<void> {
     const [error, isComplete, returnHandlers] =
-      await JsonRpcEngine._runAllMiddleware(req, res, requestMiddlewares);
+      await JsonRpcEngine._runAllRequestMiddleware(
+        req,
+        res,
+        requestMiddlewares,
+      );
 
     // Throw if "end" was not called, or if the response has neither a result
     // nor an error.
@@ -462,7 +488,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
    * a boolean indicating whether the request was completed, and an array of
    * middleware-defined return handlers.
    */
-  private static async _runAllMiddleware(
+  private static async _runAllRequestMiddleware(
     req: JsonRpcRequest<unknown>,
     res: PendingJsonRpcResponse<unknown>,
     requestMiddlewares: JsonRpcMiddleware<unknown, unknown>[],
@@ -479,7 +505,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
 
     // Go down stack of middleware, call and collect optional returnHandlers
     for (const middleware of requestMiddlewares) {
-      [error, isComplete] = await JsonRpcEngine._runMiddleware(
+      [error, isComplete] = await JsonRpcEngine._runRequestMiddleware(
         req,
         res,
         middleware,
@@ -503,7 +529,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
    * @returns An array of any error encountered during middleware exection,
    * and a boolean indicating whether the request should end.
    */
-  private static _runMiddleware(
+  private static _runRequestMiddleware(
     req: JsonRpcRequest<unknown>,
     res: PendingJsonRpcResponse<unknown>,
     middleware: JsonRpcMiddleware<unknown, unknown>,
@@ -576,7 +602,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
    *
    * @param req - The request object.
    * @param res - The response object.
-   * @param isComplete - Boolean from {@link JsonRpcEngine._runAllMiddleware}
+   * @param isComplete - Boolean from {@link JsonRpcEngine._runAllRequestMiddleware}
    * indicating whether a middleware ended the request.
    */
   private static _checkForCompletion(