AC - cleaned up code

index.js

@@ -8,6 +8,9 @@ import markAsRead from "./src/put/mark_as_read.js";
 import sendMessage from "./src/post/send_message.js";
 import sendMessageChunks from "./src/post/send_message_chunks.js";
 
+let logLevel = process.env.LOG_LEVEL || "DEBUG";
+log.setLevel(log.levels[logLevel]);
+
 // defaults to the local url for the sandbox environment, defaults for sandbox
 let url = process.env.MESH_URL || "https://localhost:8700";
 
@@ -19,9 +22,8 @@ let sharedKey = process.env.MESH_SHARED_KEY || "TestKey";
 let sandbox = process.env.MESH_SANDBOX || "true";
 let senderAgent;
 let receiverAgent;
-
 if (sandbox === "true") {
-  log.info("Running in sandbox mode");
+  console.log("Running in sandbox mode");
   // just setup to ignore self-signed certs
   senderAgent = new Agent({
     rejectUnauthorized: false,
@@ -31,7 +33,7 @@ if (sandbox === "true") {
     rejectUnauthorized: false,
   });
 } else {
-  log.info("Running in integration mode");
+  console.log("Running in integration mode");
   // Setup the https agents for integration, you can ignore this for sandbox
   senderAgent = new Agent({
     cert: readFileSync(process.env.MESH_SENDER_CERT_LOCATION),
@@ -45,9 +47,6 @@ if (sandbox === "true") {
   });
 }
 
-let logLevel = process.env.LOG_LEVEL || "INFO";
-log.setLevel(log.levels[logLevel]);
-
 // The 'sender' is the mailbox we will be sending the message from, defaults to sandbox
 let senderMailboxID = process.env.MESH_SENDER_MAILBOX_ID || "X26ABC1";
 let senderMailboxPassword =
@@ -89,6 +88,7 @@ async function createMessages() {
     mailboxPassword: senderMailboxPassword,
     message: messageContent,
     mailboxTarget: receiverMailboxID,
+    sharedKey: sharedKey,
     agent: senderAgent,
   });
   log.debug("New message created with an ID: " + newMessage.data["message_id"]);
@@ -112,6 +112,7 @@ async function createMessageChunks() {
     mailboxPassword: senderMailboxPassword,
     mailboxTarget: receiverMailboxID,
     messageFile: messageFile,
+    sharedKey: sharedKey,
     agent: senderAgent,
   });
 }
