major refactor of TRAPI and summarization code

StartServer.mjs

@@ -4,6 +4,7 @@ import { bootstrapConfig } from './lib/config.mjs';
 
 import { loadBiolink } from './lib/biolink-model.mjs';
 import { loadChebi } from './lib/chebi.mjs';
+import { loadTrapi } from './lib/trapi.mjs';
 import { TranslatorService } from './services/TranslatorService.mjs';
 import { TranslatorServicexFEAdapter } from './adapters/TranslatorServicexFEAdapter.mjs';
 import { ARSClient } from './lib/ARSClient.mjs';
@@ -33,10 +34,8 @@ const SERVER_CONFIG = await (async function() {
   return bootstrapConfig(basefile, overrides);
 })();
 
-await loadBiolink(SERVER_CONFIG.biolink.version,
-                  SERVER_CONFIG.biolink.support_deprecated_predicates,
-                  SERVER_CONFIG.biolink.infores_catalog,
-                  SERVER_CONFIG.biolink.prefix_catalog);
+await loadBiolink(SERVER_CONFIG.biolink);
+await loadTrapi(SERVER_CONFIG.trapi);
 await loadChebi();
 
 // Bootstrap the translator service.

adapters/TranslatorServicexFEAdapter.mjs

@@ -1,7 +1,7 @@
 'use strict';
 
 import * as arsmsg from '../lib/ARSMessages.mjs';
-import * as trapi from '../lib/trapi.mjs';
+import * as sm from '../lib/summarization.mjs';
 
 /* Translate messages coming from the Translator Service into the formats that the Frontend (FE) app expects */
 /* This module should not contain logic that goes beyond message transformations */
@@ -49,15 +49,15 @@ class TranslatorServicexFEAdapter {
       }
     });
 
-    const summary = await trapi.creativeAnswersToSummary(
+    const smry = await sm.answersToSmry(
       msg.pk,
       data,
       maxHops);
-    summary.meta.timestamp = msg.meta.timestamp;
+    smry.meta.timestamp = msg.meta.timestamp;
 
     return {
       status: determineStatus(msg),
-      data: summary
+      data: smry
     };
   }
 }

configurations/ci.json

@@ -3,6 +3,10 @@
   "port": 8386,
   "response_timeout": 300,
   "json_payload_limit": "20mb",
