Add support for JSON patch transforms on request bodies

Author: pimterry

package.json

@@ -177,6 +177,7 @@
     "cross-fetch": "^3.1.5",
     "destroyable-server": "^1.0.2",
     "express": "^4.14.0",
+    "fast-json-patch": "^3.1.1",
     "graphql": "^14.0.2 || ^15.5",
     "graphql-http": "^1.22.0",
     "graphql-subscriptions": "^1.1.0",

src/rules/requests/request-handler-definitions.ts

@@ -4,6 +4,10 @@ import type * as net from 'net';
 import { encode as encodeBase64 } from 'base64-arraybuffer';
 import { Readable, Transform } from 'stream';
 import { stripIndent } from 'common-tags';
+import {
+    Operation as JsonPatchOperation,
+    validate as validateJsonPatch
+} from 'fast-json-patch';
 
 import {
     Headers,
@@ -597,13 +601,25 @@ export interface RequestTransform {
 
     /**
      * A JSON object which will be merged with the real request body. Undefined values
-     * will be removed. Any requests which are received with an invalid JSON body that
-     * match this rule will fail.
+     * will be removed, and other values will be merged directly with the target value
+     * recursively.
+     *
+     * Any requests which are received with an invalid JSON body that match this rule
+     * will fail.
      */
     updateJsonBody?: {
         [key: string]: any;
     };
 
+    /**
+     * A series of operations to apply to the request body in JSON Patch format (RFC
+     * 6902).
+     *
+     * Any requests which are received with an invalid JSON body that match this rule
+     * will fail.
+     */
+    patchJsonBody?: Array<JsonPatchOperation>;
+
     /**
      * Perform a series of string match & replace operations on the request body.
      *
@@ -810,11 +826,17 @@ export class PassThroughHandlerDefinition extends Serializable implements Reques
                 options.transformRequest.replaceBody,
                 options.transformRequest.replaceBodyFromFile,
                 options.transformRequest.updateJsonBody,
+                options.transformRequest.patchJsonBody,
                 options.transformRequest.matchReplaceBody
             ].filter(o => !!o).length > 1) {
                 throw new Error("Only one request body transform can be specified at a time");
             }
 
+            if (options.transformRequest.patchJsonBody) {
+                const validationError = validateJsonPatch(options.transformRequest.patchJsonBody);
+                if (validationError) throw validationError;
+            }
+
             this.transformRequest = options.transformRequest;
         }
 

src/rules/requests/request-handlers.ts

@@ -11,6 +11,7 @@ import { decode as decodeBase64 } from 'base64-arraybuffer';
 import { Transform } from 'stream';
 import { stripIndent, oneLine } from 'common-tags';
 import { TypedError } from 'typed-error';
+import { applyPatch as applyJsonPatch } from 'fast-json-patch';
 
 import {
     Headers,
@@ -492,6 +493,7 @@ export class PassThroughHandler extends PassThroughHandlerDefinition {
                 replaceBody,
                 replaceBodyFromFile,
                 updateJsonBody,
+                patchJsonBody,
                 matchReplaceBody
             } = this.transformRequest;
 
@@ -518,22 +520,28 @@ export class PassThroughHandler extends PassThroughHandlerDefinition {
                 reqBodyOverride = await fs.readFile(replaceBodyFromFile);
             } else if (updateJsonBody) {
                 const { body: realBody } = await waitForCompletedRequest(clientReq);
-                if (await realBody.getJson() === undefined) {
-                    throw new Error("Can't transform non-JSON request body");
+                const jsonBody = await realBody.getJson();
+                if (jsonBody === undefined) {
+                    throw new Error("Can't update JSON in non-JSON request body");
                 }
 
-                const updatedBody = _.mergeWith(
-                    await realBody.getJson(),
-                    updateJsonBody,
-                    (_oldValue, newValue) => {
-                        // We want to remove values with undefines, but Lodash ignores
-                        // undefined return values here. Fortunately, JSON.stringify
-                        // ignores Symbols, omitting them from the result.
-                        if (newValue === undefined) return OMIT_SYMBOL;
-                    }
-                );
+                const updatedBody = _.mergeWith(jsonBody, updateJsonBody, (_oldValue, newValue) => {
+                    // We want to remove values with undefines, but Lodash ignores
+                    // undefined return values here. Fortunately, JSON.stringify
+                    // ignores Symbols, omitting them from the result.
+                    if (newValue === undefined) return OMIT_SYMBOL;
+                });
 
                 reqBodyOverride = asBuffer(JSON.stringify(updatedBody));
+            } else if (patchJsonBody) {
+                const { body: realBody } = await waitForCompletedRequest(clientReq);
+                const jsonBody = await realBody.getJson();
+                if (jsonBody === undefined) {
+                    throw new Error("Can't patch JSON in non-JSON request body");
+                }
+
+                applyJsonPatch(jsonBody, patchJsonBody, true); // Mutates the JSON body returned above
+                reqBodyOverride = asBuffer(JSON.stringify(jsonBody));
             } else if (matchReplaceBody) {
                 const { body: realBody } = await waitForCompletedRequest(clientReq);
 

test/integration/proxying/proxy-transforms.spec.ts

@@ -451,7 +451,8 @@ nodeOnly(() => {
             it("can update a JSON body with new fields", async () => {
                 await server.forAnyRequest().thenPassThrough({
                     transformRequest: {
-                        updateJsonBody:{
+                        // Same update as the JSON Patch below, in simpler merge form:
+                        updateJsonBody: {
                             a: 100, // Update
                             b: undefined, // Remove
                             c: 2 // Add
@@ -480,7 +481,8 @@ nodeOnly(() => {
             it("can update a JSON body while handling encoding automatically", async () => {
                 await server.forAnyRequest().thenPassThrough({
                     transformRequest: {
-                        updateJsonBody:{
+                        // Same update as the JSON Patch below, in simpler merge form:
+                        updateJsonBody: {
                             a: 100, // Update
                             b: undefined, // Remove
                             c: 2 // Add
@@ -513,6 +515,36 @@ nodeOnly(() => {
                     body: JSON.stringify({ a: 100, c: 2 })
                 });
             });
+
+            it("can update a JSON body with a JSON patch", async () => {
+                await server.forAnyRequest().thenPassThrough({
+                    transformRequest: {
+                        patchJsonBody: [
+                            // Same logic as the update above, in JSON Patch form:
+                            { op: 'replace', path: '/a', value: 100 },
+                            { op: 'remove', path: '/b' },
+                            { op: 'add', path: '/c', value: 2 }
+                        ]
+                    }
+                });
+
+                let response = await request.post(remoteServer.urlFor("/abc"), {
+                    headers: { 'custom-header': 'a-value' },
+                    body: { a: 1, b: 2 },
+                    json: true
+                });
+
+                expect(response).to.deep.equal({
+                    url: remoteServer.urlFor("/abc"),
+                    method: 'POST',
+                    headers: {
+                        ...baseHeaders(),
+                        'content-length': '15',
+                        'custom-header': 'a-value'
+                    },
+                    body: JSON.stringify({ a: 100, c: 2 })
+                });
+            });
         });
 
         describe("that transforms responses automatically", () => {