changes to the node ldk to make bi direction communication work with whispers

Author: Jon Bernard

ldk/node/dist/bin/build.js

@@ -12,6 +12,7 @@
   "devDependencies": {
     "@types/jest": "26.0.13",
     "@types/node": "14.10.0",
+    "@types/ramda": "^0.27.34",
     "@typescript-eslint/eslint-plugin": "4.1.0",
     "@typescript-eslint/parser": "4.1.0",
     "eslint": "7.8.1",
@@ -30,6 +31,7 @@
   },
   "dependencies": {
     "@oliveai/ldk": "file:../..",
-    "moment": "^2.29.1"
+    "moment": "^2.29.1",
+    "ramda": "0.27.1"
   }
 }

ldk/node/dist/hostClients/networkClient.js

@@ -1,16 +1,21 @@
-
+import { find, propEq } from 'ramda';
 import moment from "moment";
 
 import { HostServices, Logger, Loop, serveLoop } from '../../../dist';
 import {
   WhisperDisambiguationElements,
-  // WhisperDisambiguationOption,
+  WhisperListStyle,
+  WhisperListAlign,
 } from '../../../dist/hostClients/whisperService';
 
-import {RecallJSON} from './transform'
+import { decodeRecall, Recall, RecallJSON } from './transform'
 
 const logger = new Logger('olive-helps-node-example-network');
 
+export interface RecallMap {
+  [key: string]: Recall
+}
+
 export interface Element {
   [key: string]: WhisperDisambiguationElements
 }
