@sjcrh/proteinpaint-server 2.98.0 → 2.98.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.98.0",
+  "version": "2.98.1",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -61,7 +61,7 @@
     "@sjcrh/augen": "2.87.0",
     "@sjcrh/proteinpaint-rust": "2.84.0",
     "@sjcrh/proteinpaint-shared": "2.98.0",
-    "@sjcrh/proteinpaint-types": "2.98.0",
+    "@sjcrh/proteinpaint-types": "2.98.1",
     "better-sqlite3": "^9.4.1",
     "body-parser": "^1.15.2",
     "canvas": "~2.11.2",

package/routes/correlationVolcano.js

@@ -0,0 +1,128 @@
+import { CorrelationVolcanoPayload } from "#types/checkers";
+import { getData } from "../src/termdb.matrix.js";
+import run_R from "../src/run_R.js";
+import serverconfig from "../src/serverconfig.js";
+import { mayLog } from "#src/helpers.ts";
+import path from "path";
+const api = {
+  endpoint: "termdb/correlationVolcano",
+  methods: {
+    get: {
+      ...CorrelationVolcanoPayload,
+      init
+    },
+    post: {
+      ...CorrelationVolcanoPayload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    try {
+      const genome = genomes[q.genome];
+      if (!genome)
+        throw "invalid genome name";
+      const ds = genome.datasets?.[q.dslabel];
+      if (!ds)
+        throw "invalid ds";
+      const result = await compute(q, ds, genome);
+      res.send(result);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.error(e);
+    }
+  };
+}
+async function compute(q, ds, genome) {
+  const terms = [q.featureTw, ...q.variableTwLst];
+  const data = await getData(
+    {
+      filter: q.filter,
+      filter0: q.filter0,
+      terms
+    },
+    ds,
+    genome
+  );
+  if (data.error)
+    throw data.error;
+  const vtid2array = /* @__PURE__ */ new Map();
+  for (const tw of q.variableTwLst) {
+    vtid2array.set(tw.$id, { id: tw.$id, v1: [], v2: [] });
+  }
+  for (const sid in data.samples) {
+    const featureValue = data.samples[sid][q.featureTw.$id]?.value;
+    if (!Number.isFinite(featureValue))
+      continue;
+    for (const tw of q.variableTwLst) {
+      const variableValue = data.samples[sid][tw.$id]?.value;
+      if (!Number.isFinite(variableValue))
+        continue;
+      vtid2array.get(tw.$id).v1.push(featureValue);
+      vtid2array.get(tw.$id).v2.push(variableValue);
+    }
+  }
+  const input = {
+    method: q.correlationMethod || "pearson",
+    terms: [...vtid2array.values()]
+  };
+  const time1 = Date.now();
+  const r_output = await run_R(path.join(serverconfig.binpath, "utils", "corr.R"), JSON.stringify(input));
+  mayLog("Time taken to run correlation analysis:", Date.now() - time1);
+  let json_result;
+  for (const line of r_output.split("\n")) {
+    if (line.startsWith("adjusted_p_values:")) {
+      json_result = JSON.parse(line.replace("adjusted_p_values:", ""));
+    } else {
+    }
+  }
+  const output = { terms: json_result };
+  const result = { variableItems: [] };
+  for (const t of output.terms) {
+    const t2 = {
+      tw$id: t.id,
+      sampleSize: t.sample_size,
+      //sampleSize: input.terms.get(t.id).v1.length, // This was not working so passed the length of each array from R
+      correlation: t.correlation,
+      original_pvalue: t.original_p_value,
+      adjusted_pvalue: t.adjusted_p_value
+    };
+    result.variableItems.push(t2);
+  }
+  return result;
+}
+function validate_correlationVolcano(ds) {
+  const cv = ds.cohort.correlationVolcano;
+  if (!cv)
+    return;
+  if (typeof cv.feature != "object")
+    throw "cv.feature not obj";
+  if (cv.feature.termType == "geneExpression") {
+    if (!ds.queries?.geneExpression)
+      throw "cv.feature.termType=geneExpression not supported by ds";
+  } else {
+    throw "unknown cv.feature.termType";
+  }
+  if (typeof cv.variables != "object")
+    throw "cv.variables not obj";
+  if (cv.variables.type == "dictionaryTerm") {
+    if (!Array.isArray(cv.variables.termIds))
+      throw "cv.variables.termIds not array when type=dictionaryTerm";
+    for (const id of cv.variables.termIds) {
+      const t = ds.cohort.termdb.q.termjsonByOneid(id);
+      if (!t)
+        throw "cv.variables.termIds: unknown id: " + id;
+      if (t.type != "integer" && t.type != "float")
+        throw "cv.variables.termIds: not integer/float: " + id;
+    }
+  } else {
+    throw "unknown cv.variables.type";
+  }
+}
+export {
+  api,
+  validate_correlationVolcano
+};

package/routes/termdb.config.js

@@ -27,7 +27,7 @@ function init({ genomes }) {
       if (!genome)
         throw "invalid genome";
       const [ds] = get_ds_tdb(genome, q);
-      return make(q, res, ds, genome);
+      return make(q, req, res, ds, genome);
     } catch (e) {
       res.send({ error: e.message || e });
       if (e.stack)
@@ -37,13 +37,11 @@ function init({ genomes }) {
     }
   };
 }
