Merge pull request #129 from mcode/extractor-dependencies

Adding implementation of extractor dependencies

Author: dmendelowitz

src/client/MCODEClient.js

@@ -22,6 +22,7 @@ const {
   FHIRPatientExtractor,
   FHIRProcedureExtractor,
 } = require('../extractors');
+const { sortExtractors } = require('../helpers/dependencyUtils.js');
 
 class MCODEClient extends BaseClient {
   constructor({ extractors, commonExtractorArgs, webServiceAuthConfig }) {
@@ -51,6 +52,21 @@ class MCODEClient extends BaseClient {
     );
     // Store the extractors defined by the configuration file as local state
     this.extractorConfig = extractors;
+    // Define information about the order and dependencies of extractors
+    const dependencyInfo = [
+      { type: 'CSVPatientExtractor', dependencies: [] },
+      { type: 'CSVConditionExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVCancerDiseaseStatusExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVClinicalTrialInformationExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVTreatmentPlanChangeExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVStagingExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVCancerRelatedMedicationExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVProcedureExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVObservationExtractor', dependencies: ['CSVPatientExtractor'] },
+      { type: 'CSVAdverseEventExtractor', dependencies: ['CSVPatientExtractor'] },
+    ];
+    // Sort extractors based on order and dependencies
+    this.extractorConfig = sortExtractors(this.extractorConfig, dependencyInfo);
     // Store webServiceAuthConfig if provided`
     this.authConfig = webServiceAuthConfig;
     this.commonExtractorArgs = {

src/helpers/dependencyUtils.js

@@ -0,0 +1,47 @@
+const logger = require('./logger');
+
+/**
+ * Checks if any dependencies of extractors are missing.
+ * If no depedencies are missing, sorts extractors into the correct order.
+ * @param {Array} extractors array of extractors from the config file
+ * @param {Array} dependencyInfo array of objects dictacting order of extractors and their dependencies
+ * @returns {Array} array of extractors sorted into the order defined in dependency info
+ * Example of dependencyInfo:
+ * [
+ *  { type: 'CSVPatientExtractor', dependencies: [] },
+ *  { type: 'CSVConditionExtractor', dependencies: ['CSVPatientExtractor'] },
+ *  ...
+ * ]
+ */
+function sortExtractors(extractors, dependencyInfo) {
+  const missing = {};
+  // Filter dependency info to only extractors in the config
+  dependencyInfo.filter((e) => extractors.map((x) => x.type).includes(e.type)).forEach((extractor) => {
+    // For each extractor, check if its dependencies are present
+    extractor.dependencies.forEach((dependency) => {
+      if (extractors.filter((e) => e.type === dependency).length === 0) {
+        if (missing[dependency] === undefined) {
+          missing[dependency] = [extractor.type];
+        } else {
+          missing[dependency].push(extractor.type);
+        }
+      }
+    });
+  });
+  // If extractors are missing, alert user which are missing
+  if (Object.keys(missing).length > 0) {
+    Object.keys(missing).forEach((extractor) => {
+      logger.error(`Missing dependency: ${extractor} (required by: ${missing[extractor].join(', ')})`);
+    });
+    throw new Error('Some extractors are missing dependencies, see above for details.');
+  }
+  // If no missing dependencies, sort extractors into correct order
+  const sortedExtractors = [...extractors];
+  const order = dependencyInfo.map((x) => x.type);
+  sortedExtractors.sort((a, b) => order.indexOf(a.type) - order.indexOf(b.type));
+  return sortedExtractors;
+}
+
+module.exports = {
+  sortExtractors,
+};

test/cli/mcodeExtraction.test.js

@@ -92,6 +92,13 @@ describe('mcodeExtraction', () => {
               filePath: path.join(__dirname, './fixtures/example-clinical-trial-info.csv'),
             },
           },
+          {
+            label: 'patient',
+            type: 'CSVPatientExtractor',
+            constructorArgs: {
+              filePath: path.join(__dirname, './fixtures/example-patient.csv'),
+            },
+          },
         ],
       };
 
@@ -105,5 +112,21 @@ describe('mcodeExtraction', () => {
       const flatErrors = flattenErrorValues(totalExtractionErrors);
       expect(flatErrors).toHaveLength(3);
     });
+    it('should throw error when initialized with missing dependencies', async () => {
+      const testConfig = {
+        extractors: [
+          // Should fail when this extractor is run without patient in config becuase patient is required dependency
+          {
+            label: 'CTI',
+            type: 'CSVClinicalTrialInformationExtractor',
+            constructorArgs: {
+              filePath: path.join(__dirname, './fixtures/example-clinical-trial-info.csv'),
+            },
+          },
+        ],
+      };
+
+      expect(() => new MCODEClient(testConfig)).toThrow();
+    });
   });
 });

test/helpers/dependencyUtils.test.js

@@ -0,0 +1,42 @@
+const { sortExtractors } = require('../../src/helpers/dependencyUtils.js');
+
+const WRONG_ORDER = [
+  { type: 'Extractor3' },
+  { type: 'Extractor1' },
+  { type: 'Extractor2' },
+];
+
+const MISSING = [
+  { type: 'Extractor1' },
+  { type: 'Extractor3' },
+];
+
+const NO_CHANGE = [
+  { type: 'Extractor1' },
+  { type: 'Extractor2' },
+  { type: 'Extractor3' },
+];
+
+const DEPENDENCY_INFO = [
+  { type: 'Extractor1', dependencies: [] },
+  { type: 'Extractor2', dependencies: ['Extractor1'] },
+  { type: 'Extractor3', dependencies: ['Extractor1', 'Extractor2'] },
+];
+
+describe('sortExtractors', () => {
+  test('should put extractors in the correct order', () => {
+    const sorted = sortExtractors(WRONG_ORDER, DEPENDENCY_INFO);
+    expect(sorted[0].type).toEqual('Extractor1');
+    expect(sorted[1].type).toEqual('Extractor2');
+    expect(sorted[2].type).toEqual('Extractor3');
+  });
+
+  test('should change nothing if all extractors are in order with all dependencies', () => {
+    const unchanged = sortExtractors(NO_CHANGE, DEPENDENCY_INFO);
+    expect(unchanged).toEqual(NO_CHANGE);
+  });
+
+  test('should fail when missing dependencies', () => {
+    expect(() => sortExtractors(MISSING, DEPENDENCY_INFO)).toThrow();
+  });
+});