Merge pull request #466 from bcgsc/feat/DEVSU-2745-improve-rapid-report-variants-tests

elewis2 · web-flow · commit cbfcadb40994 · 2025-10-23T07:26:18.000-07:00
cleanup variant fetching code and add tests
diff --git a/app/libs/createReport.js b/app/libs/createReport.js
@@ -207,7 +207,6 @@ const createReportGenes = async (report, content, options = {}) => {
     for (const gene of genes) {
       geneDefns[gene.name] = gene.id;
     }
-
     return geneDefns;
   } catch (error) {
     throw new Error(`Unable to create report genes ${error.message || error}`);
@@ -234,7 +233,10 @@ const updateKbMatchesInputFormat = (content) => {
         if (!('kbMatchedStatements' in content)) {
           content.kbMatchedStatements = [];
         }
-        content.kbMatchedStatements.push(statement);
+        const stmtIds = content.kbMatchedStatements.map((s) => {return s.kbStatementId;});
+        if (!stmtIds.includes(statement.kbStatementId)) {
+          content.kbMatchedStatements.push(statement);
+        }
 
         const conditionSet = {
           kbStatementId: item.kbStatementId,
@@ -246,7 +248,17 @@ const updateKbMatchesInputFormat = (content) => {
         if (!('kbStatementMatchedConditions' in content)) {
           content.kbStatementMatchedConditions = [];
         }
-        content.kbStatementMatchedConditions.push(conditionSet);
+        const exists = content.kbStatementMatchedConditions.some((cs) => {
+          return cs.kbStatementId === conditionSet.kbStatementId
+          && cs.matchedConditions.length === conditionSet.matchedConditions.length
+          && cs.matchedConditions.every((mc, index) => {
+            return mc.observedVariantKey === conditionSet.matchedConditions[index].observedVariantKey
+            && mc.kbVariantId === conditionSet.matchedConditions[index].kbVariantId;
+          });
+        });
+        if (!exists) {
+          content.kbStatementMatchedConditions.push(conditionSet);
+        }
       }
     });
   }
