feat: Allow converting V2 middleware to legacy middleware

Co-authored-by: erik.marks <[email protected]>

Author: cursoragent

packages/json-rpc-engine/README.md

@@ -81,8 +81,9 @@ await server.handle(notification);
 
 ### Legacy compatibility
 
-Use the `asLegacyMiddleware` function to use a `JsonRpcEngineV2` as a
-middleware in a legacy `JsonRpcEngine`:
+Use the `asLegacyMiddleware` function to use a `JsonRpcEngineV2` or V2 middleware as middleware in a legacy `JsonRpcEngine`:
+
+#### Converting a V2 engine
 
 ```ts
 import {
@@ -102,6 +103,34 @@ const v2Engine = JsonRpcEngineV2.create({
 legacyEngine.push(asLegacyMiddleware(v2Engine));
 ```
 
+#### Converting V2 middleware
+
+You can also directly convert one or more V2 middlewares without creating an engine:
+
+```ts
+import {
+  asLegacyMiddleware,
+  type JsonRpcMiddleware,
+} from '@metamask/json-rpc-engine/v2';
+import { JsonRpcEngine } from '@metamask/json-rpc-engine';
+
+// Convert a single V2 middleware
+const middleware1: JsonRpcMiddleware<JsonRpcRequest> = ({ request }) => {
+  /* ... */
+};
+
+const legacyEngine = new JsonRpcEngine();
+legacyEngine.push(asLegacyMiddleware(middleware1));
+
+// Convert multiple V2 middlewares at once
+const middleware2: JsonRpcMiddleware<JsonRpcRequest> = ({ context, next }) => {
+  /* ... */
+};
+
+const legacyEngine2 = new JsonRpcEngine();
+legacyEngine2.push(asLegacyMiddleware(middleware1, middleware2));
+```
+
 In keeping with the conventions of the legacy engine, non-JSON-RPC string properties of the `context` will be
 copied over to the request once the V2 engine is done with the request. _Note that **only `string` keys** of
 the `context` will be copied over._

packages/json-rpc-engine/src/v2/asLegacyMiddleware.test.ts

@@ -190,4 +190,93 @@ describe('asLegacyMiddleware', () => {
     await legacyEngine.handle(makeRequest());
     expect(observedContextValues).toStrictEqual([1, 2]);
   });
+
+  describe('with V2 middleware', () => {
+    it('accepts a single V2 middleware', async () => {
+      const v2Middleware: JsonRpcMiddleware<JsonRpcRequest> = jest.fn(
+        () => 'test-result',
+      );
+
+      const legacyEngine = new JsonRpcEngine();
+      legacyEngine.push(asLegacyMiddleware(v2Middleware));
+
+      const response = (await legacyEngine.handle(
+        makeRequest(),
+      )) as JsonRpcSuccess;
+
+      expect(response.result).toBe('test-result');
+      expect(v2Middleware).toHaveBeenCalledTimes(1);
+    });
+
+    it('accepts multiple V2 middlewares via rest params', async () => {
+      const middleware1: JsonRpcMiddleware<JsonRpcRequest> = jest.fn(
+        ({ context, next }) => {
+          context.set('visited1', true);
+          return next();
+        },
+      );
+
+      const middleware2: JsonRpcMiddleware<JsonRpcRequest> = jest.fn(
+        ({ context }) => {
+          expect(context.get('visited1')).toBe(true);
+          return 'composed-result';
+        },
+      );
+
+      const legacyEngine = new JsonRpcEngine();
+      legacyEngine.push(asLegacyMiddleware(middleware1, middleware2));
+
+      const response = (await legacyEngine.handle(
+        makeRequest(),
+      )) as JsonRpcSuccess;
+
+      expect(response.result).toBe('composed-result');
+      expect(middleware1).toHaveBeenCalledTimes(1);
+      expect(middleware2).toHaveBeenCalledTimes(1);
+    });
+
+    it('forwards errors from V2 middleware', async () => {
+      const v2Middleware: JsonRpcMiddleware<JsonRpcRequest> = jest.fn(() => {
+        throw new Error('v2-error');
+      });
+
+      const legacyEngine = new JsonRpcEngine();
+      legacyEngine.push(asLegacyMiddleware(v2Middleware));
+
+      const response = (await legacyEngine.handle(
+        makeRequest(),
+      )) as JsonRpcFailure;
+
+      expect(response.error).toStrictEqual({
+        message: 'v2-error',
+        code: -32603,
+        data: {
+          cause: {
+            message: 'v2-error',
+            stack: expect.any(String),
+          },
+        },
+      });
+    });
+
+    it('allows legacy engine to continue when V2 middleware does not end', async () => {
+      const v2Middleware: JsonRpcMiddleware<JsonRpcRequest> = jest.fn(
+        ({ next }) => next(),
+      );
+
+      const legacyEngine = new JsonRpcEngine();
+      legacyEngine.push(asLegacyMiddleware(v2Middleware));
+      legacyEngine.push((_req, res, _next, end) => {
+        res.result = 'continued';
+        end();
+      });
+
+      const response = (await legacyEngine.handle(
+        makeRequest(),
+      )) as JsonRpcSuccess;
+
+      expect(response.result).toBe('continued');
+      expect(v2Middleware).toHaveBeenCalledTimes(1);
+    });
+  });
 });

