@sjcrh/proteinpaint-server 2.81.4-0 → 2.81.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.81.4-0",
+  "version": "2.81.5",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -43,7 +43,7 @@
     "@babel/preset-env": "^7.9.6",
     "@babel/preset-typescript": "^7.21.4",
     "@babel/register": "^7.14.5",
-    "@sjcrh/proteinpaint-types": "2.81.0",
+    "@sjcrh/proteinpaint-types": "2.81.5",
     "@types/node": "^20.11.24",
     "@types/tough-cookie": "^4.0.5",
     "@typescript-eslint/eslint-plugin": "^5.60.0",
@@ -63,7 +63,7 @@
   },
   "dependencies": {
     "@sjcrh/augen": "2.46.0",
-    "@sjcrh/proteinpaint-rust": "2.78.0",
+    "@sjcrh/proteinpaint-rust": "2.81.5",
     "@sjcrh/proteinpaint-shared": "2.79.4",
     "better-sqlite3": "^9.4.1",
     "body-parser": "^1.15.2",

package/routes/genesetOverrepresentation.js

@@ -37,6 +37,7 @@ async function run_genesetOverrepresentation_analysis(q, genomes) {
     sample_genes: q.sample_genes,
     msigdb: genomes[q.genome].termdbs.msigdb.cohort.db.connection.name,
     gene_set_group: q.geneSetGroup,
+    filter_non_coding_genes: q.filter_non_coding_genes,
     genedb: path.join(serverconfig.tpmasterdir, genomes[q.genome].genedb.dbfile)
   };
   if (q.background_genes) {

package/routes/termdb.DE.js

@@ -43,6 +43,7 @@ async function run_DE(param, ds) {
     throw "samplelst.groups[0].values.length<1";
   if (param.samplelst.groups[1].values?.length < 1)
     throw "samplelst.groups[1].values.length<1";
+  param.storage_type = ds.queries.rnaseqGeneCount.storage_type;
   const q = ds.queries.rnaseqGeneCount;
   if (!q)
     return;
@@ -83,9 +84,11 @@ async function run_DE(param, ds) {
   const expression_input = {
     case: cases_string,
     control: controls_string,
+    data_type: "do_DE",
     input_file: q.file,
     min_count: param.min_count,
-    min_total_count: param.min_total_count
+    min_total_count: param.min_total_count,
+    storage_type: param.storage_type
   };
   const sample_size_limit = 8;
   let result;

package/routes/termdb.boxplot.js

@@ -0,0 +1,123 @@
+import { getData } from "../src/termdb.matrix.js";
+import { boxplot_getvalue } from "../src/utils.js";
+import { sortKey2values } from "../src/termdb.violin.js";
+const api = {
+  endpoint: "termdb/boxplot",
+  methods: {
+    all: {
+      init,
+      request: {
+        typeId: "BoxplotRequest"
+      },
+      response: {
+        typeId: "BoxplotResponse"
+      },
+      examples: []
+    }
+  }
+};
+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 terms = [q.tw];
+      if (q.divideTw)
+        terms.push(q.divideTw);
+      const data = await getData(
+        {
+          filter: q.filter,
+          filter0: q.filter0,
+          terms
+        },
+        ds,
+        genome
+      );
+      if (data.error)
+        throw data.error;
+      const sampleType = `All ${data.sampleType?.plural_name || "samples"}`;
+      const key2values = /* @__PURE__ */ new Map();
+      const overlayTerm = q.divideTw;
+      for (const [key, val] of Object.entries(data.samples)) {
+        const value = val[q.tw.$id];
+        if (!Number.isFinite(value?.value))
+          continue;
+        if (overlayTerm) {
+          if (!val[overlayTerm?.$id])
+            continue;
+          const value2 = val[overlayTerm.$id];
+          if (!key2values.has(value2.key))
+            key2values.set(value2.key, []);
+          key2values.get(value2.key).push(value.value);
+        } else {
+          if (!key2values.has(sampleType))
+            key2values.set(sampleType, []);
+          key2values.get(sampleType).push(value.value);
+        }
+      }
+      const plots = [];
+      let absMin, absMax, maxLabelLgth;
+      for (const [key, values] of sortKey2values(data, key2values, overlayTerm)) {
+        const sortedValues = values.sort((a, b) => a - b);
+        if (!absMin || sortedValues[0] < absMin)
+          absMin = sortedValues[0];
+        if (!absMax || sortedValues[sortedValues.length - 1] > absMax)
+          absMax = sortedValues[sortedValues.length - 1];
+        const vs = sortedValues.map((v) => {
+          const value = { value: v };
+          return value;
+        });
+        if (overlayTerm) {
+          let label = overlayTerm?.term?.values?.[key]?.label || key;
+          label = `${label}, n=${values.length}`;
+          if (!maxLabelLgth || label.length > maxLabelLgth.length)
+            maxLabelLgth = label.length;
+          const plot = {
+            // label,
+            // values,
+            seriesId: key,
+            color: overlayTerm?.term?.values?.[key]?.color || null,
+            boxplot: boxplot_getvalue(vs),
+            //Need sd and mean?
+            // plotValueCount: values.length,
+            min: sortedValues[0],
+            max: sortedValues[sortedValues.length - 1]
+          };
+          plot.boxplot.label = label;
+          plots.push(plot);
+        } else {
+          const label = `${sampleType}, n=${values.length}`;
+          if (!maxLabelLgth || label.length > maxLabelLgth.length)
+            maxLabelLgth = label.length;
+          const plot = {
+            // label,
+            // values,
+            // plotValueCount: values.length,
+            boxplot: boxplot_getvalue(vs),
+            min: sortedValues[0],
+            max: sortedValues[sortedValues.length - 1]
+          };
+          plot.boxplot.label = label;
+          plots.push(plot);
+        }
+      }
+      data.plots = plots;
+      data.absMin = absMin;
+      data.absMax = absMax;
+      data.maxLabelLgth = maxLabelLgth;
+      res.send(data);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+export {
+  api
+};

package/routes/termdb.cluster.js

@@ -72,18 +72,21 @@ async function getResult(q, ds) {
     return { term: { gene: g, type: TermTypes.GENE_EXPRESSION }, data: term2sample2value.get(g) };
   }
   const t = Date.now();
-  const clustering = await doClustering(term2sample2value, q);
+  const clustering = await doClustering(term2sample2value, q, Object.keys(bySampleId).length);
   if (serverconfig.debugmode)
     console.log("clustering done:", Date.now() - t, "ms");
   return { clustering, byTermId, bySampleId };
 }
-async function doClustering(data, q) {
+async function doClustering(data, q, numCases = 1e3) {
   const sampleSet = /* @__PURE__ */ new Set();
   for (const o of data.values()) {
     for (const s in o)
       sampleSet.add(s);
-    break;
+    if (sampleSet.size >= numCases)
+      break;
   }
+  if (sampleSet.size == 0)
+    throw "termdb.cluster: no samples";
   if (!clusterMethodLst.find((i) => i.value == q.clusterMethod))
     throw "Invalid cluster method";
   if (!distanceMethodLst.find((i) => i.value == q.distanceMethod))
@@ -107,6 +110,8 @@ async function doClustering(data, q) {
     }
     inputData.matrix.push(getZscore(row));
   }
+  if (inputData.matrix.length == 0)
+    throw "Clustering matrix is empty";
   const Routput = JSON.parse(
     await run_R(path.join(serverconfig.binpath, "utils", "hclust.R"), JSON.stringify(inputData))
   );

package/routes/termdb.config.js

@@ -64,8 +64,8 @@ function make(q, res, ds, genome) {
     hasSampleAncestry: ds.cohort.termdb.hasSampleAncestry,
     defaultChartType: ds.cohort.defaultChartType
   };
-  if (tdb.chartConfigByType)
-    c.chartConfigByType = tdb.chartConfigByType;
+  if (tdb.plotConfigByCohort)
+    c.plotConfigByCohort = tdb.plotConfigByCohort;
   if (tdb.multipleTestingCorrection)
     c.multipleTestingCorrection = tdb.multipleTestingCorrection;
   if (tdb.neuroOncRegression)
@@ -222,7 +222,7 @@ function addNonDictionaryQueries(c, ds, genome) {
         width: q.singleCell.data.width,
         height: q.singleCell.data.height,
         plots: q.singleCell.data.plots.map((p) => {
-          return { name: p.name, colorColumns: p.colorColumns.map((c2) => c2.name) };
+          return { name: p.name, colorColumns: p.colorColumns.map((c2) => c2.name), selected: p.selected };
         })
       }
     };

package/routes/termdb.topVariablyExpressedGenes.js

@@ -3,6 +3,7 @@ import serverconfig from "#src/serverconfig.js";
 import { get_samples } from "#src/termdb.sql.js";
 import { makeFilter } from "#src/mds3.gdc.js";
 import { cachedFetch } from "#src/utils.js";
+import { joinUrl } from "#src/helpers.ts";
 const api = {
   endpoint: "termdb/topVariablyExpressedGenes",
   methods: {
@@ -181,10 +182,9 @@ function gdcValidateQuery(ds, genome) {
       throw "The server has not finished caching the case IDs: try again in about 2 minutes.";
     }
     const { host, headers } = ds.getHostHeaders(q);
-    const url = `${host.geneExp}/gene_expression/gene_selection`;
     try {
       const response = await cachedFetch(
-        url,
+        joinUrl(host.geneExp, "/gene_expression/gene_selection"),
         {
           method: "POST",
           headers,