feat: added util func to propagate the forzen request to mutable one

Author: lwin-kyaw

src/jrpc/v2/compatibility-utils.ts

@@ -97,6 +97,23 @@ export function propagateToRequest(req: Record<string, unknown>, context: Middle
     });
 }
 
+/**
+ * Copies non-JSON-RPC string properties from the context to the request.
+ *
+ * Clone the original request object and propagate the context to the cloned request.
+ *
+ * **ATTN:** Only string properties are copied.
+ *
+ * @param req - The request to propagate the context to.
+ * @param context - The context to propagate from.
+ * @returns The mutable cloned request.
+ */
+export function propagateToMutableRequest(req: Record<string, unknown>, context: MiddlewareContext): Record<string, unknown> {
+  const clonedRequest = deepClone(req);
+  propagateToRequest(clonedRequest, context);
+  return clonedRequest;
+}
+
 /**
  * Deserialize the error property for a thrown error, merging in the cause where possible.
  *

src/jrpc/v2/index.ts

@@ -1,6 +1,6 @@
 export { getUniqueId, isNotification, isRequest } from "../../utils/jrpc";
 export { asLegacyMiddleware } from "./asLegacyMiddleware";
-export { deepClone, fromLegacyRequest, makeContext, propagateToContext, propagateToRequest } from "./compatibility-utils";
+export { deepClone, fromLegacyRequest, makeContext, propagateToContext, propagateToMutableRequest, propagateToRequest } from "./compatibility-utils";
 export { createScaffoldMiddleware as createScaffoldMiddlewareV2 } from "./createScaffoldMiddleware";
 export { JRPCEngineV2 } from "./jrpcEngineV2";
 export { JRPCServer } from "./jrpcServer";

test/v2/compatibility-utils.test.ts

@@ -1,17 +1,18 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { Json, JRPCParams, JRPCRequest } from "../../src";
-import { stringify } from "../../src/utils/jrpc";
+import { JRPCParams, JRPCRequest, Json } from "../../src";
 import { JsonRpcError } from "../../src/jrpc/errors";
 import {
   deepClone,
   deserializeError,
   fromLegacyRequest,
   makeContext,
   propagateToContext,
+  propagateToMutableRequest,
   propagateToRequest,
 } from "../../src/jrpc/v2/compatibility-utils";
 import { MiddlewareContext } from "../../src/jrpc/v2/MiddlewareContext";
+import { stringify } from "../../src/utils/jrpc";
 
 const jsonrpc = "2.0" as const;
 
@@ -340,6 +341,85 @@ describe("compatibility-utils", () => {
     });
   });
 
+  describe("propagateToMutableRequest", () => {
+    it("returns a mutable object from a frozen request", () => {
+      const request = Object.freeze({
+        jsonrpc,
+        method: "test_method",
+        params: Object.freeze([1, 2, 3]),
+        id: 1,
+      });
+      const context = new MiddlewareContext<Record<string, unknown>>();
+      context.set("extraProp", "value");
+
+      const result = propagateToMutableRequest(request, context);
+
+      expect(Object.isFrozen(result)).toBe(false);
+      result.newKey = "can assign";
+      expect(result.newKey).toBe("can assign");
+    });
+
+    it("does not mutate the original frozen request", () => {
+      const request = Object.freeze({
+        jsonrpc,
+        method: "test_method",
+        params: Object.freeze([1, 2, 3]),
+        id: 1,
+      });
+      const context = new MiddlewareContext<Record<string, unknown>>();
+      context.set("extraProp", "value");
+
+      propagateToMutableRequest(request, context);
+
+      expect(request).toStrictEqual({
+        jsonrpc,
+        method: "test_method",
+        params: [1, 2, 3],
+        id: 1,
+      });
+      expect("extraProp" in request).toBe(false);
+    });
+
+    it("propagates context properties onto the mutable clone of a frozen request", () => {
+      const request = Object.freeze({
+        jsonrpc,
+        method: "test_method",
+        params: Object.freeze([1]),
+        id: 42,
+      });
+      const context = new MiddlewareContext<Record<string, unknown>>();
+      context.set("extraProp", "value");
+      context.set("anotherProp", { nested: true });
+
+      const result = propagateToMutableRequest(request, context);
+
+      expect(result).toStrictEqual({
+        jsonrpc,
+        method: "test_method",
+        params: [1],
+        id: 42,
+        extraProp: "value",
+        anotherProp: { nested: true },
+      });
+    });
+
+    it("produces deeply mutable params from a frozen request", () => {
+      const request = Object.freeze({
+        jsonrpc,
+        method: "test_method",
+        params: Object.freeze([Object.freeze({ a: 1 }), 2]),
+        id: 1,
+      });
+      const context = new MiddlewareContext();
+
+      const result = propagateToMutableRequest(request, context);
+
+      expect(Object.isFrozen(result.params)).toBe(false);
+      (result.params as unknown[])[0] = "replaced";
+      expect((result.params as unknown[])[0]).toBe("replaced");
+    });
+  });
+
   describe("deserializeError", () => {
     // Requires some special handling due to the possible existence or
     // non-existence of Error.isError