feat: pass client headers like payload, gateway cookies manipulation

Author: MatthewPattell

__tests__/services/abstract-microservice-test.ts

@@ -336,7 +336,13 @@ describe('services/abstract-microservice', () => {
     // Set correctly microservice url
     expect(url).to.equal(`${options.connection}/${ms.getChannelPrefix()}/${microservice}`);
     // correctly pass params to request
-    expect(data.params).to.deep.equal(params);
+    expect(data.params).to.deep.equal({
+      ...params,
+      payload: {
+        sender: 'tests',
+        senderStack: ['tests'],
+      },
+    });
     // correctly generate request id
     expect(data.id).to.not.empty;
   });

__tests__/services/gateway-test.ts

@@ -38,7 +38,11 @@ describe('services/gateway', () => {
    * Create express response
    */
   const createResponse = () =>
-    ({ json: sinon.stub() } as unknown as Response & { json: SinonStub });
+    ({
+      json: sinon.stub(),
+      cookie: sinon.stub(),
+      clearCookie: sinon.stub(),
+    } as unknown as Response & { json: SinonStub; cookie: SinonStub; clearCookie: SinonStub });
 
   const msName = 'ms1';
   const msName2 = 'ms2';
@@ -301,6 +305,7 @@ describe('services/gateway', () => {
     expect(response.getResult()).to.deep.equal({ endpointTriggerMiddleware, middleware: 'after' });
     expect(data.method).to.equal(endpointTriggerMiddleware);
     expect(data.params.middleware).to.equal('before');
+    expect(data.params.payload.headers.type).to.equal('async'); // check pass client headers through payload
     expect(headers.type).to.equal('async');
   });
 
@@ -386,4 +391,34 @@ describe('services/gateway', () => {
     expect(response).to.undefined;
     expect(stubbed).to.calledOnce;
   });
+
+  it('should correctly manipulation with cookie', async () => {
+    const req = createRequest({ method: 'cookies.test-cookies' });
+    const res = createResponse();
+
+    const responseAxios = new MicroserviceResponse({
+      result: {
+        hello: 'world',
+        payload: {
+          cookies: [
+            { action: 'add', name: 'cookie1', value: 'test1', options: { httpOnly: true } },
+            { action: 'remove', name: 'cookie2' },
+          ],
+        },
+      },
+    });
+    const stubbed = sinon.stub(axios, 'request').resolves({ data: responseAxios.toJSON() });
+
+    await handleClientRequest(req, res);
+
+    stubbed.restore();
+
+    const addCookie = res.cookie.firstCall.args;
+    const clearCookie = res.clearCookie.firstCall.args;
+    const result = res.json.firstCall.firstArg;
+
+    expect(addCookie).to.deep.equal(['cookie1', 'test1', { httpOnly: true }]);
+    expect(clearCookie).to.deep.equal(['cookie2']);
+    expect(result.payload).to.undefined;
+  });
 });

example/index.ts

@@ -4,6 +4,8 @@ import Microservice from '@services/microservice';
 // import { Gateway, Microservice } from '../lib';
 
 /**
+ * THIS IS MICROSERVICE: demo
+ *
  * 1. Create microservice with name 'demo'
  * 2. add 'test' endpoint handler
  */
@@ -21,8 +23,19 @@ microservice.addEndpoint('test-exception', () => {
     },
   });
 });
+microservice.addEndpoint('test-with-cookies-manipulations', () => ({
+  awesome: 'result',
+  payload: {
+    cookies: [
+      { action: 'add', name: 'cookie1', value: 'test1', options: { httpOnly: true } },
+      { action: 'remove', name: 'cookie2' },
+    ],
+  },
+}));
 
 /**
+ * THIS IS MICROSERVICE: gateway
+ *
  * 1. Create gateway (auto registration microservices enabled)
  */
 const gateway = Gateway.create();

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lomray/microservice-nodejs-lib",
-	"version": "2.3.0",
+	"version": "2.4.0",
 	"description": "Package for create microservice architecture based on NodeJS & inverted json.",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",

src/interfaces/core/i-microservice-request.ts

@@ -5,6 +5,7 @@ interface IMicroserviceRequestPayload {
   sender?: string;
   isInternal?: boolean;
   senderStack?: string[];
+  headers?: Record<string, any>;
 }
 
 type PayloadExtends<TParams> = TParams & IMicroserviceRequestPayload;

src/interfaces/core/i-microservice-response.ts

@@ -1,10 +1,17 @@
+import type { CookieOptions } from 'express-serve-static-core';
 import BaseException from '@core/base-exception';
 
 /**
  * Microservices data
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface IMicroserviceResponsePayload {}
+interface IMicroserviceResponsePayload {
+  cookies?: {
+    action: 'add' | 'remove';
+    name: string;
+    value?: string;
+    options?: CookieOptions;
+  }[];
+}
 
 type PayloadExtends<TParams> = TParams & IMicroserviceResponsePayload;
 

src/services/abstract-microservice.ts

@@ -393,20 +393,16 @@ abstract class AbstractMicroservice {
       logPadding = '  ',
       reqParams = {},
     } = params;
-
+    const requestParams = { ...data };
     const sender = this.options.name;
-    const senderStack = [...(data.payload?.senderStack ?? []), sender];
+
+    _.set(requestParams, 'payload.sender', sender);
+    _.set(requestParams, 'payload.senderStack', [...(data.payload?.senderStack ?? []), sender]);
 
     const request = new MicroserviceRequest({
       ...(shouldGenerateId || reqId ? { id: reqId ?? uuidv4() } : {}),
       method: endpoint.join('.'),
-      params: _.merge(data, {
-        payload: {
-          sender,
-          senderStack,
-          isInternal,
-        },
-      }),
+      params: requestParams,
     });
 
     this.logDriver(

src/services/gateway.ts

@@ -234,6 +234,30 @@ class Gateway extends AbstractMicroservice {
       this.logDriver(() => `End batch request: ${body.length} (${id}).`, LogType.RES_EXTERNAL, id);
     }
 
+    // cookie manipulations
+    (Array.isArray(response) ? response : [response]).forEach((msRes) => {
+      const reqPayload = msRes?.getResult()?.payload;
+      const cookies = reqPayload?.cookies;
+
+      if (Array.isArray(cookies)) {
+        _.unset(reqPayload, 'cookies');
+
+        cookies.forEach((cookie) => {
+          switch (cookie.action) {
+            case 'add':
+              res.cookie(cookie.name, cookie.value, cookie.options ?? {});
+              break;
+            case 'remove':
+              res.clearCookie(cookie.name);
+          }
+        });
+
+        if (reqPayload && Object.keys(reqPayload).length === 0) {
+          _.unset(msRes?.getResult(), 'payload');
+        }
+      }
+    });
+
     res.json(response);
   }
 
@@ -264,11 +288,12 @@ class Gateway extends AbstractMicroservice {
       });
     }
 
-    const request = new MicroserviceRequest(
-      _.merge(body, {
-        params: { payload: { sender: 'client', senderStack: ['client'], isInternal: false } },
-      }),
-    );
+    _.set(body, 'params.payload.sender', 'client');
+    _.set(body, 'params.payload.senderStack', ['client']);
+    _.set(body, 'params.payload.isInternal', false);
+    _.set(body, 'params.payload.headers', headers);
+
+    const request = new MicroserviceRequest(body);
     const [microservice] = request.getMethod().split('.');
     const clientHandler = this.microservices[microservice];