@@ -196,9 +197,9 @@ async function receiveMessage() {
       log.debug("clearing the message from the mailbox");
       await markAsRead({
         url: url,
-        mailbox_id: receiverMailboxID,
-        mailbox_password: receiverMailboxPassword,
-        shared_key: sharedKey,
+        mailboxID: receiverMailboxID,
+        mailboxPassword: receiverMailboxPassword,
+        sharedKey: sharedKey,
         message: message,
         agent: receiverAgent,
       });

src/get/generate_headers.js

@@ -2,32 +2,36 @@ import crypto from "crypto";
 import { v4 as uuid } from "uuid";
 
 // Generates the token, this will be generated fresh for each call, as required by MESH
-async function generateToken(
+async function generateToken({
   mailboxID,
-  password,
+  mailboxPassword,
   sharedKey,
   nonce = uuid(),
-  nonceCount = 0
-) {
+  nonceCount = 0,
+}) {
   // Make sure to leave a space at the end of the schema.
-  const auth_schema_name = "NHSMESH ";
-  const timestamp = new Date()
+  let auth_schema_name = "NHSMESH ";
+  let timestamp = new Date()
     .toISOString()
     .replace(/[-:.TZ]/g, "")
     .slice(0, 12);
-  const hmac_msg = `${mailboxID}:${nonce}:${nonceCount}:${password}:${timestamp}`;
+  let hmac_msg = `${mailboxID}:${nonce}:${nonceCount}:${mailboxPassword}:${timestamp}`;
 
-  const hmac = crypto
+  let hmac = crypto
     .createHmac("sha256", sharedKey)
     .update(hmac_msg)
     .digest("hex");
 
   return `${auth_schema_name}${mailboxID}:${nonce}:${nonceCount}:${timestamp}:${hmac}`;
 }
 
-async function generateHeaders(mailboxID, mailboxPassword, sharedKey) {
-  const token = await generateToken(mailboxID, mailboxPassword, sharedKey);
-  const header = {
+async function generateHeaders({ mailboxID, mailboxPassword, sharedKey }) {
+  let token = await generateToken({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    sharedKey: sharedKey,
+  });
+  let header = {
     accept: "application/vnd.mesh.v2+json",
     authorization: token,
     "mex-clientversion": "ApiDocs==0.0.1",

src/get/handshake.js

@@ -9,15 +9,19 @@ async function handShake({
   sharedKey,
   agent,
 }) {
-  const full_url = `${url}/messageexchange/${mailboxID}`;
-  const headers = await generateHeaders(mailboxID, mailboxPassword, sharedKey);
+  let full_url = `${url}/messageexchange/${mailboxID}`;
+  let headers = await generateHeaders({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    sharedKey: sharedKey,
+  });
 
   let config = { headers: headers };
   // attach agent to headers
   config.httpsAgent = agent;
-  // const response = await axios.get(full_url, config);
+  // let response = await axios.get(full_url, config);
   try {
-    const response = await axios.get(full_url, config);
+    let response = await axios.get(full_url, config);
     if (response.status === 200) {
       log.info(`Handshake successful, status ${response.status}\n`);
       return response;

src/get/message_count.js

@@ -10,7 +10,11 @@ async function getMessageCount({
   agent,
 }) {
   let fullUrl = `${url}/messageexchange/${mailboxID}/inbox`;
-  let headers = await generateHeaders(mailboxID, mailboxPassword, sharedKey);
+  let headers = await generateHeaders({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    sharedKey: sharedKey,
+  });
 
   let config = { headers: headers };
   // attach agent to headers

src/get/read_message.js

@@ -20,7 +20,11 @@ async function readMessage({
   }
   let chunkedMessage = "";
   let fullUrl = `${url}/messageexchange/${mailboxID}/inbox/${messageID}`;
-  let headers = await generateHeaders(mailboxID, mailboxPassword, sharedKey);
+  let headers = await generateHeaders({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    sharedKey: sharedKey,
+  });
 
   let config = { headers: headers };
   // attach agent to headers
@@ -41,11 +45,11 @@ async function readMessage({
         let [currentChunk, totalChunks] = chunkRange.split(":").map(Number);
         log.debug(`chunk ${currentChunk} of ${totalChunks} downloaded`);
         if (currentChunk < totalChunks) {
-          let headers = await generateHeaders(
-            mailboxID,
-            mailboxPassword,
-            sharedKey
-          );
+          let headers = await generateHeaders({
+            mailboxID: mailboxID,
+            mailboxPassword: mailboxPassword,
+            sharedKey: sharedKey,
+          });
 
           let config = { headers: headers };
           // attach agent to headers

src/post/generate_headers.js

@@ -2,34 +2,41 @@ import crypto from "crypto";
 import { v4 as uuid } from "uuid";
 
 // Generates the token, this will be generated fresh for each call, as required by MESH
-async function generateToken(
+async function generateToken({
   mailboxID,
   mailboxPassword,
+  sharedKey,
   nonce = uuid(),
-  nonce_count = 0
-) {
-  //   Make sure the mesh shared key is set as an environmental var
-  const mesh_shared_key = process.env.MESH_SHARED_KEY;
-
+  nonce_count = 0,
+}) {
   // Make sure to leave a space at the end of the schema.
-  const auth_schema_name = "NHSMESH ";
-  const timestamp = new Date()
+  let auth_schema_name = "NHSMESH ";
+  let timestamp = new Date()
     .toISOString()
     .replace(/[-:.TZ]/g, "")
     .slice(0, 12);
-  const hmac_msg = `${mailboxID}:${nonce}:${nonce_count}:${mailboxPassword}:${timestamp}`;
+  let hmac_msg = `${mailboxID}:${nonce}:${nonce_count}:${mailboxPassword}:${timestamp}`;
 
-  const hmac = crypto
-    .createHmac("sha256", mesh_shared_key)
+  let hmac = crypto
+    .createHmac("sha256", sharedKey)
     .update(hmac_msg)
     .digest("hex");
 
   return `${auth_schema_name}${mailboxID}:${nonce}:${nonce_count}:${timestamp}:${hmac}`;
 }
 
-async function generateHeaders(mailboxID, mailboxPassword, mailboxTarget) {
-  const token = await generateToken(mailboxID, mailboxPassword);
-  const header = {
+async function generateHeaders({
+  mailboxID,
+  mailboxPassword,
+  mailboxTarget,
+  sharedKey,
+}) {
+  let token = await generateToken({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    sharedKey: sharedKey,
+  });
+  let header = {
     accept: "application/vnd.mesh.v2+json",
     authorization: token,
     "content-type": "application/octet-stream",

src/post/send_message.js

@@ -6,16 +6,18 @@ async function sendMessage({
   url,
   mailboxID,
   mailboxPassword,
+  sharedKey,
   message,
   mailboxTarget,
   agent,
 }) {
   const fullUrl = `${url}/messageexchange/${mailboxID}/outbox`;
-  const headers = await generateHeaders(
-    mailboxID,
-    mailboxPassword,
-    mailboxTarget
-  );
+  const headers = await generateHeaders({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    mailboxTarget: mailboxTarget,
+    sharedKey: sharedKey,
+  });
 
   let config = { headers: headers };
   // attach agent to headers

src/post/send_message_chunks.js

@@ -80,6 +80,7 @@ async function sendMessageChunks({
   mailboxID,
   mailboxPassword,
   mailboxTarget,
+  sharedKey,
   messageFile,
   agent,
 }) {
@@ -105,11 +106,12 @@ async function sendMessageChunks({
       fullUrl = `${url}/messageexchange/${mailboxID}/outbox`;
     }
 
-    let headers = await generateHeaders(
-      mailboxID,
-      mailboxPassword,
-      mailboxTarget
-    );
+    let headers = await generateHeaders({
+      mailboxID: mailboxID,
+      mailboxPassword: mailboxPassword,
+      mailboxTarget: mailboxTarget,
+      sharedKey: sharedKey,
+    });
     headers["mex-chunk-range"] = `${chunk}:${fileCount}`;
     headers["content-encoding"] = "gzip";
 

src/put/generate_headers.js

@@ -2,31 +2,35 @@ import crypto from "crypto";
 import { v4 as uuid } from "uuid";
 
 // Generates the token, this will be generated fresh for each call, as required by MESH
-async function generateToken(
-  mailbox_id,
-  password,
-  shared_key,
+async function generateToken({
+  mailboxID,
+  mailboxPassword,
+  sharedKey,
   nonce = uuid(),
-  nonce_count = 0
-) {
+  nonce_count = 0,
+}) {
   // Make sure to leave a space at the end of the schema.
   const auth_schema_name = "NHSMESH ";
   const timestamp = new Date()
     .toISOString()
     .replace(/[-:.TZ]/g, "")
     .slice(0, 12);
-  const hmac_msg = `${mailbox_id}:${nonce}:${nonce_count}:${password}:${timestamp}`;
+  const hmac_msg = `${mailboxID}:${nonce}:${nonce_count}:${mailboxPassword}:${timestamp}`;
 
   const hmac = crypto
-    .createHmac("sha256", shared_key)
+    .createHmac("sha256", sharedKey)
     .update(hmac_msg)
     .digest("hex");
 
-  return `${auth_schema_name}${mailbox_id}:${nonce}:${nonce_count}:${timestamp}:${hmac}`;
+  return `${auth_schema_name}${mailboxID}:${nonce}:${nonce_count}:${timestamp}:${hmac}`;
 }
 
-async function generateHeaders(mailbox_id, mailbox_password, shared_key) {
-  const token = await generateToken(mailbox_id, mailbox_password, shared_key);
+async function generateHeaders({ mailboxID, mailboxPassword, sharedKey }) {
+  const token = await generateToken({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    sharedKey: sharedKey,
+  });
   const header = {
     accept: "application/vnd.mesh.v2+json",
     authorization: token,

src/put/mark_as_read.js

@@ -6,14 +6,18 @@ import generateHeaders from "./generate_headers.js";
 
 async function markAsRead({
   url,
-  mailbox_id,
-  mailbox_password,
-  shared_key,
+  mailboxID,
+  mailboxPassword,
+  sharedKey,
   message,
   agent,
 }) {
-  let full_url = `${url}/messageexchange/${mailbox_id}/inbox/${message}/status/acknowledged`;
-  let headers = await generateHeaders(mailbox_id, mailbox_password, shared_key);
+  let full_url = `${url}/messageexchange/${mailboxID}/inbox/${message}/status/acknowledged`;
+  let headers = await generateHeaders({
+    mailboxID: mailboxID,
+    mailboxPassword: mailboxPassword,
+    sharedKey: sharedKey,
+  });
 
   let config = { headers: headers };
   // attach agent to headers