Merge pull request #88 from mcode/case-insensitive-lookups

Implements the case insensitive CancerDiseaseStatus lookups

Author: Dtphelan1

src/helpers/diseaseStatusUtils.js

@@ -1,44 +1,20 @@
 const moment = require('moment');
-const { invertObject } = require('./helperUtils');
+const { lowercaseLookupQuery } = require('./lookupUtils');
+const {
+  mcodeDiseaseStatusTextToCodeLookup,
+  icareDiseaseStatusTextToCodeLookup,
+  mcodeDiseaseStatusCodeToTextLookup,
+  icareDiseaseStatusCodeToTextLookup,
+  evidenceTextToCodeLookup,
+  evidenceCodeToTextLookup,
+} = require('./lookups/diseaseStatusLookup');
 
 // Translate an M-language epoch date to an appropriate moment date
 function mEpochToDate(date) {
   const epochDate = moment('1840-12-31');
   return epochDate.add(date, 'days');
 }
 
-// Code mapping is based on current values at http://standardhealthrecord.org/guides/icare/mapping_guidance.html
-const currentDiseaseStatusTextToCodeLookup = {
-  'Not detected (qualifier)': '260415000',
-  'Patient condition improved (finding)': '268910001',
-  'Patient\'s condition stable (finding)': '359746009',
-  'Patient\'s condition worsened (finding)': '271299001',
-  'Patient condition undetermined (finding)': '709137006',
-};
-const currentDiseaseStatusCodeToTextLookup = invertObject(currentDiseaseStatusTextToCodeLookup);
-
-// Code mapping is based on initial values still in use by icare implementors
-// specifically using lowercase versions of the text specified by ICARE for status
-const icareDiseaseStatusTextToCodeLookup = {
-  'no evidence of disease': '260415000',
-  responding: '268910001',
-  stable: '359746009',
-  progressing: '271299001',
-  'not evaluated': '709137006',
-};
-const icareDiseaseStatusCodeToTextLookup = invertObject(icareDiseaseStatusTextToCodeLookup);
-
-// Code mapping is based on http://standardhealthrecord.org/guides/icare/mapping_guidance.html
-// specifically using lowercase versions of the text specified by ICARE for Reason
-const evidenceTextToCodeLookup = {
-  imaging: '363679005',
-  pathology: '252416005',
-  symptoms: '711015009',
-  'physical exam': '5880005',
-  'lab results': '386344002',
-};
-const evidenceCodeToTextLookup = invertObject(evidenceTextToCodeLookup);
-
 /**
  * Converts Text Value to code in mCODE's ConditionStatusTrendVS
  * @param {string} text, limited to 'no evidence of disease', Responding, Stable, Progressing, or 'not evaluated'
@@ -47,9 +23,9 @@ const evidenceCodeToTextLookup = invertObject(evidenceTextToCodeLookup);
 function getDiseaseStatusCode(text, implementation) {
   switch (implementation) {
     case 'icare':
-      return icareDiseaseStatusTextToCodeLookup[text];
+      return lowercaseLookupQuery(text, icareDiseaseStatusTextToCodeLookup);
     default:
-      return currentDiseaseStatusTextToCodeLookup[text];
+      return lowercaseLookupQuery(text, mcodeDiseaseStatusTextToCodeLookup);
   }
 }
 
@@ -61,9 +37,9 @@ function getDiseaseStatusCode(text, implementation) {
 function getDiseaseStatusDisplay(code, implementation) {
   switch (implementation) {
     case 'icare':
-      return icareDiseaseStatusCodeToTextLookup[code];
+      return lowercaseLookupQuery(code, icareDiseaseStatusCodeToTextLookup);
     default:
-      return currentDiseaseStatusCodeToTextLookup[code];
+      return lowercaseLookupQuery(code, mcodeDiseaseStatusCodeToTextLookup);
   }
 }
 
@@ -73,7 +49,7 @@ function getDiseaseStatusDisplay(code, implementation) {
  * @return {string} corresponding Evidence code
  */
 function getDiseaseStatusEvidenceCode(text) {
-  return evidenceTextToCodeLookup[text];
+  return lowercaseLookupQuery(text, evidenceTextToCodeLookup);
 }
 
 /**
@@ -82,7 +58,7 @@ function getDiseaseStatusEvidenceCode(text) {
  * @return {string} corresponding Evidence display text
  */
 function getDiseaseStatusEvidenceDisplay(code) {
-  return evidenceCodeToTextLookup[code];
+  return lowercaseLookupQuery(code, evidenceCodeToTextLookup);
 }
 
 module.exports = {

src/helpers/helperUtils.js

@@ -0,0 +1,47 @@
+/**
+ * Create a lookup table that swaps keys and values s.t. (k->v) becomes (v->k)
+ * @param {Object} lookup - a lookup table, defined by key-value pairs
+ * @return {Object} the lookup table, with all keys and values inverted
+ */
+function createInvertedLookup(lookup) {
+  // NOTE: This will produce collisions if values aren't unique
+  //       and unspecified behavior if values are non-strings
+  return Object.entries(lookup).reduce((ret, entry) => {
+    const [key, value] = entry;
+    // eslint-disable-next-line no-param-reassign
+    ret[value] = key;
+    return ret;
+  }, {});
+}
+
+/**
+ * Create a lookup table where all the keys are lowercased
+ * @param {Object} lookup - a lookup table, defined by key-value pairs
+ * @return {Object} the lookup table, with all keys lowercased
+ */
+function createLowercaseLookup(lookup) {
+  // NOTE: This will produce collisions if keys aren't unique w/r/t case
+  return Object.entries(lookup).reduce((ret, entry) => {
+    const [k, v] = entry;
+    // eslint-disable-next-line no-param-reassign
+    ret[k.toLowerCase()] = v;
+    return ret;
+  }, {});
+}
+
+/**
+ * Performs a lookup using the original key and a lowercase key
+ * @param {String} key - key being queried for in the lookup
+ * @param {Object} lookup - lookup table
+ * @return {any} the value associated with that key
+*/
+function lowercaseLookupQuery(key, lookup) {
+  const lowerKey = key.toLowerCase();
+  return lookup[key] || lookup[lowerKey];
+}
+
+module.exports = {
+  lowercaseLookupQuery,
+  createLowercaseLookup,
+  createInvertedLookup,
+};

src/helpers/lookupUtils.js

@@ -0,0 +1,42 @@
+const { createInvertedLookup, createLowercaseLookup } = require('../lookupUtils');
+
+// Code mapping is based on current values at http://standardhealthrecord.org/guides/icare/mapping_guidance.html
+const mcodeDiseaseStatusTextToCodeLookup = {
+  'Not detected (qualifier)': '260415000',
+  'Patient condition improved (finding)': '268910001',
+  'Patient\'s condition stable (finding)': '359746009',
+  'Patient\'s condition worsened (finding)': '271299001',
+  'Patient condition undetermined (finding)': '709137006',
+};
+const mcodeDiseaseStatusCodeToTextLookup = createInvertedLookup(mcodeDiseaseStatusTextToCodeLookup);
+
+// Code mapping is based on initial values still in use by icare implementors
+// specifically using lowercase versions of the text specified by ICARE for status
+const icareDiseaseStatusTextToCodeLookup = {
+  'no evidence of disease': '260415000',
+  responding: '268910001',
+  stable: '359746009',
+  progressing: '271299001',
+  'not evaluated': '709137006',
+};
+const icareDiseaseStatusCodeToTextLookup = createInvertedLookup(icareDiseaseStatusTextToCodeLookup);
+
+// Code mapping is based on http://standardhealthrecord.org/guides/icare/mapping_guidance.html
+// specifically using lowercase versions of the text specified by ICARE for Reason
+const evidenceTextToCodeLookup = {
+  imaging: '363679005',
+  pathology: '252416005',
+  symptoms: '711015009',
+  'physical exam': '5880005',
+  'lab results': '386344002',
+};
+const evidenceCodeToTextLookup = createInvertedLookup(evidenceTextToCodeLookup);
+
+module.exports = {
+  mcodeDiseaseStatusTextToCodeLookup: createLowercaseLookup(mcodeDiseaseStatusTextToCodeLookup),
+  mcodeDiseaseStatusCodeToTextLookup: createLowercaseLookup(mcodeDiseaseStatusCodeToTextLookup),
+  icareDiseaseStatusTextToCodeLookup: createLowercaseLookup(icareDiseaseStatusTextToCodeLookup),
+  icareDiseaseStatusCodeToTextLookup: createLowercaseLookup(icareDiseaseStatusCodeToTextLookup),
+  evidenceTextToCodeLookup: createLowercaseLookup(evidenceTextToCodeLookup),
+  evidenceCodeToTextLookup: createLowercaseLookup(evidenceCodeToTextLookup),
+};

src/helpers/lookups/diseaseStatusLookup.js

@@ -64,6 +64,7 @@ const {
 } = require('./helpers/conditionUtils');
 const { getDiseaseStatusCode, getDiseaseStatusEvidenceCode, mEpochToDate } = require('./helpers/diseaseStatusUtils');
 const { formatDate, formatDateTime } = require('./helpers/dateUtils');
+const { lowercaseLookupQuery, createLowercaseLookup, createInvertedLookup } = require('./helpers/lookupUtils');
 const { getConditionEntriesFromContext, getConditionsFromContext, getEncountersFromContext, getPatientFromContext } = require('./helpers/contextUtils');
 
 module.exports = {
@@ -106,6 +107,8 @@ module.exports = {
   MCODEClient,
   // FHIR and resource helpers
   allResourcesInBundle,
+  createLowercaseLookup,
+  createInvertedLookup,
   firstEntryInBundle,
   firstIdentifierEntry,
   firstResourceInBundle,
@@ -131,6 +134,7 @@ module.exports = {
   isConditionCodeCancer,
   isConditionCancer,
   logOperationOutcomeInfo,
+  lowercaseLookupQuery,
   mEpochToDate,
   // Context operations
   getConditionEntriesFromContext,

src/index.js

@@ -0,0 +1,96 @@
+const { createLowercaseLookup, createInvertedLookup, lowercaseLookupQuery } = require('../../src/helpers/lookupUtils');
+
+describe('lookupUtils', () => {
+  describe('createLowercaseLookup', () => {
+    const exampleLookup = {
+      foo: 'bar',
+      'apples AND': 'oranges',
+      AI: 'ethics',
+    };
+    const lowercaseLookup = createLowercaseLookup(exampleLookup);
+
+    test('should fail if supplied an undefined or null value', () => {
+      expect(() => createInvertedLookup()).toThrow();
+      expect(() => createInvertedLookup(undefined)).toThrow();
+      expect(() => createInvertedLookup(null)).toThrow();
+    });
+
+    test('all new keys should match the lowercased original keys', () => {
+      const lowercasedExampleKeys = Object.keys(exampleLookup).map((k) => k.toLowerCase());
+      expect(Object.keys(lowercaseLookup)).toEqual(lowercasedExampleKeys);
+    });
+
+    test('given a lookup with unique keys, values should remain unchanged after lowercasing', () => {
+      const originalValues = Object.values(exampleLookup);
+      expect(Object.values(lowercaseLookup)).toEqual(originalValues);
+    });
+
+    test('given a lookup with unique keys, # of keys should stay the same', () => {
+      expect(Object.keys(lowercaseLookup).length).toEqual(Object.keys(exampleLookup).length);
+    });
+  });
+
+  describe('createInvertedLookup', () => {
+    const exampleLookup = {
+      foo: 'bar',
+      'apples AND': 'oranges',
+      AI: 'ethics',
+    };
+    const invertedLookup = createInvertedLookup(exampleLookup);
+
+    test('should fail if supplied a non-object', () => {
+      expect(() => createInvertedLookup()).toThrow();
+      expect(() => createInvertedLookup(undefined)).toThrow();
+      expect(() => createInvertedLookup(null)).toThrow();
+    });
+
+    test('all old values should be keys after inversion', () => {
+      expect(Object.keys(invertedLookup)).toEqual(expect.arrayContaining(Object.values(exampleLookup)));
+    });
+
+    test('all old keys should be values after inversion', () => {
+      expect(Object.values(invertedLookup)).toEqual(expect.arrayContaining(Object.keys(exampleLookup)));
+    });
+
+    test('given a lookup with unique values, # of new keys should match the # of values in the old object', () => {
+      expect(Object.keys(invertedLookup).length).toEqual(Object.values(exampleLookup).length);
+    });
+
+    test('given a lookup with unique values, # of new values should match the # of keys in the old object', () => {
+      expect(Object.values(invertedLookup).length).toEqual(Object.keys(exampleLookup).length);
+    });
+  });
+
+  describe('lowercaseLookupQuery', () => {
+    const exampleLookup = {
+      foo: 'bar',
+      'apples AND': 'oranges',
+      AI: 'ethics',
+    };
+    // Create a lowercased lookup as this is
+    const lowercaseLookup = createLowercaseLookup(exampleLookup);
+    const originalCaseKeys = Object.keys(exampleLookup);
+    const lowercaseKeys = Object.keys(exampleLookup).map((k) => k.toLowerCase());
+    const uppercaseKeys = Object.keys(exampleLookup).map((k) => k.toUpperCase());
+
+    test('lookup should return undefined when the value provided is not defined in the lookup', () => {
+      expect(lowercaseLookupQuery('', lowercaseLookup)).toEqual(undefined);
+    });
+
+    test('lookup should work for the lowercased keys', () => {
+      lowercaseKeys.forEach((lowercaseKey) => {
+        expect(lowercaseLookupQuery(lowercaseKey, lowercaseLookup)).toEqual(lowercaseLookup[lowercaseKey]);
+      });
+    });
+    test('lookup should work for the originalcase keys', () => {
+      originalCaseKeys.forEach((originalCaseKey) => {
+        expect(lowercaseLookupQuery(originalCaseKey, lowercaseLookup)).toEqual(lowercaseLookup[originalCaseKey.toLowerCase()]);
+      });
+    });
+    test('lookup should work for the uppercased keys', () => {
+      uppercaseKeys.forEach((uppercaseKey) => {
+        expect(lowercaseLookupQuery(uppercaseKey, lowercaseLookup)).toEqual(lowercaseLookup[uppercaseKey.toLowerCase()]);
+      });
+    });
+  });
+});