[json-rpc-engine] Fix any types in catch blocks, refactor

packages/json-rpc-engine/src/JsonRpcEngine.ts

@@ -9,21 +9,23 @@ import type {
   JsonRpcParams,
   PendingJsonRpcResponse,
 } from '@metamask/utils';
-import { hasProperty, isJsonRpcRequest } from '@metamask/utils';
+import {
+  hasProperty,
+  isJsonRpcNotification,
+  isJsonRpcRequest,
+} from '@metamask/utils';
 
 export type JsonRpcEngineCallbackError = Error | SerializedJsonRpcError | null;
 
 export type JsonRpcEngineReturnHandler = (
-  done: (error?: JsonRpcEngineCallbackError) => void,
+  done: (error?: unknown) => void,
 ) => void;
 
 export type JsonRpcEngineNextCallback = (
   returnHandlerCallback?: JsonRpcEngineReturnHandler,
 ) => void;
 
-export type JsonRpcEngineEndCallback = (
-  error?: JsonRpcEngineCallbackError,
-) => void;
+export type JsonRpcEngineEndCallback = (error?: unknown) => void;
 
 export type JsonRpcMiddleware<
   Params extends JsonRpcParams,
@@ -200,9 +202,13 @@ export class JsonRpcEngine extends SafeEventEmitter {
     requests: (JsonRpcRequest<Params> | JsonRpcNotification<Params>)[],
   ): Promise<JsonRpcResponse<Result>[]>;
 
