@sjcrh/proteinpaint-server 2.44.0 → 2.46.0

package/routes/termdb.config.js

@@ -0,0 +1,201 @@
+import serverconfig from "#src/serverconfig.js";
+import { authApi } from "#src/auth.js";
+import { get_ds_tdb } from "#src/termdb.js";
+import { mayCopyFromCookie } from "#src/utils.js";
+import { mayComputeTermtypeByCohort } from "#src/termdb.server.init.js";
+const api = {
+  endpoint: "termdb/config",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "any"
+      },
+      response: {
+        typeId: "any"
+      }
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    mayCopyFromCookie(q, req.cookies);
+    try {
+      const genome = genomes[q.genome];
+      if (!genome)
+        throw "invalid genome";
+      const [ds, tdb] = get_ds_tdb(genome, q);
+      return make(q, res, ds, genome);
+    } catch (e) {
+      res.send({ error: e.message || e });
+      if (e.stack)
+        console.log(e.stack);
+      else
+        console.log(e);
+    }
+  };
+}
+function make(q, res, ds, genome) {
+  const tdb = ds.cohort.termdb;
+  const c = {
+    selectCohort: tdb.selectCohort,
+    // optional
+    supportedChartTypes: tdb.q.getSupportedChartTypes(q.embedder),
+    hiddenChartTypes: ds.cohort.hiddenChartTypes,
+    renamedChartTypes: ds.cohort.renamedChartTypes,
+    allowedTermTypes: getAllowedTermTypes(ds),
+    termMatch2geneSet: tdb.termMatch2geneSet,
+    massSessionDuration: serverconfig.features.massSessionDuration || 30,
+    dataDownloadCatch: tdb.dataDownloadCatch,
+    matrix: tdb.matrix,
+    hierCluster: tdb.hierCluster,
+    mclass: tdb.mclass,
+    alwaysRefillCategoricalTermValues: tdb.alwaysRefillCategoricalTermValues,
+    isGeneSetTermdb: tdb.isGeneSetTermdb,
+    lollipop: tdb.lollipop,
+    urlTemplates: tdb.urlTemplates
+  };
+  if (tdb.chartConfigByType)
+    c.chartConfigByType = tdb.chartConfigByType;
+  if (tdb.multipleTestingCorrection)
+    c.multipleTestingCorrection = tdb.multipleTestingCorrection;
+  if (tdb.helpPages)
+    c.helpPages = tdb.helpPages;
+  if (tdb.minTimeSinceDx)
+    c.minTimeSinceDx = tdb.minTimeSinceDx;
+  if (tdb.timeUnit)
+    c.timeUnit = tdb.timeUnit;
+  if (tdb.cohortStartTimeMsg)
+    c.cohortStartTimeMsg = tdb.cohortStartTimeMsg;
+  if (tdb.displaySampleIds)
+    c.displaySampleIds = tdb.displaySampleIds;
+  if (tdb.logscaleBase2)
+    c.logscaleBase2 = tdb.logscaleBase2;
+  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);
+  addGenomicQueries(c, ds, genome);
+  res.send({ termdbConfig: c });
+}
+function addRestrictAncestries(c, tdb) {
+  if (!tdb.restrictAncestries)
+    return;
+  c.restrictAncestries = tdb.restrictAncestries.map((i) => {
+    return { name: i.name, tvs: i.tvs, PCcount: i.PCcount };
+  });
+}
+function addScatterplots(c, ds) {
+  if (!ds.cohort.scatterplots)
+    return;
+  c.scatterplots = ds.cohort.scatterplots.plots.map((p) => {
+    return {
+      name: p.name,
+      dimensions: p.dimensions,
+      colorTW: p.colorTW,
+      shapeTW: p.shapeTW,
+      colorColumn: p.colorColumn
+    };
+  });
+}
+function addMatrixplots(c, ds) {
+  if (!ds.cohort.matrixplots)
+    return;
+  c.matrixplots = ds.cohort.matrixplots.plots.map((p) => {
+    return { name: p.name };
+  });
+}
+function addGenomicQueries(c, ds, genome) {
+  const q = ds.queries;
+  if (!q)
+    return;
+  c.queries = {
+    defaultCoord: q.defaultCoord || genome.defaultcoord
+  };
+  const q2 = c.queries;
+  if (q.defaultBlock2GeneMode)
+    q2.defaultBlock2GeneMode = q.defaultBlock2GeneMode;
+  if (q.snvindel) {
+    q2.snvindel = {
+      allowSNPs: q.snvindel.allowSNPs
+    };
+  }
+  if (q.cnv) {
+    q2.cnv = {};
+    for (const k of [
+      "cnvMaxLength",
+      "cnvGainCutoff",
+      "cnvLossCutoff",
+      "absoluteValueRenderMax",
+      "gainColor",
+      "lossColor"
+    ]) {
+      if (k in q.cnv)
+        q2.cnv[k] = q.cnv[k];
+    }
+  }
+  if (q.topMutatedGenes)
+    q2.topMutatedGenes = q.topMutatedGenes;
+  if (q.topVariablyExpressedGenes)
+    q2.topVariablyExpressedGenes = q.topVariablyExpressedGenes;
+  if (q.singleSampleMutation) {
+    q2.singleSampleMutation = {
+      sample_id_key: q.singleSampleMutation.sample_id_key,
+      discoSkipChrM: q.singleSampleMutation.discoSkipChrM
+    };
+  }
+  if (q.singleSampleGenomeQuantification) {
+    q2.singleSampleGenomeQuantification = {};
+    for (const k in q.singleSampleGenomeQuantification) {
+      q2.singleSampleGenomeQuantification[k] = JSON.parse(JSON.stringify(q.singleSampleGenomeQuantification[k]));
+      delete q2.singleSampleGenomeQuantification[k].folder;
+    }
+  }
+  if (q.singleSampleGbtk) {
+    q2.singleSampleGbtk = {};
+    for (const k in q.singleSampleGbtk) {
+      q2.singleSampleGbtk[k] = JSON.parse(JSON.stringify(q.singleSampleGbtk[k]));
+      delete q2.singleSampleGbtk[k].folder;
+    }
+  }
+  if (q.rnaseqGeneCount) {
+    q2.rnaseqGeneCount = true;
+  }
+  if (q.singleCell) {
+    q2.singleCell = {
+      samples: {
+        firstColumnName: q.singleCell.samples.firstColumnName,
+        sampleColumns: q.singleCell.samples.sampleColumns,
+        experimentColumns: q.singleCell.samples.experimentColumns
+      },
+      data: {
+        sameLegend: q.singleCell.data.sameLegend,
+        refName: q.singleCell.data.refName
+      }
+    };
+  }
+}
+function getAllowedTermTypes(ds) {
+  mayComputeTermtypeByCohort(ds);
+  const typeSet = /* @__PURE__ */ new Set();
+  for (const r of ds.cohort.termdb.termtypeByCohort) {
+    if (r.type)
+      typeSet.add(r.type);
+  }
+  if (ds.cohort.termdb.allowedTermTypes) {
+    for (const t of ds.cohort.termdb.allowedTermTypes)
+      typeSet.add(t);
+  }
+  if (ds?.queries?.defaultBlock2GeneMode) {
+    typeSet.add("geneVariant");
+  }
+  return [...typeSet];
+}
+export {
+  api
+};