+  "trapi": {
+    "query_subject_key": "sn",
+    "query_object_key": "on"
+  },
   "ars_endpoint": {
     "host": "ars.ci.transltr.io",
     "post_uri": "/ars/api/submit",

configurations/production.json

@@ -3,6 +3,10 @@
   "port": 8386,
   "response_timeout": 300,
   "json_payload_limit": "1mb",
+  "trapi": {
+    "query_subject_key": "sn",
+    "query_object_key": "on"
+  },
   "ars_endpoint": {
     "host": "ars-prod.transltr.io",
     "post_uri": "/ars/api/submit",

configurations/test.json

@@ -3,6 +3,10 @@
   "port": 8386,
   "response_timeout": 300,
   "json_payload_limit": "1mb",
+  "trapi": {
+    "query_subject_key": "sn",
+    "query_object_key": "on"
+  },
   "ars_endpoint": {
     "host": "ars.test.transltr.io",
     "post_uri": "/ars/api/submit",

lib/biolink-model.mjs

@@ -9,54 +9,58 @@ let DEPRECATED_TO_QUALIFIED_PREDICATE_MAP = null;
 let PREFIX_CATALOG = null;
 let PREFIX_EXCLUDE_LIST = null;
 
-export async function loadBiolink(biolinkVersion, supportDeprecatedPredicates, inforesCatalog, prefixCatalog) {
+export async function loadBiolink(biolinkConfig) {
+  const biolinkVersion = biolinkConfig.version;
+  const supportDeprecatedPreds = biolinkConfig.support_deprecated_predicates;
+  const inforesCatalog = biolinkConfig.infores_catalog;
+  const prefixCatalog = biolinkConfig.prefix_catalog;
   const biolinkModel = await cmn.readJson(`./assets/biolink-model/${biolinkVersion}/biolink-model.json`);
   const slots = cmn.jsonGet(biolinkModel, 'slots');
   const classes = cmn.jsonGet(biolinkModel, 'classes');
-  BIOLINK_PREDICATES = makeBlPredicates(slots);
+  BIOLINK_PREDICATES = makeBlPreds(slots);
   BIOLINK_CLASSES = makeBlClasses(classes);
   INFORES_CATALOG = await cmn.readJson(`./assets/biolink-model/common/${inforesCatalog}`);
   PREFIX_CATALOG = await cmn.readJson(`./assets/biolink-model/common/${prefixCatalog.path}`);
   PREFIX_EXCLUDE_LIST = prefixCatalog.exclude;
-  if (supportDeprecatedPredicates) {
+  if (supportDeprecatedPreds) {
     DEPRECATED_TO_QUALIFIED_PREDICATE_MAP = await cmn.readJson(`./assets/biolink-model/${biolinkVersion}/deprecated-predicate-mapping.json`);
   }
 }
 
 export function tagBiolink(str) {
-  return biolinkifyPredicate(str);
+  return biolinkifyPred(str);
 }
 
-export function isDeprecatedPredicate(s) {
+export function isDeprecatedPred(s) {
   return !!DEPRECATED_TO_QUALIFIED_PREDICATE_MAP &&
          DEPRECATED_TO_QUALIFIED_PREDICATE_MAP[sanitizeBiolinkItem(s)] !== undefined;
 }
 
-export function isBiolinkPredicate(s) {
-  const sanitizedPredicate = sanitizeBiolinkItem(s);
-  return BIOLINK_PREDICATES[sanitizedPredicate] !== undefined ||
-         isDeprecatedPredicate(sanitizedPredicate);
+export function isBiolinkPred(s) {
+  const sanitizedPred = sanitizeBiolinkItem(s);
+  return BIOLINK_PREDICATES[sanitizedPred] !== undefined ||
+         isDeprecatedPred(sanitizedPred);
 }
 
 export function sanitizeBiolinkItem(pred) {
   return pred.replaceAll('_', ' ').replaceAll('biolink:', '');
 }
 
-export function invertBiolinkPredicate(pred, biolinkify = false) {
+export function invertBiolinkPred(pred, biolinkify = false) {
   const p = sanitizeBiolinkItem(pred);
-  const biolinkPredicate = cmn.jsonGet(BIOLINK_PREDICATES, p, false);
-  if (biolinkPredicate) {
+  const biolinkPred= cmn.jsonGet(BIOLINK_PREDICATES, p, false);
+  if (biolinkPred) {
     if (biolinkify) {
-      return biolinkifyPredicate(biolinkPredicate.inverse);
+      return biolinkifyPred(biolinkPred.inverse);
     }
-    return biolinkPredicate.inverse;
+    return biolinkPred.inverse;
   }
   throw InvalidPredicateError(p);
 }
 
-export function deprecatedPredicateToPredicateAndQualifiers(predicate) {
-  const qualifiedPredicate = DEPRECATED_TO_QUALIFIED_PREDICATE_MAP[predicate];
-  return [qualifiedPredicate.predicate, qualifiedPredicate];
+export function deprecatedPredToPredAndQualifiers(pred) {
+  const qualifiedPred = DEPRECATED_TO_QUALIFIED_PREDICATE_MAP[pred];
+  return [qualifiedPred.predicate, qualifiedPred];
 }
 
 export function inforesToProvenance(infores) {
@@ -117,13 +121,13 @@ export function curieToUrl(curie) {
   return `${url}${curieId}`;
 }
 
-export function predicateToUrl(predicate) {
-  const p = predicate.replaceAll(' ', '_');
+export function predToUrl(pred) {
+  const p = pred.replaceAll(' ', '_');
   return `https://biolink.github.io/biolink-model/${p}/`
 }
 
-function InvalidPredicateError(predicate) {
-  const error = new Error(`Expected a valid biolink predicate. Got: ${predicate}`, 'biolink-model.mjs');
+function InvalidPredicateError(pred) {
+  const error = new Error(`Expected a valid biolink predicate. Got: ${pred}`, 'biolink-model.mjs');
 }
 InvalidPredicateError.prototype = Object.create(Error.prototype);
 
@@ -164,39 +168,39 @@ function getInverse(pred, record) {
   return cmn.jsonGet(record, 'inverse', false);
 }
 
-function distanceFromRelatedTo(slots, predicate) {
+function distanceFromRelatedTo(slots, pred) {
   for (let level = 0; ;level += 1) {
-    if (predicate === 'related to') {
+    if (pred === 'related to') {
       return level;
     }
 
-    let predicateObj = cmn.jsonGet(slots, predicate, false);
-    if (!predicateObj) {
+    let predObj = cmn.jsonGet(slots, pred, false);
+    if (!predObj) {
       return -1;
     }
 
-    predicate = cmn.jsonGet(predicateObj, 'is_a', false);
+    pred = cmn.jsonGet(predObj, 'is_a', false);
   }
 }
 
-function makeBlPredicate(predicate, record, rank) {
+function makeBlPred(pred, record, rank) {
   return {
-    'parent': getParent(predicate, record),
-    'isCanonical': isCanonical(predicate, record),
-    'isSymmetric': isSymmetric(predicate, record),
-    'isDeprecated': isDeprecated(predicate, record),
-    'inverse': getInverse(predicate, record),
+    'parent': getParent(pred, record),
+    'isCanonical': isCanonical(pred, record),
+    'isSymmetric': isSymmetric(pred, record),
+    'isDeprecated': isDeprecated(pred, record),
+    'inverse': getInverse(pred, record),
     'rank': rank,
   };
 }
 
-function makeBlPredicates(slots) {
+function makeBlPreds(slots) {
   let blPreds = {};
   Object.keys(slots).forEach((pred) => {
       const rank = distanceFromRelatedTo(slots, pred);
       if (rank >= 0) {
         const record = slots[pred];
-        blPreds[pred] = makeBlPredicate(pred, record, rank);
+        blPreds[pred] = makeBlPred(pred, record, rank);
       }
     });
 
@@ -213,7 +217,7 @@ function makeBlPredicates(slots) {
   return blPreds;
 }
 
-function biolinkifyPredicate(pred) {
+function biolinkifyPred(pred) {
   let s = pred.replaceAll(' ', '_');
   if (s.startsWith('biolink:')) {
     return s;
@@ -222,29 +226,29 @@ function biolinkifyPredicate(pred) {
   return `biolink:${s}`;
 }
 
-function getBiolinkPredicateData(pred) {
+function getBiolinkPredData(pred) {
   return cmn.jsonGet(BIOLINK_PREDICATES, sanitizeBiolinkItem(pred), false);
 }
 
-function isBiolinkPredicateMoreSpecific(pred1, pred2) {
+function isBiolinkPredMoreSpecific(pred1, pred2) {
   const p1 = sanitizeBiolinkItem(pred1);
   const p2 = sanitizeBiolinkItem(pred2);
-  const biolinkPredicate1 = getBiolinkPredicateData(p1);
-  const biolinkPredicate2 = getBiolinkPredicateData(p2);
+  const biolinkPred1 = getBiolinkPredData(p1);
+  const biolinkPred2 = getBiolinkPredData(p2);
 
-  if (!biolinkPredicate1) {
+  if (!biolinkPred1) {
     throw InvalidPredicateError(p1);
   }
-  else if (!biolinkPredicate2) {
+  else if (!biolinkPred2) {
     throw InvalidPredicateError(p2);
   }
   else {
     return pred1.rank > pred2.rank;
   }
 }
 
-function sortBiolinkPredicates(preds) {
-  return sort(pres, isBiolinkPredicateMoreSpecific);
+function sortBiolinkPreds(preds) {
+  return sort(pres, isBiolinkPredMoreSpecific);
 }
 
 /* Biolink category-related functions

lib/biothings-annotation.mjs

@@ -6,9 +6,9 @@ import * as chebi from './chebi.mjs';
 export function getFdaApproval(annotation) {
   return parseAnnotation(
     annotation,
-    noHandler,
+    genDefaultHandler(),
     getChemicalFdaApproval,
-    noHandler);
+    genDefaultHandler());
 }
 
 export function getDescription(annotation) {
@@ -22,37 +22,40 @@ export function getDescription(annotation) {
 export function getChebiRoles(annotation) {
   return parseAnnotation(
     annotation,
-    noHandler,
+    genDefaultHandler(),
     getChemicalChebiRoles,
-    noHandler);
+    genDefaultHandler());
 }
 
 export function getDrugIndications(annotation) {
+  const defaultHandler = genDefaultHandler([]);
   return parseAnnotation(
     annotation,
-    noHandler,
+    defaultHandler,
     getChemicalDrugIndications,
-    noHandler);
+    defaultHandler,
+    defaultHandler);
 }
 
 export function getCuries(annotation) {
+  const defaultHandler = genDefaultHandler([]);
   return parseAnnotation(
     annotation,
     getDiseaseMeshCuries,
-    noHandler,
-    noHandler);
+    defaultHandler,
+    defaultHandler,
+    defaultHandler);
 }
 
 export function getNames(annotation) {
   return parseAnnotation(
     annotation,
-    noHandler,
+    genDefaultHandler(),
     getChemicalNames,
-    noHandler);
+    genDefaultHandler());
 }
 
-function parseAnnotation(annotation, diseaseHandler, chemicalHandler, geneHandler, fallback = null) {
-  annotation = annotation[0];
+function parseAnnotation(annotation, diseaseHandler, chemicalHandler, geneHandler, defaultHandler = genDefaultHandler()) {
   if (isDisease(annotation)) {
     return diseaseHandler(annotation);
   }
@@ -65,7 +68,7 @@ function parseAnnotation(annotation, diseaseHandler, chemicalHandler, geneHandle
     return geneHandler(annotation);
   }
 
-  return fallback;
+  return defaultHandler();
 }
 
 function getDiseaseDescription(annotation) {
@@ -82,15 +85,13 @@ function getDiseaseMeshCuries(annotation) {
     ['mondo', 'xrefs', 'mesh'],
     ['disease_ontology', 'xrefs', 'mesh']
   ];
-
   const curies = [];
   for (const path of paths) {
     const curie = cmn.jsonGetFromKpath(annotation, path, null);
     if (curie) {
       curies.push(`MESH:${curie}`);
     }
   }
-
   return curies;
 }
 
@@ -181,6 +182,6 @@ function isGene(annotation) {
   return annotation.symbol !== undefined;
 }
 
-function noHandler(annotation) {
-  return null;
+function genDefaultHandler(fallback = null) {
+  return function() { return fallback };
 }