-function make(q, res, ds, genome) {
+function make(q, req, res, ds, genome) {
   const tdb = ds.cohort.termdb;
-  const auth = { embedder: q.embedder };
   const c = {
-    selectCohort: tdb.selectCohort,
-    // optional
-    supportedChartTypes: tdb.q?.getSupportedChartTypes(auth),
+    selectCohort: getSelectCohort(ds, req),
+    supportedChartTypes: tdb.q?.getSupportedChartTypes(req),
     renamedChartTypes: ds.cohort.renamedChartTypes,
     allowedTermTypes: getAllowedTermTypes(ds),
     termMatch2geneSet: tdb.termMatch2geneSet,
@@ -68,8 +66,6 @@ function make(q, res, ds, genome) {
     c.plotConfigByCohort = tdb.plotConfigByCohort;
   if (tdb.multipleTestingCorrection)
     c.multipleTestingCorrection = tdb.multipleTestingCorrection;
-  if (tdb.neuroOncRegression)
-    c.neuroOncRegression = tdb.neuroOncRegression;
   if (tdb.helpPages)
     c.helpPages = tdb.helpPages;
   if (tdb.minTimeSinceDx)
@@ -90,15 +86,22 @@ function make(q, res, ds, genome) {
     c.excludedTermtypeByTarget = tdb.excludedTermtypeByTarget;
   if (tdb.survival)
     c.survival = tdb.survival;
+  if (tdb.regression)
+    c.regression = tdb.regression;
   if (ds.assayAvailability)
     c.assayAvailability = ds.assayAvailability;
   if (ds.customTwQByType)
     c.customTwQByType = ds.customTwQByType;
+  if (ds.cohort.correlationVolcano)
+    c.correlationVolcano = ds.cohort.correlationVolcano;
   c.requiredAuth = authApi.getRequiredCredForDsEmbedder(q.dslabel, q.embedder);
   addRestrictAncestries(c, tdb);
   addScatterplots(c, ds);
   addMatrixplots(c, ds);
   addNonDictionaryQueries(c, ds, genome);
+  c.requiredAuth = authApi.getRequiredCredForDsEmbedder(q.dslabel, q.embedder);
+  const info = authApi.getNonsensitiveInfo(req);
+  c.clientAuthResult = info.clientAuthResult || {};
   res.send({ termdbConfig: c });
 }
 function addRestrictAncestries(c, tdb) {
@@ -256,6 +259,16 @@ function getAllowedTermTypes(ds) {
     typeSet.add(TermTypes.METABOLITE_INTENSITY);
   return [...typeSet];
 }
+function getSelectCohort(ds, req) {
+  if (!ds.cohort.termdb.selectCohort)
+    return;
+  const copy = Object.assign({}, ds.cohort.termdb.selectCohort);
+  if (ds.cohort.termdb.selectCohort.descriptionByUser) {
+    copy.description = ds.cohort.termdb.selectCohort.descriptionByUser(authApi.getNonsensitiveInfo(req));
+    delete copy.descriptionByUser;
+  }
+  return copy;
+}
 export {
   api
 };

package/routes/termdb.violin.js

@@ -122,7 +122,7 @@ function divideValues(q, data, sampleType) {
     key2values,
     min: absMin,
     max: absMax,
-    uncomputableValueObj: sortObj(uncomputableValues)
+    uncomputableValues: sortObj(uncomputableValues)
   };
 }
 function sortObj(object) {
@@ -148,16 +148,14 @@ function setResponse(valuesObject, data, q, sampleType) {
         seriesId: key,
         plotValueCount: values?.length,
         color: overlayTerm?.term?.values?.[key]?.color || null,
-        divideTwBins: isNumericTerm(overlayTerm.term) ? numericBins(overlayTerm, data) : null,
-        uncomputableValueObj: Object.keys(valuesObject.uncomputableValueObj).length > 0 ? valuesObject.uncomputableValueObj : null
+        divideTwBins: isNumericTerm(overlayTerm.term) ? numericBins(overlayTerm, data) : null
       });
     } else {
-      const plot = {
+      plots.push({
         label: sampleType,
         values,
         plotValueCount: values.length
-      };
-      plots.push(plot);
+      });
     }
   }
   const result = {
@@ -165,7 +163,7 @@ function setResponse(valuesObject, data, q, sampleType) {
     max: valuesObject.max,
     plots,
     pvalues: [],
-    uncomputableValueObj: Object.keys(valuesObject.uncomputableValueObj).length > 0 ? valuesObject.uncomputableValueObj : null
+    uncomputableValues: Object.keys(valuesObject.uncomputableValues).length > 0 ? valuesObject.uncomputableValues : null
   };
   return result;
 }
@@ -222,9 +220,8 @@ function createCanvasImg(q, result, ds) {
         ctx.stroke();
       });
     plot.src = canvas.toDataURL();
-    const isKDE = q.isKDE;
-    plot.density = getBinsDensity(axisScale, plot, isKDE, q.ticks);
-    plot.summaryStats = summaryStats(plot.values);
+    plot.density = getBinsDensity(axisScale, plot, q.isKDE, q.ticks);
+    plot.summaryStats = summaryStats(plot.values).values;
     delete plot.values;
   }
 }