@sjcrh/proteinpaint-server 2.97.0 → 2.98.1-0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.97.0",
+  "version": "2.98.1-0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -42,7 +42,6 @@
     "@babel/preset-env": "^7.9.6",
     "@babel/preset-typescript": "^7.21.4",
     "@babel/register": "^7.14.5",
-    "@sjcrh/proteinpaint-types": "2.96.2-0",
     "@types/node": "^20.11.24",
     "@types/tough-cookie": "^4.0.5",
     "@typescript-eslint/eslint-plugin": "^8.13.0",
@@ -61,7 +60,8 @@
   "dependencies": {
     "@sjcrh/augen": "2.87.0",
     "@sjcrh/proteinpaint-rust": "2.84.0",
-    "@sjcrh/proteinpaint-shared": "2.96.0",
+    "@sjcrh/proteinpaint-shared": "2.98.0",
+    "@sjcrh/proteinpaint-types": "2.98.1-0",
     "better-sqlite3": "^9.4.1",
     "body-parser": "^1.15.2",
     "canvas": "~2.11.2",

package/routes/termdb.boxplot.js

@@ -1,7 +1,7 @@
 import { boxplotPayload } from "#types/checkers";
 import { getData } from "../src/termdb.matrix.js";
 import { boxplot_getvalue } from "../src/utils.js";
-import { sortKey2values } from "../src/termdb.violin.js";
+import { sortKey2values } from "./termdb.violin.ts";
 import { roundValueAuto } from "#shared/roundValue.js";
 const api = {
   endpoint: "termdb/boxplot",
@@ -41,43 +41,18 @@ function init({ genomes }) {
       if (data.error)
         throw data.error;
       const sampleType = `All ${data.sampleType?.plural_name || "samples"}`;
-      const key2values = /* @__PURE__ */ new Map();
       const overlayTerm = q.overlayTw;
-      const uncomputableValues = {};
-      for (const val of Object.values(data.samples)) {
-        const value = val[q.tw.$id];
-        if (!Number.isFinite(value?.value))
-          continue;
-        if (q.tw.term.values?.[value.value]?.uncomputable) {
-          const label = q.tw.term.values[value.value].label;
-          uncomputableValues[label] = (uncomputableValues[label] || 0) + 1;
-          continue;
-        }
-        if (overlayTerm) {
-          if (!val[overlayTerm?.$id])
-            continue;
-          const value2 = val[overlayTerm.$id];
-          if (overlayTerm.term?.values?.[value2.key]?.uncomputable) {
-            const label = overlayTerm.term.values[value2?.key]?.label;
-            uncomputableValues[label] = (uncomputableValues[label] || 0) + 1;
-          }
-          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 isLog = false;
+      const { absMin, absMax, key2values, uncomputableValues } = parseValues(
+        q,
+        data,
+        sampleType,
+        isLog,
+        overlayTerm
+      );
       const plots = [];
-      let absMin = null, absMax = null;
       for (const [key, values] of sortKey2values(data, key2values, overlayTerm)) {
         const sortedValues = values.sort((a, b) => a - b);
-        if (absMin === null || sortedValues[0] < absMin)
-          absMin = sortedValues[0];
-        if (absMax === null || sortedValues[sortedValues.length - 1] > absMax)
-          absMax = sortedValues[sortedValues.length - 1];
         const vs = sortedValues.map((v) => {
           const value = { value: v };
           return value;
@@ -179,10 +154,50 @@ function setUncomputableValues(values) {
   } else
     return null;
 }
+function parseValues(q, data, sampleType, isLog, overlayTerm) {
+  const key2values = /* @__PURE__ */ new Map();
+  const uncomputableValues = {};
+  let absMin = null, absMax = null;
+  for (const val of Object.values(data.samples)) {
+    const value = val[q.tw.$id];
+    if (!Number.isFinite(value?.value))
+      continue;
+    if (q.tw.term.values?.[value.value]?.uncomputable) {
+      const label = q.tw.term.values[value.value].label;
+      uncomputableValues[label] = (uncomputableValues[label] || 0) + 1;
+      continue;
+    }
+    if (isLog && value.value <= 0)
+      continue;
+    if (overlayTerm) {
+      if (!val[overlayTerm?.$id])
+        continue;
+      const value2 = val[overlayTerm.$id];
+      if (overlayTerm.term?.values?.[value2.key]?.uncomputable) {
+        const label = overlayTerm.term.values[value2?.key]?.label;
+        uncomputableValues[label] = (uncomputableValues[label] || 0) + 1;
+      }
+      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);
+    }
+    if (absMin === null || value.value < absMin)
+      absMin = value.value;
+    if (absMax === null || value.value > absMax)
+      absMax = value.value;
+  }
+  return { absMax, absMin, key2values, uncomputableValues };
+}
 function numericBins(overlayTerm, data) {
   const overlayBins = data.refs.byTermId[overlayTerm?.$id]?.bins ?? [];
   return new Map(overlayBins.map((bin) => [bin.label, bin]));
 }
 export {
-  api
+  api,
+  numericBins,
+  parseValues
 };

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,12 @@ 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),
+    supportedChartTypes: tdb.q?.getSupportedChartTypes(req),
     renamedChartTypes: ds.cohort.renamedChartTypes,
     allowedTermTypes: getAllowedTermTypes(ds),
     termMatch2geneSet: tdb.termMatch2geneSet,
@@ -68,8 +67,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 +87,19 @@ 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;
-  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) {

package/routes/termdb.violin.js

@@ -1,5 +1,13 @@
 import { violinPayload } from "#types/checkers";
-import { trigger_getViolinPlotData } from "#src/termdb.violin.js";
+import { scaleLinear, scaleLog } from "d3";
+import { run_rust } from "@sjcrh/proteinpaint-rust";
+import { getData } from "../src/termdb.matrix.js";
+import { createCanvas } from "canvas";
+import { getOrderedLabels } from "../src/termdb.barchart.js";
+import summaryStats from "#shared/descriptive.stats.js";
+import { isNumericTerm } from "#shared/terms.js";
+import { getBinsDensity } from "#shared/violin.bins.js";
+import { numericBins, parseValues } from "./termdb.boxplot.ts";
 const api = {
   endpoint: "termdb/violin",
   methods: {
@@ -24,7 +32,7 @@ function init({ genomes }) {
       const ds = g.datasets?.[q.dslabel];
       if (!ds)
         throw "invalid ds";
-      data = await trigger_getViolinPlotData(q, null, ds, g);
+      data = await trigger_getViolinPlotData(q, ds, g);
     } catch (e) {
       data = { error: e?.message || e };
       if (e instanceof Error && e.stack)
@@ -33,6 +41,193 @@ function init({ genomes }) {
     res.send(data);
   };
 }
+async function trigger_getViolinPlotData(q, ds, genome) {
+  if (typeof q.tw?.term != "object" || typeof q.tw?.q != "object")
+    throw "q.tw not of {term,q}";
+  const term = q.tw.term;
+  if (!q.tw.q.mode)
+    q.tw.q.mode = "continuous";
+  if (!isNumericTerm(term) && term.type !== "survival")
+    throw "term type is not numeric or survival";
+  const terms = [q.tw];
+  if (q.divideTw)
+    terms.push(q.divideTw);
+  const data = await getData(
+    { terms, filter: q.filter, filter0: q.filter0, currentGeneNames: q.currentGeneNames },
+    ds,
+    genome
+  );
+  const sampleType = `All ${data.sampleType?.plural_name || "samples"}`;
+  if (data.error)
+    throw data.error;
+  if (q.divideTw && data.refs.byTermId[q.divideTw.$id]) {
+    data.refs.byTermId[q.divideTw.$id].orderedLabels = getOrderedLabels(
+      q.divideTw,
+      data.refs.byTermId[q.divideTw.$id]?.bins,
+      void 0,
+      q.divideTw.q
+    );
+  }
+  if (q.scale)
+    setScaleData(q, data, q.tw);
+  const valuesObject = divideValues(q, data, sampleType);
+  const result = setResponse(valuesObject, data, q, sampleType);
+  await getWilcoxonData(q.divideTw, result);
+  createCanvasImg(q, result, ds);
+  return result;
+}
+async function getWilcoxonData(divideTw, result) {
+  if (!divideTw)
+    return;
+  const numPlots = result.plots.length;
+  if (numPlots < 2)
+    return;
+  const wilcoxInput = [];
+  for (let i = 0; i < numPlots; i++) {
+    const group1_id = result.plots[i].label;
+    const group1_values = result.plots[i].values;
+    for (let j = i + 1; j < numPlots; j++) {
+      const group2_id = result.plots[j].label;
+      const group2_values = result.plots[j].values;
+      wilcoxInput.push({ group1_id, group1_values, group2_id, group2_values });
+    }
+  }
+  const wilcoxOutput = JSON.parse(await run_rust("wilcoxon", JSON.stringify(wilcoxInput)));
+  for (const test of wilcoxOutput) {
+    if (test.pvalue == null || test.pvalue == "null") {
+      result.pvalues.push([{ value: test.group1_id }, { value: test.group2_id }, { html: "NA" }]);
+    } else {
+      result.pvalues.push([{ value: test.group1_id }, { value: test.group2_id }, { html: test.pvalue.toPrecision(4) }]);
+    }
+  }
+}
+function setScaleData(q, data, tw) {
+  if (!q.scale)
+    return;
+  const scale = Number(q.scale);
+  for (const val of Object.values(data.samples)) {
+    if (!tw.$id || !val[tw.$id])
+      continue;
+    if (tw.term.values?.[val[tw.$id]?.value]?.uncomputable)
+      continue;
+    val[tw.$id].key = val[tw.$id].key / scale;
+    val[tw.$id].value = val[tw.$id].value / scale;
+  }
+}
+function divideValues(q, data, sampleType) {
+  const overlayTerm = q.divideTw;
+  const useLog = q.unit == "log";
+  const { absMax, absMin, key2values, uncomputableValues } = parseValues(q, data, sampleType, useLog, overlayTerm);
+  return {
+    key2values,
+    min: absMin,
+    max: absMax,
+    uncomputableValues: sortObj(uncomputableValues)
+  };
+}
+function sortObj(object) {
+  return Object.fromEntries(Object.entries(object).sort(([, a], [, b]) => a - b));
+}
+function sortKey2values(data, key2values, overlayTerm) {
+  const orderedLabels = overlayTerm?.$id ? data.refs.byTermId[overlayTerm.$id]?.keyOrder : void 0;
+  key2values = new Map(
+    [...key2values].sort(
+      orderedLabels ? (a, b) => orderedLabels.indexOf(a[0]) - orderedLabels.indexOf(b[0]) : overlayTerm?.term?.type === "categorical" ? (a, b) => b[1].length - a[1].length : overlayTerm?.term?.type === "condition" ? (a, b) => Number(a[0]) - Number(b[0]) : (a, b) => a.toString().replace(/[^a-zA-Z0-9<]/g, "").localeCompare(b.toString().replace(/[^a-zA-Z0-9<]/g, ""), void 0, { numeric: true })
+    )
+  );
+  return key2values;
+}
+function setResponse(valuesObject, data, q, sampleType) {
+  const overlayTerm = q.divideTw;
+  const plots = [];
+  for (const [key, values] of sortKey2values(data, valuesObject.key2values, overlayTerm)) {
+    if (overlayTerm) {
+      plots.push({
+        label: overlayTerm?.term?.values?.[key]?.label || key,
+        values,
+        seriesId: key,
+        plotValueCount: values?.length,
+        color: overlayTerm?.term?.values?.[key]?.color || null,
+        divideTwBins: isNumericTerm(overlayTerm.term) ? numericBins(overlayTerm, data) : null
+      });
+    } else {
+      plots.push({
+        label: sampleType,
+        values,
+        plotValueCount: values.length
+      });
+    }
+  }
+  const result = {
+    min: valuesObject.min,
+    max: valuesObject.max,
+    plots,
+    pvalues: [],
+    uncomputableValues: Object.keys(valuesObject.uncomputableValues).length > 0 ? valuesObject.uncomputableValues : null
+  };
+  return result;
+}
+function createCanvasImg(q, result, ds) {
+  if (!q.radius)
+    q.radius = 5;
+  if (q.radius <= 0)
+    throw "q.radius is not a number";
+  else
+    q.radius = +q.radius;
+  if (!q.strokeWidth)
+    q.strokeWidth = 0.2;
+  const refSize = q.radius * 4;
+  let axisScale;
+  const useLog = q.unit == "log";
+  if (useLog) {
+    axisScale = scaleLog().base(ds.cohort.termdb.logscaleBase2 ? 2 : 10).domain([result.min, result.max]).range(q.orientation === "horizontal" ? [0, q.svgw] : [q.svgw, 0]);
+  } else {
+    axisScale = scaleLinear().domain([result.min, result.max]).range(q.orientation === "horizontal" ? [0, q.svgw] : [q.svgw, 0]);
+  }
+  const [width, height] = q.orientation == "horizontal" ? [q.svgw * q.devicePixelRatio, refSize * q.devicePixelRatio] : [refSize * q.devicePixelRatio, q.svgw * q.devicePixelRatio];
+  const scaledRadius = q.radius / q.devicePixelRatio;
+  const arcEndAngle = scaledRadius * Math.PI;
+  for (const plot of result.plots) {
+    const canvas = createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    ctx.strokeStyle = "rgba(0,0,0,0.8)";
+    ctx.lineWidth = q.strokeWidth / q.devicePixelRatio;
+    ctx.globalAlpha = 0.5;
+    ctx.fillStyle = "#ffe6e6";
+    if (q.devicePixelRatio != 1) {
+      ctx.scale(q.devicePixelRatio, q.devicePixelRatio);
+    }
+    if (q.datasymbol === "rug")
+      plot.values.forEach((i) => {
+        ctx.beginPath();
+        if (q.orientation == "horizontal") {
+          ctx.moveTo(+axisScale(i), 0);
+          ctx.lineTo(+axisScale(i), scaledRadius * 2);
+        } else {
+          ctx.moveTo(0, +axisScale(i));
+          ctx.lineTo(scaledRadius * 2, +axisScale(i));
+        }
+        ctx.stroke();
+      });
+    else if (q.datasymbol === "bean")
+      plot.values.forEach((i) => {
+        ctx.beginPath();
+        if (q.orientation === "horizontal")
+          ctx.arc(+axisScale(i), q.radius, scaledRadius, 0, arcEndAngle);
+        else
+          ctx.arc(q.radius, +axisScale(i), scaledRadius, 0, arcEndAngle);
+        ctx.fill();
+        ctx.stroke();
+      });
+    plot.src = canvas.toDataURL();
+    plot.density = getBinsDensity(axisScale, plot, q.isKDE, q.ticks);
+    plot.summaryStats = summaryStats(plot.values).values;
+    delete plot.values;
+  }
+}
 export {
-  api
+  api,
+  getWilcoxonData,
+  sortKey2values,
+  trigger_getViolinPlotData
 };