pass http headers in subject message header

github1 · github1 · commit 186a90028c80 · 2020-08-21T14:58:50.000-04:00
diff --git a/src/backends/http/http-support.test.ts b/src/backends/http/http-support.test.ts
@@ -1,3 +1,5 @@
+// tslint:disable:no-any
+
 import {
   mesh,
   Mesh,
@@ -29,37 +31,56 @@ describe('http-support', () => {
   it('can send messages over http', async () => {
     await p1.subject('test-sub-2')
       // tslint:disable-next-line:no-any
-      .on('test-http', (msg : any) => {
-        return {echo: msg};
+      .on('test-http', (msg : any, header : SubjectMessageHeader) => {
+        return {
+          echo: {
+            msg,
+            header
+          }
+        };
       })
       .awaitRegistration();
-    const res : Response = await fetch(`http://localhost:${port}/api/test-sub-2/123`,
-      {
-        headers: {
-          'content-type': 'application/json'
-        },
-        method: 'post',
-        body: JSON.stringify({name: 'test-http'})
-      });
+    const res : Response = await sendHttp(`${port}/api/test-sub-2/123`, {name: 'test-http'});
+    expect(res.status)
+      .toBe(200);
     const resJson = await res.json();
-    expect(resJson.echo.name)
+    expect(resJson.echo.msg.name)
+      .toBe('test-http');
+    expect(resJson.echo.header.http.headers['content-type'])
+      .toBe('application/json');
+    const resDirect : any = await p1.subject('test-sub-2')
+      .send({name:'test-http'});
+    expect(resDirect.echo.msg.name)
       .toBe('test-http');
   });
+  it('can set the http response status in the handler', async () => {
+    await p1.subject('test-sub-2')
+      // tslint:disable-next-line:no-any
+      .on('test-http', () => {
+        return {
+          http: {
+            status: 202,
+            headers: {
+              'x-something': 'foo'
+            }
+          }
+        };
+      })
+      .awaitRegistration();
+    const res : Response = await sendHttp(`${port}/api/test-sub-2/123`, {name: 'test-http'});
+    expect(res.status)
+      .toBe(202);
+    expect(res.headers.get('x-something'))
+      .toBe('foo');
+  });
   it('returns status 404 if there are no handlers', async () => {
     await p1.subject('test-sub-2')
       // tslint:disable-next-line:no-any
       .on('test-http', (msg : any) => {
         return {echo: msg};
       })
       .awaitRegistration();
-    let res : Response = await fetch(`http://localhost:${port}/api/no-sub/123`,
-      {
-        headers: {
-          'content-type': 'application/json'
-        },
-        method: 'post',
-        body: JSON.stringify({name: 'test-http'})
-      });
+    let res : Response = await sendHttp(`${port}/api/no-sub/123`, {name: 'test-http'});
     expect(res.status)
       .toBe(404);
     res = await fetch(`http://localhost:${port}/api/broadcast/no-sub`,
@@ -80,14 +101,7 @@ describe('http-support', () => {
         return {echo: msg};
       })
       .awaitRegistration();
-    const res : Response = await fetch(`http://localhost:${port}/api/test-sub-2/123?messageName=test-http`,
-      {
-        headers: {
-          'content-type': 'application/json'
-        },
-        method: 'post',
-        body: '{}'
-      });
+    const res : Response = await sendHttp(`${port}/api/test-sub-2/123?messageName=test-http`, {});
     const resJson = await res.json();
     expect(resJson.echo.name)
       .toBe('test-http');
@@ -99,14 +113,7 @@ describe('http-support', () => {
         return {echo: msg};
       })
       .awaitRegistration();
-    const res : Response = await fetch(`http://localhost:${port}/api/broadcast/test-sub-2?messageName=test-http`,
-      {
-        headers: {
-          'content-type': 'application/json'
-        },
-        method: 'post',
-        body: '{}'
-      });
+    const res : Response = await sendHttp(`${port}/api/broadcast/test-sub-2?messageName=test-http`, {});
     const resJson = await res.json();
     expect(resJson.length)
       .toBe(1);
@@ -120,14 +127,7 @@ describe('http-support', () => {
         return {echo: msg};
       })
       .awaitRegistration();
-    const res : Response = await fetch(`http://localhost:${port}/api/broadcast/test-sub-2?messageName=test-http&wait=false`,
-      {
-        headers: {
-          'content-type': 'application/json'
-        },
-        method: 'post',
-        body: '{}'
-      });
+    const res : Response = await sendHttp(`${port}/api/broadcast/test-sub-2?messageName=test-http&wait=false`, {});
     const resJson = await res.json();
     expect(resJson.length)
       .toBe(0);
@@ -141,14 +141,10 @@ describe('http-support', () => {
         return {name: header.name, pk: header.partitionKey};
       })
       .awaitRegistration();
-    const res : Response = await fetch(`http://localhost:${port}/api/test-sub-2/{body.key}-123?messageName={body.something}`,
-      {
-        headers: {
-          'content-type': 'application/json'
-        },
-        method: 'post',
-        body: JSON.stringify({key: 'abc', something: 'some-val'})
-      });
+    const res : Response = await sendHttp(`${port}/api/test-sub-2/{body.key}-123?messageName={body.something}`, {
+      key: 'abc',
+      something: 'some-val'
+    });
     const resJson = await res.json();
     expect(resJson.name)
       .toBe('some-val');
@@ -162,15 +158,19 @@ describe('http-support', () => {
         return {echo: msg};
       })
       .awaitRegistration();
-    const res : Response = await fetch(`http://localhost:${port}/api/test-sub-2/123`,
-      {
-        headers: {
-          'content-type': 'application/json'
-        },
-        method: 'post',
-        body: '{}'
-      });
+    const res : Response = await sendHttp(`${port}/api/test-sub-2/123`, {});
     expect(res.status)
       .toBe(400);
   });
 });
+
+function sendHttp(path : string, body : any) {
+  return fetch(`http://localhost:${path}`,
+    {
+      headers: {
+        'content-type': 'application/json'
+      },
+      method: 'post',
+      body: JSON.stringify(body)
+    });
+}
diff --git a/src/backends/http/http-support.ts b/src/backends/http/http-support.ts
@@ -1,10 +1,11 @@
 import {
-  HttpMessage,
+  HttpMessageHeader,
   MeshBackend,
   MeshBackendBase,
   MeshBackendProvider,
   MeshBackendProvision,
   MeshVoidResponse,
+  SubjectMessage,
   SubjectMessageEnvelope,
   SubjectMessageOptions,
   toMeshBackendProvision
@@ -19,6 +20,11 @@ import * as normalizeUrl from 'normalize-url';
 const log : debug.Debugger = debug('meshage')
   .extend('http');
 
+interface PreparedHttpMessage {
+  message: SubjectMessage;
+  headerData: HttpMessageHeader;
+}
+
 class HttpMeshBackend extends MeshBackendBase {
 
   private app : express.Express;
@@ -43,7 +49,7 @@ class HttpMeshBackend extends MeshBackendBase {
       }, {});
   }
 
-  private static prepareHttpMessage<T>(req : express.Request) : HttpMessage<T> {
+  private static prepareHttpMessage<T>(req : express.Request) : PreparedHttpMessage {
     // tslint:disable-next-line:no-any
     let reqUrl : string;
     if (process.env.PUBLIC_URL) {
@@ -65,9 +71,8 @@ class HttpMeshBackend extends MeshBackendBase {
     // tslint:disable-next-line:no-unsafe-any
     const messageName : string = query.messageName ? `${query.messageName}` : req.body.name;
     return {
-      name: messageName,
-      payload: {...req.body},
-      http: {
+      message: {...req.body, name: messageName},
+      headerData: {
         headers: req.headers,
         url: req.url,
         publicUrl: reqUrl,
@@ -90,7 +95,7 @@ class HttpMeshBackend extends MeshBackendBase {
         status = resultToSend.http.status;
       }
       // tslint:disable-next-line:no-unsafe-any
-      if (resultToSend.http.header) {
+      if (resultToSend.http.headers) {
         // tslint:disable-next-line:no-unsafe-any
         res.set(resultToSend.http.headers);
       }
@@ -156,17 +161,18 @@ class HttpMeshBackend extends MeshBackendBase {
       this.app.post('/api/broadcast/:subject',
         async (req : express.Request, res : express.Response) => {
           try {
-            const httpMessage = HttpMeshBackend.prepareHttpMessage(req);
-            if (!httpMessage.name) {
+            const httpMessage : PreparedHttpMessage = HttpMeshBackend.prepareHttpMessage(req);
+            if (!httpMessage.message.name) {
               res.status(400)
                 .send({error: 'Missing message name'});
             } else {
-              const result = await this.send(httpMessage.http.params.subject,
+              const result = await this.send(httpMessage.headerData.params.subject,
                 undefined,
-                httpMessage,
+                httpMessage.message,
                 {
                   wait: req.query.wait === 'true' || req.query.wait === undefined,
-                  timeout: req.query.timeout === undefined ? undefined : parseInt(`${req.query.timeout}`, 10)
+                  timeout: req.query.timeout === undefined ? undefined : parseInt(`${req.query.timeout}`, 10),
+                  additionalHeaderData: {http: httpMessage.headerData}
                 }, true);
               HttpMeshBackend.prepareHttpResponse(result, res);
             }
@@ -178,19 +184,20 @@ class HttpMeshBackend extends MeshBackendBase {
       this.app.post('/api/:subject/:partitionKey?',
         async (req : express.Request, res : express.Response) => {
           try {
-            const httpMessage = HttpMeshBackend.prepareHttpMessage(req);
-            if (!httpMessage.name) {
+            const httpMessage : PreparedHttpMessage = HttpMeshBackend.prepareHttpMessage(req);
+            if (!httpMessage.message.name) {
               res.status(400)
                 .send({error: 'Missing message name'});
             } else {
               const result = await this.send(
-                httpMessage.http.params.subject,
-                httpMessage.http.params.partitionKey,
-                httpMessage,
+                httpMessage.headerData.params.subject,
+                httpMessage.headerData.params.partitionKey,
+                httpMessage.message,
                 {
                   wait: req.query.wait === 'true' || req.query.wait === undefined,
                   timeout: req.query.timeout === undefined ? undefined : parseInt(`${req.query.timeout}`, 10),
-                  keepSignals: true
+                  keepSignals: true,
+                  additionalHeaderData: {http: httpMessage.headerData}
                 },
                 false);
               HttpMeshBackend.prepareHttpResponse(result, res);
diff --git a/src/mesh.ts b/src/mesh.ts
@@ -329,7 +329,10 @@ export abstract class MeshBackendBase implements MeshBackend {
                        message : SubjectMessage,
                        options : SubjectMessageOptions,
                        broadcast : boolean) : Promise<T> {
+    // tslint:disable-next-line:no-parameter-reassignment
+    options = options || {};
     const messageHeader : SubjectMessageHeader = {
+      ...options.additionalHeaderData,
       uid: v4(),
       subject,
       // tslint:disable-next-line:no-unsafe-any
diff --git a/src/messages.ts b/src/messages.ts
@@ -1,6 +1,14 @@
 // tslint:disable-next-line:no-any
 export type ConstructorOf<T> = new (...args: any[]) => T;
 
+export interface HttpMessageHeader {
+  headers : { [key : string] : string | string[] | undefined };
+  url : string;
+  publicUrl : string;
+  params : { [key : string] : string };
+  query : { [key : string] : string };
+}
+
 // tslint:disable-next-line:no-any
 export interface SubjectMessage {
   // tslint:disable-next-line:no-any
@@ -11,13 +19,16 @@ export interface SubjectMessageOptions {
   timeout?: number;
   wait?: boolean;
   keepSignals?: boolean;
+  // tslint:disable-next-line:no-any
+  additionalHeaderData?: any;
 }
 
 export interface SubjectMessageHeader {
   uid: string;
   subject: string;
   name: string;
   partitionKey?: string;
+  http?: HttpMessageHeader;
 }
 
 export interface SubjectMessageEnvelope {
@@ -27,17 +38,3 @@ export interface SubjectMessageEnvelope {
 
 // tslint:disable-next-line:no-any
 export type SubjectMessageHandler<T> = (data? : T, header? : SubjectMessageHeader) => any;
-
-export interface HttpMessageHeader {
-  headers : { [key : string] : string | string[] | undefined };
-  url : string;
-  publicUrl : string;
-  params : { [key : string] : string };
-  query : { [key : string] : string };
-}
-
-export interface HttpMessage<T> {
-  name : string;
-  payload : T;
-  http : HttpMessageHeader;
-}