@@ -30,15 +35,18 @@ class ExampleLoop implements Loop {
       method: "GET",
       body: "",
     }).then((response) => {
-      const { results } = JSON.parse(Buffer.from(response.data).toString('utf8'));
+      const { results: jsonResults } = JSON.parse(Buffer.from(response.data).toString('utf8'));
       const itemList = {} as Element;
+      const results = {} as RecallMap;
 
-      results.forEach((resultItem: RecallJSON, index: number) => {
+      jsonResults.forEach((resultItem: RecallJSON, index: number) => {
         itemList[resultItem.recall_number] = {
-          label: `😝${resultItem.recalling_firm} (${resultItem.recall_initiation_date}) jb`,
+          label: `😝${resultItem.recalling_firm} (${resultItem.recall_initiation_date})`,
           order: index + 1,
           type: 'option',
         }
+
+        results[resultItem.recall_number] = decodeRecall(resultItem)
       })
 
       this.host.whisper.disambiguationWhisper({
@@ -48,7 +56,106 @@ class ExampleLoop implements Loop {
       },
       (error, input) => {
         if (input) {
-          logger.info(`Zhu Li Do The Thing With ${input.key}`);
+          const recallItem: Recall = results[input.key];
+
+          logger.info(`Emitting disambiguation whisper with the key ${input.key}`, JSON.stringify(recallItem), JSON.stringify({
+            align: WhisperListAlign.LEFT,
+            body: recallItem.Description,
+            header: recallItem.Firm,
+            order: 0,
+            style: WhisperListStyle.NONE,
+            type: 'message',
+          }));
+
+          if (recallItem) {
+            this.host.whisper.listWhisper({
+              label: 'Latest FDA Food Recall',
+              markdown: '',
+              elements: {
+                topMessage: {
+                  align: WhisperListAlign.LEFT,
+                  body: recallItem.Description,
+                  header: recallItem.Firm,
+                  order: 0,
+                  style: WhisperListStyle.NONE,
+                  type: 'message',
+                },
+                sectionDivider: {
+                  order: 1,
+                  type: 'divider',
+                },
+                reason: {
+                  value: recallItem.Reason,
+                  label: 'Reason',
+                  order: 2,
+                  type: 'pair',
+                },
+                distribution: {
+                  value: recallItem.Distribution,
+                  label: 'Distribution',
+                  order: 3,
+                  type: 'pair',
+                },
+                quantity: {
+                  value: recallItem.Quantity,
+                  label: 'Quantity',
+                  order: 4,
+                  type: 'pair',
+                },
+                codes: {
+                  extra: true,
+                  value: recallItem.Codes,
+                  label: 'Codes',
+                  order: 5,
+                  type: 'pair',
+                },
+                id: {
+                  extra: true,
+                  value: recallItem.ID,
+                  label: 'Recall number',
+                  order: 6,
+                  type: 'pair',
+                },
+                date: {
+                  extra: true,
+                  value: recallItem.Date,
+                  label: 'Date initiated',
+                  order: 7,
+                  type: 'pair',
+                },
+                recallType: {
+                  extra: true,
+                  value: recallItem.RecallType,
+                  label: 'Recall type',
+                  order: 8,
+                  type: 'pair',
+                },
+                type: {
+                  extra: true,
+                  value: recallItem.Type,
+                  label: 'Product type',
+                  order: 9,
+                  type: 'pair',
+                },
+                classification: {
+                  extra: true,
+                  value: recallItem.Classification,
+                  label: 'Classification',
+                  order: 10,
+                  type: 'pair',
+                },
+                address: {
+                  extra: true,
+                  value: `${recallItem.Address1} ${recallItem.Address2 ? `${recallItem.Address2} ` : ''}${recallItem.City}, ${recallItem.State} ${recallItem.Zip} ${recallItem.Country}`,
+                  label: 'Company address',
+                  order: 11,
+                  type: 'pair',
+                },
+              },
+            });
+          } else {
+            logger.info(`Could not find recall with the key ${input.key}`);
+          }
         }
       },
       );

ldk/node/dist/hostClients/networkService.d.ts

@@ -57,7 +57,9 @@ export class NetworkClient
         msg.setUrl(req.url);
         msg.setMethod(req.method);
         msg.setBody(req.body);
-        addHeadersToMessage(msg, req.headers);
+        if (req.headers) {
+          addHeadersToMessage(msg, req.headers);
+        }
         return msg;
       },
       (response: messages.HTTPResponseMsg) => ({

ldk/node/dist/hostClients/whisperClient.js

@@ -3,7 +3,7 @@ export interface HttpRequest {
   method: string;
   body: string | Uint8Array;
 
-  headers: Record<string, Array<string>>;
+  headers?: Record<string, Array<string>>;
 }
 
 export interface HttpResponse {

ldk/node/examples/whisper-disambiguation/package-lock.json

@@ -81,24 +81,32 @@ class WhisperClient
     whisper: WhisperDisambiguationConfig,
     listener: StreamListener<WhisperDisambiguationEvent>,
   ): StoppableStream<WhisperDisambiguationEvent> {
-    const msg = generateWhisperDisambiguation(whisper);
-    const stream = this.client.whisperDisambiguation(msg);
+    const message = generateWhisperDisambiguation(whisper)
+      .setSession(this.createSessionMessage());
     return new TransformingStream<
       messages.WhisperDisambiguationStreamResponse,
       WhisperDisambiguationEvent
-    >(stream, (response) => transformDisambiguationResponse(response), listener);
+    >(
+      this.client.whisperDisambiguation(message),
+      (response) => transformDisambiguationResponse(response), 
+      listener,
+    );
   }
 
   formWhisper(
     whisper: WhisperFormConfig,
     listener: StreamListener<WhisperFormUpdateEvent | WhisperFormSubmitEvent>,
   ): StoppableStream<WhisperFormUpdateEvent | WhisperFormSubmitEvent> {
-    const msg = generateWhisperForm(whisper);
-    const stream = this.client.whisperForm(msg);
+    const message = generateWhisperForm(whisper)
+      .setSession(this.createSessionMessage());
     return new TransformingStream<
       messages.WhisperFormStreamResponse,
       WhisperFormSubmitEvent | WhisperFormUpdateEvent
-    >(stream, (response) => transformResponse(response), listener);
+    >(
+      this.client.whisperForm(message),
+      (response) => transformResponse(response),
+      listener,
+    );
   }
 
   protected generateClient(): GRPCClientConstructor<WhisperGRPCClient> {