add chromosome to fusions and update loggers

Author: sshugsc

src/cosmic/fusions.js

@@ -19,6 +19,7 @@ const { logger } = require('../logging');
 const { cosmic: SOURCE_DEFN } = require('../sources');
 
 const RECURRENCE_THRESHOLD = 3;
+const cache = {};
 
 const HEADER = {
     diseaseId: 'COSMIC_PHENOTYPE_ID',
@@ -32,15 +33,39 @@ const HEADER = {
     sampleId: 'COSMIC_SAMPLE_ID',
 };
 
+const fetchChromosome = async (conn, sourceId) => {
+    if (cache[sourceId]) {
+        return cache[sourceId];
+    }
+    const record = await conn.getUniqueRecordBy({
+        filters: {
+            AND: [
+                { sourceId },
+                { biotype: 'chromosome' },
+            ],
+        },
+        sort: orderPreferredOntologyTerms,
+        target: 'Feature',
+    });
+    cache[sourceId] = record;
+    return record;
+};
+
 
 const processVariants = async ({
     conn, record, variantType, exonSpecific,
 }) => {
     // fetch the features
-    const [gene1] = await _gene.fetchAndLoadBySymbol(conn, record.gene1);
-    const [gene2] = await _gene.fetchAndLoadBySymbol(conn, record.gene2);
+    let [gene1] = await _gene.fetchAndLoadBySymbol(conn, record.gene1),
+        [gene2] = await _gene.fetchAndLoadBySymbol(conn, record.gene2);
 
     // create the variants
+    if (!gene1) {
+        gene1 = await fetchChromosome(conn, record.gene1);
+    }
+    if (!gene2) {
+        gene2 = await fetchChromosome(conn, record.gene2);
+    }
     if (!gene1 || !gene2) {
         throw new Error(`unable to find genes for record ${record.id}: ${record.gene1}, ${record.gene2}`);
     }

src/cosmic/resistance.js

@@ -69,43 +69,45 @@ const processVariants = async ({ conn, record, source }) => {
                 throw Error(`failed to find the HGNC gene for ${record.gene}`);
             }
         } catch (err) {
-            logger.error(err);
+            logger.warn(err);
         }
     }
 
-    try {
-        // add the protein variant with its protein translation
-        const variant = jsonifyVariant(parseVariant(record.protein, false));
-        variant.type = rid(await conn.getVocabularyTerm(variant.type));
-
-        const reference1 = rid(await _ensembl.fetchAndLoadById(
-            conn,
-            { biotype: 'protein', sourceId: variant.reference1 },
-        ));
-        protein = rid(await conn.addVariant({
-            content: { ...variant, reference1 },
-            existsOk: true,
-            target: 'PositionalVariant',
-        }));
-
-        if (gene) {
-            // add the same protein variant with the gene notation
-            generalProtein = rid(await conn.addVariant({
-                content: { ...variant, reference1: gene },
+    if (record.protein && record.protein.trim()) {
+        try {
+            // add the protein variant with its protein translation
+            const variant = jsonifyVariant(parseVariant(record.protein, false));
+            variant.type = rid(await conn.getVocabularyTerm(variant.type));
+
+            const reference1 = rid(await _ensembl.fetchAndLoadById(
+                conn,
+                { biotype: 'protein', sourceId: variant.reference1 },
+            ));
+            protein = rid(await conn.addVariant({
+                content: { ...variant, reference1 },
                 existsOk: true,
                 target: 'PositionalVariant',
             }));
 
-            // link the translation version to the gene version
-            await conn.addRecord({
-                content: { in: generalProtein, out: protein },
-                existsOk: true,
-                fetchExisting: false,
-                target: 'Infers',
-            });
+            if (gene) {
+                // add the same protein variant with the gene notation
+                generalProtein = rid(await conn.addVariant({
+                    content: { ...variant, reference1: gene },
+                    existsOk: true,
+                    target: 'PositionalVariant',
+                }));
+
+                // link the translation version to the gene version
+                await conn.addRecord({
+                    content: { in: generalProtein, out: protein },
+                    existsOk: true,
+                    fetchExisting: false,
+                    target: 'Infers',
+                });
+            }
+        } catch (err) {
+            logger.error(err);
         }
-    } catch (err) {
-        logger.error(err);
     }
 
     // create the cds variant

src/hgnc/index.js

@@ -203,7 +203,9 @@ const fetchAndLoadBySymbol = async ({
             CACHE[paramType][symbol] = record;
         }
         return record;
-    } catch (err) { }
+    } catch (err) {
+        logger.info('Unable to fetch ensembl source for linking records');
+    }
     // fetch from the HGNC API and upload
     const uri = `${HGNC_API}/${paramType}/${
         paramType === 'hgnc_id'
@@ -218,6 +220,10 @@ const fetchAndLoadBySymbol = async ({
         uri,
     });
 
+    if (!docs || docs.length === 0) {
+        throw new Error(`No HGNC record found for ${paramType}: ${symbol}`);
+    }
+
     for (const record of docs) {
         checkSpec(validateHgncSpec, record, rec => rec.hgnc_id);
     }
@@ -238,7 +244,9 @@ const fetchAndLoadBySymbol = async ({
             filters: { name: ensemblSourceName },
             target: 'Source',
         });
-    } catch (err) { }
+    } catch (err) {
+        logger.info('Unable to fetch ensembl source for linking records');
+    }
     const result = await uploadRecord({
         conn,
         deprecated: (