@@ -312,6 +324,7 @@ const createReportVariantsSection = async (reportId, genesRecordsByName, modelNa
 const createReportVariantSections = async (report, content, transaction) => {
   // create the genes first since they will need to be linked to the variant records
   const geneDefns = await createReportGenes(report, content, {transaction});
+
   // create the variants and create a mapping from their input 'key' value to the new records
   const variantMapping = {};
   const variantPromises = Object.keys(KB_PIVOT_MAPPING).map(async (variantType) => {
@@ -321,8 +334,8 @@ const createReportVariantSections = async (report, content, transaction) => {
     if (!Array.isArray(content[variantModel]) && typeof content[variantModel] === 'object') {
       content[variantModel] = [content[variantModel]];
     }
-    const mapping = await createReportVariantsSection(report.id, geneDefns, variantModel, content[variantModel] || [], {transaction});
 
+    const mapping = await createReportVariantsSection(report.id, geneDefns, variantModel, content[variantModel] || [], {transaction});
     variantMapping[variantType] = mapping;
   });
   // create the probe results (linked to gene but not to kbMatches)
diff --git a/app/routes/report/variants.js b/app/routes/report/variants.js
@@ -3,7 +3,7 @@ const express = require('express');
 
 const router = express.Router({mergeParams: true});
 
-const {Op, literal} = require('sequelize');
+const {literal} = require('sequelize');
 const db = require('../../models');
 const logger = require('../../log');
 
@@ -13,6 +13,7 @@ const KBMATCHEXCLUDE = ['id', 'reportId', 'variantId', 'deletedAt', 'updatedBy']
 const OBSVARANNOTEXCLUDE = KBMATCHEXCLUDE;
 const STATEMENTEXCLUDE = ['id', 'reportId', 'deletedAt', 'updatedBy'];
 const MUTATION_REGEX = '^([^\\s]+)(\\s)(mutation[s]?)?(missense)?$';
+const MSI_CUTOFF = 20;
 
 const getVariants = async (tableName, variantType, reportId) => {
   return db.models[tableName].scope('extended').findAll({
@@ -38,87 +39,66 @@ const getVariants = async (tableName, variantType, reportId) => {
 };
 
 const unknownSignificanceIncludes = ['mut'];
-const signatureVariant = ['tmb', 'msi', 'sigv'];
-
-const unknownSignificanceGeneFilter = {
-  [Op.or]: [{oncogene: true}, {tumourSuppressor: true}, {cancerGeneListMatch: true}],
-};
+const cancerRelevanceOmits = ['exp'];
+const geneLinkedVariantTypes = ['mut', 'cnv', 'exp'];
 
 const getRapidReportVariants = async (tableName, variantType, reportId, rapidTable) => {
   let allKbMatches;
-  if (
-    unknownSignificanceIncludes.includes(variantType)
-    && !signatureVariant.includes(variantType)
-  ) {
-    allKbMatches = await db.models[tableName].scope('extended').findAll({
-      order: [['id', 'ASC']],
-      attributes: {
-        include: [[literal(`'${variantType}'`), 'variantType']],
-      },
-      where: {
-        reportId,
-      },
-      include: [
-        {
-          model: db.models.kbMatches,
-          attributes: {exclude: KBMATCHEXCLUDE},
-          include: [
-            {
-              model: db.models.kbMatchedStatements,
-              as: 'kbMatchedStatements',
-              attributes: {
-                exclude: STATEMENTEXCLUDE,
-              },
-              // where: {
-              //  ...therapeuticAssociationFilterStatement,
-              // },
-              through: {attributes: ['flags']},
+
+  const query = {
+    order: [['id', 'ASC']],
+    attributes: {
+      include: [[literal(`'${variantType}'`), 'variantType']],
+    },
+    where: {
+      reportId,
+    },
+    include: [
+      {
+        model: db.models.kbMatches,
+        attributes: {exclude: KBMATCHEXCLUDE},
+        include: [
+          {
+            model: db.models.kbMatchedStatements,
+            as: 'kbMatchedStatements',
+            attributes: {
+              exclude: STATEMENTEXCLUDE,
             },
-          ],
-        },
-        {
-          model: db.models.observedVariantAnnotations,
-          attributes: {exclude: OBSVARANNOTEXCLUDE},
-          as: 'observedVariantAnnotation',
-        },
-        {
-          model: db.models.genes.scope('minimal'),
-          as: 'gene',
-          where: unknownSignificanceGeneFilter, // TODO does including this remove results that would otherwise be in allKbMatches
-        },
-      ],
-    });
-  } else {
-    allKbMatches = await db.models[tableName].scope('extended').findAll({
-      order: [['id', 'ASC']],
-      attributes: {
-        include: [[literal(`'${variantType}'`), 'variantType']],
+            through: {attributes: ['flags']},
+          },
+        ],
       },
-      where: {
-        reportId,
+      {
+        model: db.models.observedVariantAnnotations,
+        attributes: {exclude: OBSVARANNOTEXCLUDE},
+        as: 'observedVariantAnnotation',
       },
-      include: [
-        {
-          model: db.models.kbMatches,
-          attributes: {exclude: KBMATCHEXCLUDE},
-          include: [
-            {
-              model: db.models.kbMatchedStatements,
-              as: 'kbMatchedStatements',
-              attributes: {
-                exclude: STATEMENTEXCLUDE,
-              },
-              through: {attributes: ['flags']},
-            },
-          ],
-        },
-        {
-          model: db.models.observedVariantAnnotations,
-          attributes: {exclude: OBSVARANNOTEXCLUDE},
-          as: 'observedVariantAnnotation',
-        },
-      ],
-    });
+    ],
+  };
+  if (geneLinkedVariantTypes.includes(variantType)) {
+    const geneSubquery = {
+      model: db.models.genes.scope('minimal'),
+      as: 'gene',
+    };
+    query.include.push(geneSubquery);
+  }
+
+  // if the table is unknownSignificance, only get subset of variant types
+  if (rapidTable === 'unknownSignificance') {
+    if (unknownSignificanceIncludes.includes(variantType)) {
+      allKbMatches = await db.models[tableName].scope('extended').findAll(query);
+    }
+  } else if (rapidTable === 'cancerRelevance') {
+    // exclude expression variants from cancer relevance table
+    if (!cancerRelevanceOmits.includes(variantType)) {
+      allKbMatches = await db.models[tableName].scope('extended').findAll(query);
+    }
+  } else {
+    allKbMatches = await db.models[tableName].scope('extended').findAll(query);
+  }
+
+  if (!allKbMatches) {
+    return [];
   }
 
   // do initial filtering based on contents of annotations - these should override defaults
@@ -159,6 +139,7 @@ const getRapidReportVariants = async (tableName, variantType, reportId, rapidTab
         const variantRegexMatch = item.kbVariant.match(MUTATION_REGEX);
         return !(variantRegexMatch);
       });
+
       return variant;
     });
 
@@ -181,6 +162,7 @@ const getRapidReportVariants = async (tableName, variantType, reportId, rapidTab
         kbmatch.kbMatchedStatements = statements;
         return kbmatch;
       });
+
       return variant;
     });
 
@@ -191,12 +173,14 @@ const getRapidReportVariants = async (tableName, variantType, reportId, rapidTab
           .filter((item) => {return item !== null;});
         return kbmatch.kbMatchedStatements.length > 0;
       });
+
       return variant;
     });
 
     // remove variants which have no matches
     therapeuticAssociationResults = therapeuticAssociationResults.filter((variant) => {
       const kbmatches = variant.kbMatches.filter((item) => {return item !== null;});
+
       return kbmatches.length > 0;
     });
   }
@@ -209,35 +193,37 @@ const getRapidReportVariants = async (tableName, variantType, reportId, rapidTab
 
   let cancerRelevanceResults = [];
   const cancerRelevanceResultsFiltered = [];
-  if (!(variantType === 'exp')) { // omit expression variants from this table
-    cancerRelevanceResults = JSON.parse(JSON.stringify(allKbMatches));
+  cancerRelevanceResults = JSON.parse(JSON.stringify(allKbMatches));
 
-    // remove nonmatching kbmatches
-    cancerRelevanceResults = cancerRelevanceResults.map((variant) => {
-      const kbmatches = variant.kbMatches.filter((item) => {
-        const msiMatch = (item.variantType === 'msi' && item.score >= 20);
-        if (msiMatch) {
-          return true;
-        }
-        const variantRegexMatch = item.kbVariant.match(MUTATION_REGEX);
-        return (!variantRegexMatch);
-      });
-      variant.kbMatches = kbmatches;
-      return variant;
-    });
+  // remove msi variants below cutoff
+  cancerRelevanceResults = cancerRelevanceResults.filter((variant) => {
+    if (variantType === 'msi') {
+      return (variant.score >= MSI_CUTOFF);
+    }
+    return true;
+  });
 
-    // remove variants which now have no matches
-    cancerRelevanceResults = cancerRelevanceResults.filter((variant) => {
-      const kbmatches = variant.kbMatches.filter((item) => {return item !== null;});
-      return kbmatches.length > 0;
+  // remove kbmatches that fail the regex
+  cancerRelevanceResults = cancerRelevanceResults.map((variant) => {
+    const kbmatches = variant.kbMatches.filter((item) => {
+      const variantRegexMatch = item.kbVariant.match(MUTATION_REGEX);
+      return (!variantRegexMatch);
     });
+    variant.kbMatches = kbmatches;
+    return variant;
+  });
 
-    for (const row of cancerRelevanceResults) {
-      if (!(therapeuticAssociationResults.find(
-        (e) => {return e.ident === row.ident;},
-      ))) {
-        cancerRelevanceResultsFiltered.push(row);
-      }
+  // remove variants which now have no matches
+  cancerRelevanceResults = cancerRelevanceResults.filter((variant) => {
+    const kbmatches = variant.kbMatches.filter((item) => {return item !== null;});
+    return kbmatches.length > 0;
+  });
+
+  for (const row of cancerRelevanceResults) {
+    if (!(therapeuticAssociationResults.find(
+      (e) => {return e.ident === row.ident;},
+    ))) {
+      cancerRelevanceResultsFiltered.push(row);
     }
   }
 
@@ -254,9 +240,17 @@ const getRapidReportVariants = async (tableName, variantType, reportId, rapidTab
     unknownSignificanceResults = JSON.parse(JSON.stringify(allKbMatches));
   }
 
-  // refine unknownSignificance results to only include therapeuticAssoc-qualifying matches
+  // refine unknownSignificance results to only include variants that EITHER:
+  // a - have a linked gene that is oncogene, cancerGeneList or tumourSuppressor true, OR
+  // b - therapeuticAssoc-qualifying matches
   // (unless they are tagged - add the tagged results back after filtering)
   unknownSignificanceResults = unknownSignificanceResults.map((variant) => {
+    if (
+      // this is safe to check because variantType is smallMutation which always has a gene
+      variant.gene.oncogene || variant.gene.cancerGeneListMatch || variant.gene.tumourSuppressor
+    ) {
+      return variant;
+    }
     variant.kbMatches = variant.kbMatches.map((kbmatch) => {
       const statements = kbmatch.kbMatchedStatements.filter((stmt) => {
         if ((stmt.category === 'therapeutic')
@@ -276,7 +270,7 @@ const getRapidReportVariants = async (tableName, variantType, reportId, rapidTab
     return variant;
   });
 
-  // remove matches which have no matching statements
+  // remove matches which have no matching statements...
   unknownSignificanceResults = unknownSignificanceResults.map((variant) => {
     variant.kbMatches = variant.kbMatches.filter((kbmatch) => {
       kbmatch.kbMatchedStatements = kbmatch.kbMatchedStatements
@@ -286,6 +280,11 @@ const getRapidReportVariants = async (tableName, variantType, reportId, rapidTab
     return variant;
   });
 
+  // remove variants which have no matches
+  unknownSignificanceResults = unknownSignificanceResults.filter((variant) => {
+    return variant.kbMatches.length > 0;
+  });
+
   // remove variants already included in a different section
   for (const row of unknownSignificanceResults) {
     if (!(therapeuticAssociationResults.find(
diff --git a/test/routes/report/variants.test.js b/test/routes/report/variants.test.js