packages/json-rpc-engine/src/v2/asLegacyMiddleware.ts

@@ -6,7 +6,12 @@ import {
   makeContext,
   propagateToRequest,
 } from './compatibility-utils';
-import type { JsonRpcEngineV2, ResultConstraint } from './JsonRpcEngineV2';
+import type {
+  JsonRpcEngineV2,
+  JsonRpcMiddleware as V2Middleware,
+  ResultConstraint,
+} from './JsonRpcEngineV2';
+import { JsonRpcEngineV2 as EngineV2 } from './JsonRpcEngineV2';
 import { createAsyncMiddleware } from '..';
 import type { JsonRpcMiddleware as LegacyMiddleware } from '..';
 
@@ -21,8 +26,45 @@ export function asLegacyMiddleware<
   Request extends JsonRpcRequest<Params>,
 >(
   engine: JsonRpcEngineV2<Request>,
+): LegacyMiddleware<Params, ResultConstraint<Request>>;
+
+/**
+ * Convert one or more V2 middlewares into a legacy middleware.
+ *
+ * @param middleware - The V2 middleware(s) to convert.
+ * @returns The legacy middleware.
+ */
+export function asLegacyMiddleware<
+  Params extends JsonRpcParams,
+  Request extends JsonRpcRequest<Params>,
+>(
+  ...middleware: V2Middleware<Request, ResultConstraint<Request>>[]
+): LegacyMiddleware<Params, ResultConstraint<Request>>;
+
+/**
+ * Implementation of asLegacyMiddleware that handles all input types.
+ *
+ * @param engineOrMiddleware - A V2 engine, a single V2 middleware, or an array of V2 middleware.
+ * @param rest - Additional V2 middleware when the first argument is a single middleware.
+ * @returns The legacy middleware.
+ */
+export function asLegacyMiddleware<
+  Params extends JsonRpcParams,
+  Request extends JsonRpcRequest<Params>,
+>(
+  engineOrMiddleware:
+    | JsonRpcEngineV2<Request>
+    | V2Middleware<Request, ResultConstraint<Request>>,
+  ...rest: V2Middleware<Request, ResultConstraint<Request>>[]
 ): LegacyMiddleware<Params, ResultConstraint<Request>> {
-  const middleware = engine.asMiddleware();
+  // Determine the V2 middleware function from input(s)
+  const middleware =
+    typeof engineOrMiddleware === 'function'
+      ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        EngineV2.create<any>({
+          middleware: [engineOrMiddleware, ...rest],
+        }).asMiddleware()
+      : engineOrMiddleware.asMiddleware();
   return createAsyncMiddleware(async (req, res, next) => {
     const request = fromLegacyRequest(req as Request);
     const context = makeContext(req);
@@ -32,7 +74,7 @@ export function asLegacyMiddleware<
       request,
       context,
       next: (finalRequest) => {
-        modifiedRequest = finalRequest;
+        modifiedRequest = finalRequest as Request | undefined;
         return Promise.resolve(undefined);
       },
     });