@sjcrh/proteinpaint-server 2.189.0 → 2.190.0

package/routes/termdb.topMutatedGenes.js

@@ -1,127 +0,0 @@
-import { topMutatedGenePayload } from "#types/checkers";
-import { get_samples } from "#src/termdb.sql.js";
-import { mayLog } from "#src/helpers.ts";
-const api = {
-  endpoint: "termdb/topMutatedGenes",
-  methods: {
-    get: {
-      init,
-      ...topMutatedGenePayload
-    },
-    post: {
-      init,
-      ...topMutatedGenePayload
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    try {
-      const q = req.query;
-      const g = genomes[q.genome];
-      if (!g) throw "genome missing";
-      const ds = g.datasets?.[q.dslabel];
-      if (!ds) throw "ds missing";
-      if (!ds.queries?.topMutatedGenes) throw "not supported by ds";
-      const genes = await ds.queries.topMutatedGenes.get(q);
-      const payload = { genes };
-      res.send(payload);
-    } catch (e) {
-      res.send({ status: "error", error: e.message || e });
-      if (e.stack) console.log(e.stack);
-      else console.trace(e);
-    }
-  };
-}
-function validate_query_getTopMutatedGenes(ds) {
-  const q = ds.queries?.topMutatedGenes;
-  if (!q) return;
-  if (typeof q.get == "function") return;
-  if (!q.arguments) {
-    q.arguments = [];
-    q.arguments.push({ id: "maxGenes", label: "Gene Count", type: "number", value: 50 });
-    if (ds.queries.snvindel) {
-      q.arguments.push({ id: "snv_mfndi", label: "Protein-changing mutation", type: "boolean", value: true });
-      q.arguments.push({ id: "snv_splice", label: "Splice mutation", type: "boolean", value: true });
-      q.arguments.push({ id: "snv_utr", label: "UTR mutation", type: "boolean", value: true });
-      q.arguments.push({ id: "snv_s", label: "Silent mutation", type: "boolean", value: true });
-    }
-    if (ds.queries.svfusion) {
-      q.arguments.push({ id: "sv", label: "Structural variation", type: "boolean", value: true });
-      q.arguments.push({ id: "fusion", label: "RNA fusion", type: "boolean", value: true });
-    }
-    if (ds.queries.cnv) {
-      q.arguments.push({
-        id: "cnv",
-        type: "boolean",
-        label: "CNV",
-        checked: false,
-        noStyle: true,
-        //This is a hack
-        options: [
-          {
-            id: "cnv_ms",
-            label: "Max size",
-            type: "radio",
-            options: [
-              { id: "cnv_1mb", label: "<1Mb", value: "cnv_1mb" },
-              { id: "cnv_2mb", label: "<2Mb", value: "cnv_2mb" },
-              { id: "cnv_4mb", label: "<4Mb", value: "cnv_4mb" }
-            ]
-          },
-          {
-            id: "cnv_logratio",
-            label: "Min absolute log(ratio)",
-            type: "radio",
-            options: [
-              { id: "_01", label: ">0.1", value: "_01" },
-              { id: "_02", label: ">0.2", value: "_02" },
-              { id: "_03", label: ">0.3", value: "_03" }
-            ]
-          }
-        ]
-      });
-    }
-  }
-  q.get = async (param) => {
-    let sampleStatement = "";
-    if (param.filter) {
-      const lst = await get_samples(param, ds);
-      if (lst.length == 0) throw "empty sample filter";
-      sampleStatement = `WHERE sample IN (${lst.map((i) => i.id).join(",")})`;
-    }
-    const fields = [];
-    if (param.snv_mfndi) fields.push("snv_mfndi");
-    if (param.snv_splice) fields.push("snv_splice");
-    if (param.snv_utr) fields.push("snv_utr");
-    if (param.snv_s) fields.push("snv_s");
-    if (param.sv) fields.push("sv");
-    if (param.fusion) fields.push("fusion");
-    if (param.cnv == 1 && param.cnv_ms?.type && param.cnv_logratio?.type) {
-      fields.push(param.cnv_ms.type + param.cnv_logratio.type);
-    }
-    if (!fields.length) throw "no fields";
-    const query = `WITH
-		filtered AS (
-			SELECT genesymbol, ${fields.join("+")} AS total FROM genesamplemutationcount
-			${sampleStatement}
-		)
-		SELECT genesymbol, SUM(total) AS count
-		FROM filtered
-		GROUP BY genesymbol
-		ORDER BY count DESC
-		LIMIT ${param.maxGenes || 20}`;
-    const t = Date.now();
-    const genes = ds.cohort.db.connection.prepare(query).all();
-    mayLog("Top mutated gene sql", Date.now() - t, "ms");
-    const results = [];
-    for (const g of genes) {
-      results.push({ gene: g.genesymbol });
-    }
-    return results;
-  };
-}
-export {
-  api,
-  validate_query_getTopMutatedGenes
-};

package/routes/termdb.topTermsByType.js

@@ -1,96 +0,0 @@
-import { termdbTopTermsByTypePayload } from "#types/checkers";
-import { run_rust } from "@sjcrh/proteinpaint-rust";
-import { get_samples } from "#src/termdb.sql.js";
-import { TermTypes } from "#shared/terms.js";
-const api = {
-  endpoint: "termdb/getTopTermsByType",
-  methods: {
-    get: {
-      ...termdbTopTermsByTypePayload,
-      init
-    },
-    post: {
-      ...termdbTopTermsByTypePayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    try {
-      const q = req.query;
-      const type = q.type;
-      const genome = genomes[q.genome];
-      if (!genome) throw "invalid genome";
-      const ds = genome.datasets?.[q.dslabel];
-      if (!ds) throw "invalid dslabel";
-      if (!ds.queries[type]) throw "not supported on dataset";
-      const terms = await ds.queries[type].getTopTerms(q);
-      res.send({ terms });
-    } catch (e) {
-      res.send({ status: "error", error: e.message || e });
-    }
-  };
-}
-function validate_query_getTopTermsByType(ds, genome) {
-  const types = [TermTypes.METABOLITE_INTENSITY];
-  for (const type of types) {
-    if (ds.queries[type]) {
-      const q = ds.queries[type];
-      if (!q) return;
-      if (q.src == "gdcapi") gdcValidateQuery(ds, genome, type);
-      else if (q.src == "native") nativeValidateQuery(ds, type);
-      else throw "unknown topVariablyExpressedGenes.src";
-    }
-  }
-}
-function nativeValidateQuery(ds, type) {
-  ds.queries[type].getTopTerms = async (q) => {
-    const typeQuery = ds.queries[type];
-    const samples = [];
-    if (q.filter) {
-      const sidlst = await get_samples(q, ds);
-      for (const i of sidlst) {
-        if (typeQuery.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 typeQuery.samples) {
-        const n = ds.cohort.termdb.q.id2sampleName(i.id);
-        if (!n) throw "sample id cannot convert to string name";
-        samples.push(n);
-      }
-    }
-    const terms = await computeTopTerms(typeQuery.file, samples, type);
-    return terms;
-  };
-}
-async function computeTopTerms(file, samples, type) {
-  const input_json = {
-    input_file: file,
-    samples: samples.join(","),
-    param: "var"
-  };
-  const rust_result = await run_rust("computeTopTerms", JSON.stringify(input_json));
-  const rust_result_list = rust_result.split("\n");
-  let output_json;
-  for (const item of rust_result_list) {
-    if (item.includes("output_json")) {
-      output_json = JSON.parse(item.replace("output_json:", ""));
-    }
-  }
-  const varMetabolite = output_json.map((i) => ({ name: i.metabolite, type }));
-  return varMetabolite;
-}
-function gdcValidateQuery(ds, genome, type) {
-  ds.queries[type].getTopTerms = async () => {
-    return [];
-  };
-}
-export {
-  api,
-  validate_query_getTopTermsByType
-};

package/routes/termdb.topVariablyExpressedGenes.js

@@ -1,132 +0,0 @@
-import { termdbTopVariablyExpressedGenesPayload } from "#types/checkers";
-import { mayLimitSamples } from "#src/mds3.filter.js";
-import { run_python } from "@sjcrh/proteinpaint-python";
-import { mayLog } from "#src/helpers.ts";
-const api = {
-  endpoint: "termdb/topVariablyExpressedGenes",
-  methods: {
-    get: {
-      ...termdbTopVariablyExpressedGenesPayload,
-      init
-    },
-    post: {
-      ...termdbTopVariablyExpressedGenesPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    let result;
-    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";
-      q.ds = ds;
-      const t = Date.now();
-      result = {
-        genes: await ds.queries.topVariablyExpressedGenes.getGenes(q)
-      };
-      mayLog("time for top variably expressed genes", Date.now() - t);
-    } catch (e) {
-      result = { status: e.status || 400, error: e.message || e };
-    }
-    res.send(result);
-  };
-}
-function validate_query_TopVariablyExpressedGenes(ds) {
-  const q = ds.queries.topVariablyExpressedGenes;
-  if (!q) return;
-  if (typeof q.getGenes == "function") return;
-  nativeValidateQuery(ds);
-}
-function nativeValidateQuery(ds) {
-  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";
-  addTopVEarg(ds.queries.topVariablyExpressedGenes);
-  ds.queries.topVariablyExpressedGenes.getGenes = async (q) => {
-    const samples = [];
-    const param = { filter: q.filter, filter0: q.filter0 };
-    const limitSamples = await mayLimitSamples(param, gE.samples, ds);
-    if (limitSamples) {
-      for (const sid of limitSamples) {
-        const n = ds.cohort.termdb.q.id2sampleName(sid);
-        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);
-        if (!n) throw "sample id cannot convert to string name";
-        samples.push(n);
-      }
-    }
-    return await computeGenes4nativeDs(q, gE, samples);
-  };
-}
-function addTopVEarg(q) {
-  const arglst = [
-    { id: "maxGenes", label: "Gene Count", type: "number", value: 100 },
-    {
-      id: "filter_extreme_values",
-      label: "Filter Extreme Values",
-      type: "boolean",
-      value: true
-    },
-    {
-      id: "rank_type",
-      label: "Rank by:",
-      type: "radio",
-      options: [
-        /** The param option in input JSON is very important.
-         * It instructs what method will be used to calculate variation in the counts for a particular gene.
-         * It supports variance as well as interquartile region.
-         * This is based on the recommendation of this article:
-         * https://www.frontiersin.org/articles/10.3389/fgene.2021.632620/full.
-         * This article recommends using interquartile region over variance.*/
-        {
-          type: "boolean",
-          label: "Variance",
-          value: "var"
-        },
-        {
-          type: "boolean",
-          label: "Interquartile Region",
-          value: "iqr"
-        }
-      ]
-    }
-  ];
-  if (q.arguments) {
-    for (const a of q.arguments) {
-      if (!a.id) throw "missing id of topVE.arguments[]";
-      const item = arglst.find((i) => i.id == a.id);
-      if (!item) throw "unknown id of topVE.arguments[]";
-      Object.assign(item, a);
-    }
-  }
-  q.arguments = arglst;
-}
-async function computeGenes4nativeDs(q, gE, samples) {
-  if (!["number", "boolean"].includes(typeof q.filter_extreme_values) || q.filter_extreme_values === void 0) {
-    q.filter_extreme_values = false;
-  }
-  const input_json = {
-    input_file: gE.file,
-    samples: samples.join(","),
-    filter_extreme_values: typeof q.filter_extreme_values === "number" ? Boolean(q.filter_extreme_values) : q.filter_extreme_values,
-    max_genes: q.maxGenes,
-    rank_type: q.rank_type?.type ?? "var"
-  };
-  const python_output = await run_python("topVEgene.py", JSON.stringify(input_json));
-  const varGenes = typeof python_output === "string" ? JSON.parse(python_output) : [];
-  return varGenes;
-}
-export {
-  api,
-  validate_query_TopVariablyExpressedGenes
-};

package/routes/tileserver.js

@@ -1,68 +0,0 @@
-import { tilePayload } from "#types/checkers";
-import ky from "ky";
-import { TileServerShardingAlgorithm } from "#src/sharding/TileServerShardingAlgorithm.ts";
-import { ShardManager } from "#src/sharding/ShardManager.ts";
-import SessionManager from "#src/wsisessions/SessionManager.ts";
-import serverconfig from "#src/serverconfig.js";
-import path from "path";
-const api = {
-  endpoint: `tileserver/layer/:type/:sessionId/zoomify/:TileGroup/:z-:x-:y@1x.jpg`,
-  methods: {
-    get: {
-      ...tilePayload,
-      init
-    },
-    post: {
-      ...tilePayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    try {
-      const { type, sessionId, TileGroup, z, x, y } = req.params;
-      const query = req.query;
-      const wsiImage = query.wsi_image;
-      if (!wsiImage) throw new Error("No wsi_image param provided");
-      const dslabel = query.dslabel;
-      if (!dslabel) throw new Error("No dslabel param provided");
-      const g = genomes[query.genome];
-      if (!g) throw new Error("Invalid genome name");
-      const ds = g.datasets[query.dslabel];
-      if (!ds) throw new Error("Invalid dataset name");
-      const sampleId = query.sample_id;
-      const projectId = query.ai_project_id;
-      if (!sampleId && !projectId) throw new Error("Either sample_id or project_id must be provided");
-      const mount = serverconfig.features?.tileserver?.mount;
-      if (!mount) throw new Error("No mount available for TileServer");
-      let wsiImagePath;
-      if (sampleId) {
-        wsiImagePath = path.join(`${mount}/${ds.queries.WSImages.imageBySampleFolder}/${sampleId}`, wsiImage);
-      } else {
-        wsiImagePath = path.join(`${mount}/${ds.queries.WSImages.aiToolImageFolder}/`, wsiImage);
-      }
-      if (!wsiImage) throw new Error("Invalid wsi_image");
-      const shardManager = ShardManager.getInstance();
-      const tileServer = await shardManager.shardingAlgorithmsMap?.get(TileServerShardingAlgorithm.TILE_SERVER_SHARDING_KEY)?.getShard(wsiImagePath);
-      if (!tileServer) {
-        throw new Error("No tile server");
-      }
-      const url = `${tileServer.url}/tileserver/layer/${type}/${sessionId}/zoomify/${TileGroup}/${z}-${x}-${y}@1x.jpg`;
-      const response = await ky.get(url, { timeout: 12e4 });
-      await SessionManager.getInstance().updateSession(wsiImagePath);
-      const buffer = await response.arrayBuffer();
-      res.status(response.status).send(Buffer.from(buffer));
-    } catch (error) {
-      if (error.response) {
-        const errorBody = await error.response.arrayBuffer();
-        res.status(error.response.status).send(Buffer.from(errorBody));
-      } else {
-        res.status(500).send("Internal Server Error");
-      }
-    }
-  };
-}
-export {
-  api
-};

package/routes/wsisamples.js

@@ -1,71 +0,0 @@
-import { wsiSamplesPayload } from "#types/checkers";
-const routePath = "wsisamples";
-const api = {
-  endpoint: `${routePath}`,
-  methods: {
-    get: {
-      ...wsiSamplesPayload,
-      init
-    },
-    post: {
-      ...wsiSamplesPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    try {
-      const query = req.query;
-      const g = genomes[query.genome];
-      if (!g) throw new Error("Invalid genome name");
-      const ds = g.datasets[query.dslabel];
-      if (!ds) throw "Invalid dslabel";
-      const images = await ds.queries.WSImages.getSamples();
-      const payload = {
-        samples: images
-      };
-      res.status(200).json(payload);
-    } catch (e) {
-      console.warn(e);
-      res.status(500).send({
-        status: "error",
-        error: e.message || e
-      });
-    }
-  };
-}
-async function validate_query_getWSISamples(ds) {
-  const q = ds.queries?.WSImages;
-  if (!q) return;
-  validateQuery(ds);
-}
-function validateQuery(ds) {
-  if (typeof ds.queries.WSImages.getSamples == "function") {
-    return;
-  }
-  ds.queries.WSImages.getSamples = async () => {
-    const sql = `SELECT wsimages.sample as sample, wsimages.filename as filename, wsimages.metadata as metadata, sampleidmap.name as sampleName
-					 FROM wsimages
-					 INNER JOIN sampleidmap
-					 ON wsimages.sample = sampleidmap.id`;
-    try {
-      const rows = ds.cohort.db.connection.prepare(sql).all();
-      const sampleMap = {};
-      for (const row of rows) {
-        if (!sampleMap[row.sample]) {
-          sampleMap[row.sample] = { sampleId: row.sampleName, wsimages: [] };
-        }
-        sampleMap[row.sample].wsimages.push(row.filename);
-      }
-      return Object.values(sampleMap);
-    } catch (error) {
-      console.error("Error fetching samples:", error);
-      throw error;
-    }
-  };
-}
-export {
-  api,
-  validate_query_getWSISamples
-};