-  // TODO: Replace `any` with type
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  handle(req: unknown, callback?: any) {
+  handle(
+    req:
+      | (JsonRpcRequest | JsonRpcNotification)[]
+      | JsonRpcRequest
+      | JsonRpcNotification,
+    callback?: (error: unknown, response: never) => void,
+  ) {
     this.#assertIsNotDestroyed();
 
     if (callback && typeof callback !== 'function') {
@@ -211,15 +217,24 @@ export class JsonRpcEngine extends SafeEventEmitter {
 
     if (Array.isArray(req)) {
       if (callback) {
-        return this.#handleBatch(req, callback);
+        return this.#handleBatch(
+          req,
+          callback as (
+            error: unknown,
+            responses?: JsonRpcResponse<Json>[],
+          ) => void,
+        );
       }
       return this.#handleBatch(req);
     }
 
     if (callback) {
-      return this.#handle(req as JsonRpcRequest, callback);
+      return this.#handle(
+        req,
+        callback as (error: unknown, response?: JsonRpcResponse<Json>) => void,
+      );
     }
-    return this._promiseHandle(req as JsonRpcRequest);
+    return this._promiseHandle(req);
   }
 
   /**
@@ -239,23 +254,19 @@ export class JsonRpcEngine extends SafeEventEmitter {
 
         if (isComplete) {
           await JsonRpcEngine.#runReturnHandlers(returnHandlers);
-          return end(middlewareError as JsonRpcEngineCallbackError);
+          return end(middlewareError);
         }
 
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
         return next(async (handlerCallback) => {
           try {
             await JsonRpcEngine.#runReturnHandlers(returnHandlers);
-            // TODO: Replace `any` with type
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          } catch (error: any) {
+          } catch (error) {
             return handlerCallback(error);
           }
           return handlerCallback();
         });
-        // TODO: Replace `any` with type
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      } catch (error: any) {
+      } catch (error) {
         return end(error);
       }
     };
@@ -317,8 +328,8 @@ export class JsonRpcEngine extends SafeEventEmitter {
         )
       ).filter(
         // Filter out any notification responses.
-        (response) => response !== undefined,
-      ) as JsonRpcResponse<Json>[];
+        (response): response is JsonRpcResponse<Json> => response !== undefined,
+      );
 
       // 3. Return batch response
       if (callback) {
@@ -392,7 +403,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
       const error = new JsonRpcError(
         errorCodes.rpc.invalidRequest,
         `Must specify a string method. Received: ${typeof callerReq.method}`,
-        { request: callerReq as Json },
+        { request: callerReq },
       );
 
       if (this.#notificationHandler && !isJsonRpcRequest(callerReq)) {
@@ -403,25 +414,23 @@ export class JsonRpcEngine extends SafeEventEmitter {
       return callback(error, {
         // Typecast: This could be a notification, but we want to access the
         // `id` even if it doesn't exist.
-        id: (callerReq as JsonRpcRequest).id ?? null,
+        id: (callerReq as JsonRpcRequest).id,
         jsonrpc: '2.0',
         error,
       });
-    }
-
-    // Handle notifications.
-    // We can't use isJsonRpcNotification here because that narrows callerReq to
-    // "never" after the if clause for unknown reasons.
-    if (this.#notificationHandler && !isJsonRpcRequest(callerReq)) {
+    } else if (
+      this.#notificationHandler &&
+      isJsonRpcNotification(callerReq) &&
+      !isJsonRpcRequest(callerReq)
+    ) {
       try {
         await this.#notificationHandler(callerReq);
       } catch (error) {
         return callback(error);
       }
       return callback(null);
     }
-
-    let error: JsonRpcEngineCallbackError = null;
+    let error = null;
 
     // Handle requests.
     // Typecast: Permit missing id's for backwards compatibility.
@@ -433,9 +442,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
 
     try {
       await JsonRpcEngine.#processRequest(req, res, this.#middleware);
-      // TODO: Replace `any` with type
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } catch (_error: any) {
+    } catch (_error) {
       // A request handler error, a re-thrown middleware error, or something
       // unexpected.
       error = _error;
@@ -543,13 +550,13 @@ export class JsonRpcEngine extends SafeEventEmitter {
     returnHandlers: JsonRpcEngineReturnHandler[],
   ): Promise<[unknown, boolean]> {
     return new Promise((resolve) => {
-      const end: JsonRpcEngineEndCallback = (error?: unknown) => {
+      const end: JsonRpcEngineEndCallback = (error) => {
         const parsedError = error || response.error;
         if (parsedError) {
           response.error = serializeError(parsedError);
         }
         // True indicates that the request should end
-        resolve([parsedError, true]);
+        resolve([parsedError ?? null, true]);
       };
 
       const next: JsonRpcEngineNextCallback = (
@@ -567,7 +574,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
                     `Received "${typeof returnHandler}" for request:\n${jsonify(
                       request,
                     )}`,
-                  { request: request as Json },
+                  { request },
                 ),
               );
             }
@@ -581,9 +588,7 @@ export class JsonRpcEngine extends SafeEventEmitter {
 
       try {
         middleware(request, response, next, end);
-        // TODO: Replace `any` with type
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      } catch (error: any) {
+      } catch (error) {
         end(error);
       }
     });
@@ -625,15 +630,15 @@ export class JsonRpcEngine extends SafeEventEmitter {
         `JsonRpcEngine: Response has no error or result for request:\n${jsonify(
           request,
         )}`,
-        { request: request as Json },
+        { request },
       );
     }
 
     if (!isComplete) {
       throw new JsonRpcError(
         errorCodes.rpc.internal,
         `JsonRpcEngine: Nothing ended request:\n${jsonify(request)}`,
-        { request: request as Json },
+        { request },
       );
     }
   }

packages/json-rpc-engine/src/createAsyncMiddleware.ts

@@ -5,7 +5,10 @@ import type {
   PendingJsonRpcResponse,
 } from '@metamask/utils';
 
-import type { JsonRpcMiddleware } from './JsonRpcEngine';
+import type {
+  JsonRpcEngineReturnHandler,
+  JsonRpcMiddleware,
+} from './JsonRpcEngine';
 
 export type AsyncJsonRpcEngineNextCallback = () => Promise<void>;
 
@@ -18,7 +21,7 @@ export type AsyncJsonrpcMiddleware<
   next: AsyncJsonRpcEngineNextCallback,
 ) => Promise<void>;
 
-type ReturnHandlerCallback = (error: null | Error) => void;
+type ReturnHandlerCallback = Parameters<JsonRpcEngineReturnHandler>[0];
 
 /**
  * JsonRpcEngine only accepts callback-based middleware directly.
@@ -83,9 +86,7 @@ export function createAsyncMiddleware<
       } else {
         end(null);
       }
-      // TODO: Replace `any` with type
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } catch (error: any) {
+    } catch (error) {
       if (returnHandlerCallback) {
         (returnHandlerCallback as ReturnHandlerCallback)(error);
       } else {