@sjcrh/proteinpaint-server 2.98.1-0 → 2.98.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.98.1-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.1-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

@@ -40,8 +40,7 @@ function init({ genomes }) {
 function make(q, req, res, ds, genome) {
   const tdb = ds.cohort.termdb;
   const c = {
-    selectCohort: tdb.selectCohort,
-    // optional
+    selectCohort: getSelectCohort(ds, req),
     supportedChartTypes: tdb.q?.getSupportedChartTypes(req),
     renamedChartTypes: ds.cohort.renamedChartTypes,
     allowedTermTypes: getAllowedTermTypes(ds),
@@ -93,6 +92,9 @@ function make(q, req, res, ds, genome) {
     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);
@@ -257,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
 };