@sjcrh/proteinpaint-server 2.44.0 → 2.46.1

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
+};

package/routes/termdb.singlecellData.js

@@ -0,0 +1,46 @@
+const api = {
+  endpoint: "termdb/singlecellData",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "TermdbSinglecellDataRequest"
+      },
+      response: {
+        typeId: "TermdbSinglecellDataResponse"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+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?.singleCell)
+        throw "no singlecell data on this dataset";
+      result = await ds.queries.singleCell.data.get(q);
+    } catch (e) {
+      if (e.stack)
+        console.log(e);
+      result = {
+        status: e.status || 400,
+        error: e.message || e
+      };
+    }
+    res.send(result);
+  };
+}
+export {
+  api
+};

package/routes/termdb.singlecellSamples.js

@@ -0,0 +1,160 @@
+import fs from "fs";
+import path from "path";
+import { read_file } from "#src/utils.js";
+import serverconfig from "#src/serverconfig.js";
+import { gdc_validate_query_singleCell_samples, gdc_validate_query_singleCell_data } from "#src/mds3.gdc.js";
+const api = {
+  endpoint: "termdb/singlecellSamples",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "TermdbSinglecellsamplesRequest"
+      },
+      response: {
+        typeId: "TermdbSinglecellsamplesResponse"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+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?.singleCell)
+        throw "no singlecell data on this dataset";
+      result = await ds.queries.singleCell.samples.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_singleCell(ds, genome) {
+  const q = ds.queries.singleCell;
+  if (!q)
+    return;
+  if (q.samples.src == "gdcapi") {
+    gdc_validate_query_singleCell_samples(ds, genome);
+  } else if (q.samples.src == "native") {
+    getSamplesNative(q.samples, ds);
+  } else {
+    throw "unknown singleCell.samples.src";
+  }
+  if (q.data.src == "gdcapi") {
+    gdc_validate_query_singleCell_data(ds, genome);
+  } else if (q.data.src == "native") {
+    getDataNative(q.data, ds);
+  } else {
+    throw "unknown singleCell.data.src";
+  }
+}
+async function getSamplesNative(S, ds) {
+  const isSamples = ds.cohort.termdb.q.getAllValues4term(S.isSampleTerm);
+  if (isSamples.size == 0)
+    throw "no samples found that are identified by isSampleTerm";
+  const samples = [];
+  for (const sampleid of isSamples.keys()) {
+    if (isSamples.get(sampleid) == "1")
+      samples.push({
+        sample: ds.cohort.termdb.q.id2sampleName(sampleid),
+        // string name for display
+        sampleid
+        // temporarily kept to assign term value to each sample
+      });
+  }
+  if (S.sampleColumns) {
+    for (const term of S.sampleColumns) {
+      const s2v = ds.cohort.termdb.q.getAllValues4term(term.termid);
+      for (const s of samples) {
+        if (s2v.has(s.sampleid))
+          s[term.termid] = s2v.get(s.sampleid);
+      }
+    }
+  }
+  for (const s of samples)
+    delete s.sampleid;
+  S.get = () => {
+    return { samples };
+  };
+}
+function getDataNative(D, ds) {
+  const nameSet = /* @__PURE__ */ new Set();
+  for (const plot of D.plots) {
+    if (nameSet.has(plot.name))
+      throw "duplicate plot.name";
+    nameSet.add(plot.name);
+  }
+  const _terms = [];
+  for (const tid of D.termIds) {
+    const t = ds.cohort.termdb.q.termjsonByOneid(tid);
+    if (!t)
+      throw "invalid term id from queries.singleCell.data.termIds[]";
+    _terms.push(t);
+  }
+  D.get = async (q) => {
+    try {
+      const tid2cellvalue = {};
+      for (const tid of D.termIds)
+        tid2cellvalue[tid] = {};
+      const plots = [];
+      for (const plot of D.plots) {
+        const tsvfile = path.join(serverconfig.tpmasterdir, plot.folder, q.sample + plot.fileSuffix);
+        try {
+          await fs.promises.stat(tsvfile);
+        } catch (e) {
+          if (e.code == "ENOENT") {
+            continue;
+          }
+          if (e.code == "EACCES")
+            throw "cannot read file, permission denied";
+          throw "failed to load sc data file";
+        }
+        const lines = (await read_file(tsvfile)).trim().split("\n");
+        const cells = [];
+        for (let i = 1; i < lines.length; i++) {
+          const l = lines[i].split("	");
+          const cellId = l[0], x = Number(l[plot.coordsColumns.x]), y = Number(l[plot.coordsColumns.y]);
+          const category = l[plot.colorColumn?.index] || "";
+          if (!cellId)
+            throw "cell id missing";
+          if (!Number.isFinite(x) || !Number.isFinite(y))
+            throw "x/y not number";
+          cells.push({ cellId, x, y, category });
+          for (const tid of D.termIds) {
+            tid2cellvalue[tid][cellId] = l[1];
+          }
+        }
+        plots.push({ name: plot.name, cells, colorBy: plot.colorColumn?.name, colorMap: plot.colorColumn?.colorMap });
+      }
+      if (plots.length == 0) {
+        return { nodata: true };
+      }
+      return { plots, terms: _terms, tid2cellvalue };
+    } catch (e) {
+      if (e.stack)
+        console.log(e.stack);
+      return { error: e.message || e };
+    }
+  };
+}
+export {
+  api,
+  validate_query_singleCell
+};