package/routes/termdb.getdescrstats.js

@@ -0,0 +1,102 @@
+import { get_rows_by_one_key } from "../src/termdb.sql.js";
+import Summarystats from "../shared/descriptive.stats.js";
+const api = {
+  endpoint: "termdb/descrstats",
+  methods: {
+    all: {
+      init,
+      request: {
+        typeId: "getdescrstatsRequest"
+      },
+      response: {
+        typeId: "getdescrstatsResponse"
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              genome: "hg38-test",
+              dslabel: "TermdbTest",
+              embedder: "localhost",
+              tid: "hrtavg",
+              filter: {
+                type: "tvslst",
+                in: true,
+                join: "",
+                lst: [
+                  {
+                    tag: "cohortFilter",
+                    type: "tvs",
+                    tvs: {
+                      term: {
+                        name: "Cohort",
+                        type: "categorical",
+                        values: { ABC: { label: "ABC" }, XYZ: { label: "XYZ" } },
+                        id: "subcohort",
+                        isleaf: false,
+                        groupsetting: { disabled: true }
+                      },
+                      values: [{ key: "ABC", label: "ABC" }]
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          response: {
+            header: { status: 200 }
+          }
+        }
+      ]
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    try {
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome name";
+      const ds = g.datasets[req.query.dslabel];
+      if (!ds)
+        throw "invalid dataset name";
+      const tdb = ds.cohort.termdb;
+      if (!tdb)
+        throw "invalid termdb object";
+      await trigger_getdescrstats(q, res, ds);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+async function trigger_getdescrstats(q, res, ds) {
+  const term = ds.cohort.termdb.q.termjsonByOneid(q.tid);
+  if (!term)
+    throw "invalid termid";
+  if (term.type != "float" && term.type != "integer")
+    throw "not numerical term";
+  const rows = await get_rows_by_one_key({
+    ds,
+    key: q.tid,
+    filter: q.filter
+  });
+  const values = [];
+  for (const { value } of rows) {
+    if (term.values?.[value]?.uncomputable) {
+      continue;
+    }
+    if (q.settings?.violin?.unit === "log") {
+      if (value === 0) {
+        continue;
+      }
+    }
+    values.push(value);
+  }
+  res.send(Summarystats(values));
+}
+export {
+  api
+};

package/routes/termdb.getnumericcategories.js

@@ -0,0 +1,92 @@
+import * as termdbsql from "#src/termdb.sql.js";
+const api = {
+  endpoint: "termdb/numericcategories",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "getnumericcategoriesRequest"
+      },
+      response: {
+        typeId: "getnumericcategoriesResponse"
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              genome: "hg38-test",
+              dslabel: "TermdbTest",
+              embedder: "localhost",
+              tid: "aaclassic_5",
+              filter: {
+                type: "tvslst",
+                in: true,
+                join: "",
+                lst: [
+                  {
+                    tag: "cohortFilter",
+                    type: "tvs",
+                    tvs: {
+                      term: {
+                        name: "Cohort",
+                        type: "categorical",
+                        values: { ABC: { label: "ABC" }, XYZ: { label: "XYZ" } },
+                        id: "subcohort",
+                        isleaf: false,
+                        groupsetting: { disabled: true }
+                      },
+                      values: [{ key: "ABC", label: "ABC" }]
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          response: {
+            header: { status: 200 }
+          }
+        }
+      ]
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    try {
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome name";
+      const ds = g.datasets[req.query.dslabel];
+      if (!ds)
+        throw "invalid dataset name";
+      const tdb = ds.cohort.termdb;
+      if (!tdb)
+        throw "invalid termdb object";
+      await trigger_getnumericcategories(q, res, tdb, ds);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+async function trigger_getnumericcategories(q, res, tdb, ds) {
+  if (!q.tid)
+    throw ".tid missing";
+  const term = tdb.q.termjsonByOneid(q.tid);
+  const arg = {
+    ds,
+    term_id: q.tid,
+    filter: q.filter
+  };
+  const lst = await termdbsql.get_summary_numericcategories(arg);
+  res.send({ lst });
+}
+export {
+  api
+};

package/routes/termdb.getpercentile.js

@@ -0,0 +1,108 @@
+import * as termdbsql from "../src/termdb.sql.js";
+import computePercentile from "../shared/compute.percentile.js";
+const api = {
+  endpoint: "termdb/getpercentile",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "getpercentileRequest"
+      },
+      response: {
+        typeId: "getpercentileResponse"
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              genome: "hg38-test",
+              dslabel: "TermdbTest",
+              embedder: "localhost",
+              getpercentile: [50],
+              tid: "agedx",
+              filter: {
+                type: "tvslst",
+                in: true,
+                join: "",
+                lst: [
+                  {
+                    tag: "cohortFilter",
+                    type: "tvs",
+                    tvs: {
+                      term: {
+                        name: "Cohort",
+                        type: "categorical",
+                        values: { ABC: { label: "ABC" }, XYZ: { label: "XYZ" } },
+                        id: "subcohort",
+                        isleaf: false,
+                        groupsetting: { disabled: true }
+                      },
+                      values: [{ key: "ABC", label: "ABC" }]
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          response: {
+            header: { status: 200 }
+          }
+        }
+      ]
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    try {
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome name";
+      const ds = g.datasets[req.query.dslabel];
+      if (!ds)
+        throw "invalid dataset name";
+      await trigger_getpercentile(q, res, ds);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+async function trigger_getpercentile(q, res, ds) {
+  const term = ds.cohort.termdb.q.termjsonByOneid(q.tid);
+  if (!term)
+    throw "invalid termid";
+  if (term.type != "float" && term.type != "integer")
+    throw "not numerical term";
+  const percentile_lst = q.getpercentile;
+  const perc_values = [];
+  const values = [];
+  const rows = await termdbsql.get_rows_by_one_key({
+    ds,
+    key: q.tid,
+    filter: q.filter ? typeof q.filter == "string" ? JSON.parse(q.filter) : q.filter : null
+  });
+  for (const { value } of rows) {
+    if (term.values && term.values[value] && term.values[value].uncomputable) {
+      continue;
+    }
+    if (term.skip0forPercentile && value == 0) {
+      continue;
+    }
+    values.push(Number(value));
+  }
+  for (const percentile of percentile_lst) {
+    const perc_value = computePercentile(values, percentile);
+    perc_values.push(perc_value);
+  }
+  res.send({ values: perc_values });
+}
+export {
+  api
+};

package/routes/termdb.getrootterm.js

@@ -0,0 +1,65 @@
+import { get_ds_tdb } from "#src/termdb.js";
+const api = {
+  endpoint: "termdb/rootterm",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "getroottermRequest"
+      },
+      response: {
+        typeId: "getroottermResponse"
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              genome: "hg38-test",
+              dslabel: "TermdbTest",
+              embedder: "localhost",
+              default_rootterm: 1,
+              cohortValues: "ABC"
+            }
+          },
+          response: {
+            header: { status: 200 }
+          }
+        }
+      ]
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    const cohortValues = q.cohortValues ? q.cohortValues : "";
+    const treeFilter = q.treeFilter ? q.treeFilter : "";
+    try {
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome name";
+      const [ds, tdb] = get_ds_tdb(g, q);
+      if (!ds)
+        throw "invalid dataset name";
+      if (!tdb)
+        throw "invalid termdb object";
+      await trigger_rootterm(q, res, tdb);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+async function trigger_rootterm(q, res, tdb) {
+  const cohortValues = q.cohortValues ? q.cohortValues : "";
+  const treeFilter = q.treeFilter ? q.treeFilter : "";
+  res.send({ lst: await tdb.q.getRootTerms(cohortValues, treeFilter) });
+}
+export {
+  api
+};

package/routes/termdb.gettermchildren.js

@@ -0,0 +1,67 @@
+import { copy_term, get_ds_tdb } from "#src/termdb.js";
+const api = {
+  endpoint: "termdb/termchildren",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "gettermchildrenRequest"
+      },
+      response: {
+        typeId: "gettermchildrenResponse"
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              genome: "hg38-test",
+              dslabel: "TermdbTest",
+              embedder: "localhost",
+              get_children: 1,
+              cohortValues: "ABC",
+              tid: "GO:0000001"
+            }
+          },
+          response: {
+            header: { status: 200 }
+          }
+        }
+      ]
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    try {
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome name";
+      const [ds, tdb] = await get_ds_tdb(g, q);
+      if (!ds)
+        throw "invalid dataset name";
+      if (!tdb)
+        throw "invalid termdb object";
+      await trigger_children(q, res, tdb);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+async function trigger_children(q, res, tdb) {
+  if (!q.tid)
+    throw "no parent term id";
+  const cohortValues = q.cohortValues ? q.cohortValues : "";
+  const treeFilter = q.treeFilter ? q.treeFilter : "";
+  const terms = await tdb.q.getTermChildren(q.tid, cohortValues, treeFilter);
+  res.send({ lst: terms.map(copy_term) });
+}
+export {
+  api
+};

package/routes/termdb.singleSampleMutation.js

@@ -0,0 +1,80 @@
+import fs from "fs";
+import path from "path";
+import { read_file } from "#src/utils.js";
+import serverconfig from "#src/serverconfig.js";
+import { gdcValidate_query_singleSampleMutation } from "#src/mds3.gdc.js";
+const api = {
+  endpoint: "termdb/singleSampleMutation",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "TermdbSingleSampleMutationRequest"
+      },
+      response: {
+        typeId: "TermdbSingleSampleMutationResponse"
+      }
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    let result;
+    try {
+      const g = genomes[q.genome];
+      if (!g)
+        throw "invalid genome name";
+      const ds = g.datasets[q.dslabel];
+      if (!ds)
+        throw "invalid dataset name";
+      if (!ds.queries?.singleSampleMutation)
+        throw "not supported on this dataset";
+      result = await ds.queries.singleSampleMutation.get(q);
+    } catch (e) {
+      if (e.stack)
+        console.log(e.stack);
+      result = {
+        status: e.status || 400,
+        error: e.message || e
+      };
+    }
+    res.send(result);
+  };
+}
+async function validate_query_singleSampleMutation(ds, genome) {
+  const _q = ds.queries.singleSampleMutation;
+  if (!_q)
+    return;
+  if (_q.src == "gdcapi") {
+    gdcValidate_query_singleSampleMutation(ds, genome);
+  } else if (_q.src == "native") {
+    _q.get = async (q) => {
+      let fileName = q.sample;
+      if (ds.cohort?.termdb?.q?.sampleName2id) {
+        fileName = ds.cohort.termdb.q.sampleName2id(q.sample);
+        if (fileName == void 0) {
+          return [];
+        }
+      }
+      const file = path.join(serverconfig.tpmasterdir, _q.folder, fileName.toString());
+      try {
+        await fs.promises.stat(file);
+      } catch (e) {
+        if (e.code == "EACCES")
+          throw "cannot read file, permission denied";
+        if (e.code == "ENOENT")
+          throw "no data for this sample";
+        throw "failed to load data";
+      }
+      const data = await read_file(file);
+      return { mlst: JSON.parse(data) };
+    };
+  } else {
+    throw "unknown singleSampleMutation.src";
+  }
+}
+export {
+  api,
+  validate_query_singleSampleMutation
+};