package/routes/termdb.termsbyids.js

@@ -0,0 +1,59 @@
+import { copy_term } from "#src/termdb.js";
+const api = {
+  endpoint: "termdb/termsbyids",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "gettermsbyidsRequest"
+      },
+      response: {
+        typeId: "gettermsbyidsResponse"
+      }
+    },
+    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_gettermsbyid(q, res, tdb);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+async function trigger_gettermsbyid(q, res, tdb) {
+  const terms = {};
+  for (const id of q.ids) {
+    const term = tdb.q.termjsonByOneid(id);
+    if (term) {
+      if (term.type == "categorical" && !term.values && !term.groupsetting?.inuse) {
+        term.values = {};
+        term.samplecount = {};
+      }
+    }
+    terms[id] = term ? copy_term(term) : void 0;
+  }
+  res.send({
+    terms
+  });
+}
+export {
+  api
+};

package/routes/termdb.topVariablyExpressedGenes.js

@@ -0,0 +1,171 @@
+import { gdcGetCasesWithExressionDataFromCohort } from "../src/mds3.gdc.js";
+import path from "path";
+import { run_rust } from "@sjcrh/proteinpaint-rust";
+import got from "got";
+import serverconfig from "#src/serverconfig.js";
+import { get_samples } from "#src/termdb.sql.js";
+const api = {
+  endpoint: "termdb/topVariablyExpressedGenes",
+  methods: {
+    all: {
+      init,
+      request: {
+        typeId: "TermdbTopVariablyExpressedGenesRequest"
+      },
+      response: {
+        typeId: "TermdbTopVariablyExpressedGenesResponse"
+      }
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const q = req.query;
+      const genome = genomes[q.genome];
+      if (!genome)
+        throw "invalid genome";
+      const ds = genome.datasets?.[q.dslabel];
+      if (!ds)
+        throw "invalid dslabel";
+      if (!ds.queries?.topVariablyExpressedGenes)
+        throw "not supported on dataset";
+      const t = Date.now();
+      const genes = await ds.queries.topVariablyExpressedGenes.getGenes(q);
+      if (serverconfig.debugmode)
+        console.log("topVariablyExpressedGenes", Date.now() - t, "ms");
+      res.send({ genes });
+    } catch (e) {
+      res.send({ status: "error", error: e.message || e });
+    }
+  };
+}
+function validate_query_TopVariablyExpressedGenes(ds, genome) {
+  const q = ds.queries.topVariablyExpressedGenes;
+  if (!q)
+    return;
+  if (q.src == "gdcapi") {
+    gdcValidateQuery(ds, genome);
+  } else if (q.src == "native") {
+    nativeValidateQuery(ds, genome);
+  } else {
+    throw "unknown topVariablyExpressedGenes.src";
+  }
+}
+function nativeValidateQuery(ds, genome) {
+  const gE = ds.queries.geneExpression;
+  if (!gE)
+    throw "topVariablyExpressedGenes query given but geneExpression missing";
+  if (gE.src != "native")
+    throw "topVariablyExpressedGenes is native but geneExpression.src is not native";
+  ds.queries.topVariablyExpressedGenes.getGenes = async (q) => {
+    const samples = [];
+    if (q.filter) {
+      const sidlst = await get_samples(q.filter, ds);
+      for (const i of sidlst) {
+        if (gE.samples.includes(i.id)) {
+          const n = ds.cohort.termdb.q.id2sampleName(i.id);
+          if (!n)
+            throw "sample id cannot convert to string name";
+          samples.push(n);
+        }
+      }
+    } else {
+      for (const i of gE.samples) {
+        const n = ds.cohort.termdb.q.id2sampleName(i.id);
+        if (!n)
+          throw "sample id cannot convert to string name";
+        samples.push(n);
+      }
+    }
+    const genes = await computeGenes4nativeDs(q, ds, gE.file, samples);
+    return genes;
+  };
+}
+async function computeGenes4nativeDs(q, ds, matrixFile, samples) {
+  const input_json = {
+    input_file: matrixFile,
+    samples: samples.join(","),
+    filter_extreme_values: true,
+    num_genes: Number(q.maxGenes),
+    param: "var"
+  };
+  const rust_output = await run_rust("topGeneByExpressionVariance", JSON.stringify(input_json));
+  const rust_output_list = rust_output.split("\n");
+  let output_json;
+  for (const item of rust_output_list) {
+    if (item.includes("output_json:")) {
+      output_json = JSON.parse(item.replace("output_json:", ""));
+    } else {
+      console.log(item);
+    }
+  }
+  const varGenes = output_json.map((i) => i.gene_symbol);
+  return varGenes;
+}
+function gdcValidateQuery(ds, genome) {
+  ds.queries.topVariablyExpressedGenes.getGenes = async (q) => {
+    if (serverconfig.features.gdcGenes) {
+      console.log("!!GDC!! using serverconfig.features.gdcGenes[]");
+      return serverconfig.features.gdcGenes;
+    }
+    if (!ds.__gdc.doneCaching)
+      throw "The server has not finished caching the case IDs: try again in ~2 minutes";
+    const caseLst = await gdcGetCasesWithExressionDataFromCohort(q, ds);
+    if (caseLst.length == 0) {
+      return [];
+    }
+    const { host, headers } = ds.getHostHeaders(q);
+    const url = path.join(host.geneExp, "/gene_expression/gene_selection");
+    try {
+      const response = await got.post(url, {
+        headers,
+        body: JSON.stringify(getGeneSelectionArg(q, caseLst))
+      });
+      const re = JSON.parse(response.body);
+      const genes = [];
+      if (!Array.isArray(re.gene_selection))
+        throw "re.gene_selection[] is not array";
+      for (const i of re.gene_selection) {
+        if (i.gene_id && typeof i.gene_id == "string") {
+          const t = genome.genedb.getNameByAlias.get(i.gene_id);
+          if (t)
+            genes.push(t.name);
+        } else if (i.symbol && typeof i.symbol == "string") {
+          genes.push(i.symbol);
+        } else {
+          throw "one of re.gene_selection[] is missing both gene_id and symbol";
+        }
+      }
+      return genes;
+    } catch (e) {
+      console.log(e.stack || e);
+      throw e;
+    }
+  };
+  function getGeneSelectionArg(q, caseLst) {
+    return {
+      case_ids: caseLst,
+      //.slice(0, 20),
+      gene_ids: tempGetCGCgenes(genome),
+      selection_size: Number(q.maxGenes)
+    };
+  }
+}
+function tempGetCGCgenes(genome) {
+  const lst = [];
+  for (const s of genome.geneset[0].lst) {
+    const a = genome.genedb.getAliasByName.all(s);
+    if (a) {
+      for (const b of a) {
+        if (b.alias.startsWith("ENSG"))
+          lst.push(b.alias);
+      }
+    }
+  }
+  return lst;
+}
+export {
+  api,
+  validate_query_TopVariablyExpressedGenes
+};

package/routes/termdb.violin.js

@@ -0,0 +1,77 @@
+import { trigger_getViolinPlotData } from "#src/termdb.violin.js";
+const api = {
+  endpoint: "termdb/violin",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "getViolinRequest"
+      },
+      response: {
+        typeId: "getViolinResponse"
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              genome: "hg38-test",
+              dslabel: "TermdbTest",
+              embedder: "localhost",
+              devicePixelRatio: 2.200000047683716,
+              maxThickness: 150,
+              screenThickness: 1218,
+              filter: {
+                type: "tvslst",
+                in: true,
+                join: "",
+                lst: [
+                  {
+                    tag: "cohortFilter",
+                    type: "tvs",
+                    tvs: { term: { id: "subcohort", type: "categorical" }, values: [{ key: "ABC", label: "ABC" }] }
+                  }
+                ]
+              },
+              svgw: 227.27272234672367,
+              orientation: "horizontal",
+              datasymbol: "bean",
+              radius: 5,
+              strokeWidth: 0.2,
+              axisHeight: 60,
+              rightMargin: 50,
+              unit: "abs",
+              termid: "agedx"
+            }
+          },
+          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];
+      const ds = g.datasets[req.query.dslabel];
+      if (!g)
+        throw "invalid genome name";
+      const data = await trigger_getViolinPlotData(req.query, null, ds, g);
+      res.send(data);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+export {
+  api
+};