@sjcrh/proteinpaint-server 2.125.0 → 2.126.0

package/dataset/termdb.test.js

@@ -6,7 +6,8 @@ function termdb_test_default() {
   return {
     isMds3: true,
     isSupportedChartOverride: {
-      runChart: () => true
+      runChart: () => true,
+      eventCount: () => true
     },
     cohort: {
       massNav: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.125.0",
+  "version": "2.126.0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -62,10 +62,10 @@
   "dependencies": {
     "@sjcrh/augen": "2.121.0",
     "@sjcrh/proteinpaint-python": "2.118.0",
-    "@sjcrh/proteinpaint-r": "2.125.0",
-    "@sjcrh/proteinpaint-rust": "2.125.0",
-    "@sjcrh/proteinpaint-shared": "2.124.0",
-    "@sjcrh/proteinpaint-types": "2.125.0",
+    "@sjcrh/proteinpaint-r": "2.126.0",
+    "@sjcrh/proteinpaint-rust": "2.126.0",
+    "@sjcrh/proteinpaint-shared": "2.126.0",
+    "@sjcrh/proteinpaint-types": "2.126.0",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
     "better-sqlite3": "^9.4.1",

package/routes/gdcGRIN2list.js

@@ -0,0 +1,121 @@
+import { gdcMafPayload } from "#types/checkers";
+import ky from "ky";
+import { joinUrl } from "#shared/joinUrl.js";
+import serverconfig from "#src/serverconfig.js";
+const maxFileNumber = 1e3;
+const allowedWorkflowType = "Aliquot Ensemble Somatic Variant Merging and Masking";
+const maxTotalSizeCompressed = serverconfig.features.gdcMafMaxFileSize || 4e8;
+const api = {
+  endpoint: "gdc/GRIN2list",
+  methods: {
+    get: {
+      ...gdcMafPayload,
+      init
+    },
+    post: {
+      ...gdcMafPayload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const g = genomes.hg38;
+      if (!g)
+        throw "hg38 missing";
+      const ds = g.datasets.GDC;
+      if (!ds)
+        throw "hg38 GDC missing";
+      const payload = await listMafFiles(req.query, ds);
+      res.send(payload);
+    } catch (e) {
+      res.send({ status: "error", error: e.message || e });
+    }
+  };
+}
+async function listMafFiles(q, ds) {
+  const dataFormatFilter = {
+    op: "and",
+    content: [{ op: "=", content: { field: "data_format", value: "MAF" } }]
+  };
+  const filters = {
+    op: "and",
+    content: [
+      dataFormatFilter,
+      { op: "=", content: { field: "experimental_strategy", value: q.experimentalStrategy } },
+      { op: "=", content: { field: "analysis.workflow_type", value: allowedWorkflowType } },
+      { op: "=", content: { field: "access", value: "open" } }
+    ]
+  };
+  const case_filters = { op: "and", content: [] };
+  if (q.filter0) {
+    case_filters.content.push(q.filter0);
+  }
+  const { host } = ds.getHostHeaders(q);
+  const body = {
+    filters,
+    size: maxFileNumber,
+    fields: [
+      "id",
+      "file_size",
+      "cases.project.project_id",
+      // for display only
+      "cases.case_id",
+      // case uuid for making case url link to portal
+      "cases.submitter_id",
+      // used when listing all cases & files
+      "cases.samples.tissue_type",
+      "cases.samples.tumor_descriptor"
+    ].join(",")
+  };
+  if (case_filters.content.length)
+    body.case_filters = case_filters;
+  const response = await ky.post(joinUrl(host.rest, "files"), { timeout: false, json: body });
+  if (!response.ok)
+    throw `HTTP Error: ${response.status} ${response.statusText}`;
+  const re = await response.json();
+  if (!Number.isInteger(re.data?.pagination?.total))
+    throw "re.data.pagination.total is not int";
+  if (!Array.isArray(re.data?.hits))
+    throw "re.data.hits[] not array";
+  const files = [];
+  for (const h of re.data.hits) {
+    const c = h.cases?.[0];
+    if (!c)
+      throw "h.cases[0] missing";
+    const file = {
+      id: h.id,
+      project_id: c.project.project_id,
+      file_size: h.file_size,
+      case_submitter_id: c.submitter_id,
+      case_uuid: c.case_id,
+      sample_types: []
+    };
+    if (c.samples) {
+      let normalTypeName;
+      for (const { tumor_descriptor, tissue_type } of c.samples) {
+        if (tissue_type == "Normal") {
+          normalTypeName = (tumor_descriptor == "Not Applicable" ? "" : tumor_descriptor + " ") + tissue_type;
+          continue;
+        }
+        file.sample_types.push(tumor_descriptor + " " + tissue_type);
+      }
+      if (normalTypeName)
+        file.sample_types.push(normalTypeName);
+    }
+    file.sample_types = [...new Set(file.sample_types)];
+    files.push(file);
+  }
+  files.sort((a, b) => b.file_size - a.file_size);
+  const result = {
+    files,
+    filesTotal: re.data.pagination.total,
+    maxTotalSizeCompressed
+  };
+  return result;
+}
+export {
+  api,
+  maxTotalSizeCompressed
+};

package/routes/gdcGRIN2run.js

@@ -0,0 +1,96 @@
+import { runGRIN2Payload } from "#types/checkers";
+import { run_rust } from "@sjcrh/proteinpaint-rust";
+import { run_R } from "@sjcrh/proteinpaint-r";
+import serverconfig from "#src/serverconfig.js";
+import path from "path";
+const api = {
+  endpoint: "gdc/runGRIN2",
+  methods: {
+    get: {
+      ...runGRIN2Payload,
+      init
+    },
+    post: {
+      ...runGRIN2Payload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      console.log("[GRIN2] Validating genome configuration");
+      const g = genomes.hg38;
+      if (!g)
+        throw "hg38 missing";
+      const ds = g.datasets.GDC;
+      if (!ds)
+        throw "hg38 GDC missing";
+      const caseFiles = req.query;
+      console.log(`[GRIN2] Request received: ${JSON.stringify(caseFiles)}`);
+      if (!caseFiles) {
+        throw "Missing or invalid cases data";
+      }
+      try {
+        console.log("[GRIN2] Calling Rust for file processing...");
+        const rustInput = JSON.stringify(caseFiles);
+        console.log("[GRIN2] Executing Rust function...");
+        const rustResult = await run_rust("gdcGRIN2", rustInput);
+        console.log("[GRIN2] Rust execution completed");
+        console.log(`[GRIN2] Rust result type: ${typeof rustResult}`);
+        if (!rustResult) {
+          throw new Error("Failed to process MAF files: No result from Rust");
+        }
+        let parsedRustResult;
+        try {
+          parsedRustResult = typeof rustResult === "string" ? JSON.parse(rustResult) : rustResult;
+          console.log(`[GRIN2] Parsed Rust result: ${JSON.stringify(parsedRustResult).substring(0, 200)}...`);
+        } catch (parseError) {
+          console.error("[GRIN2] Error parsing Rust result:", parseError);
+        }
+        const genedbfile = path.join(serverconfig.tpmasterdir, g.genedb.dbfile);
+        const imagefile = path.join(serverconfig.cachedir, `grin2_${Date.now()}_${Math.floor(Math.random() * 1e9)}.png`);
+        const rInput = JSON.stringify({
+          genedb: genedbfile,
+          chromosomelist: g.majorchr,
+          imagefile,
+          lesion: rustResult
+          // The mutation string from Rust
+        });
+        console.log(`R input: ${rInput}`);
+        const parsedInput = JSON.parse(rInput);
+        console.log("Parsed lesion data type:", typeof parsedInput.lesion);
+        console.log(
+          "Parsed lesion data length:",
+          typeof parsedInput.lesion === "string" ? parsedInput.lesion.length : "not a string"
+        );
+        console.log("[GRIN2] Executing R script...");
+        const rResult = await run_R("gdcGRIN2.R", rInput, []);
+        console.log(`[GRIN2] R execution completed, result: ${rResult}`);
+        let resultData;
+        try {
+          resultData = JSON.parse(rResult);
+          console.log("[GRIN2] Finished R analysis");
+          const pngImg = resultData.png[0];
+          return res.json({ pngImg });
+        } catch (parseError) {
+          console.error("[GRIN2] Error parsing R result:", parseError);
+          console.log("[GRIN2] Raw R result:", rResult);
+        }
+      } finally {
+      }
+    } catch (e) {
+      console.error("[GRIN2] Error running analysis:", e);
+      console.error("[GRIN2] Error stack:", e.stack);
+      const errorResponse = {
+        status: "error",
+        error: e.message || String(e)
+      };
+      console.log(`[GRIN2] Sending error response: ${JSON.stringify(errorResponse)}`);
+      res.status(500).send(errorResponse);
+    }
+  };
+}
+export {
+  api
+};

package/routes/genesetEnrichment.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import serverconfig from "#src/serverconfig.js";
 import { run_python } from "@sjcrh/proteinpaint-python";
+import { run_rust } from "@sjcrh/proteinpaint-rust";
 import { mayLog } from "#src/helpers.ts";
 const api = {
   endpoint: "genesetEnrichment",
@@ -54,14 +55,21 @@ async function run_genesetEnrichment_analysis(q, genomes) {
     db: genomes[q.genome].termdbs.msigdb.cohort.db.connection.name,
     // For now msigdb has been added, but later databases other than msigdb may be used
     geneset_group: q.geneSetGroup,
-    cachedir: cachedir_gsea,
-    geneset_name: q.geneset_name,
-    pickle_file: q.pickle_file,
-    num_permutations: q.num_permutations,
     genedb: path.join(serverconfig.tpmasterdir, genomes[q.genome].genedb.dbfile),
     filter_non_coding_genes: q.filter_non_coding_genes
   };
-  const gsea_output = await run_python("gsea.py", "/" + JSON.stringify(genesetenrichment_input));
+  let gsea_output;
+  if (q.method == "blitzgsea") {
+    genesetenrichment_input.cachedir = cachedir_gsea;
+    genesetenrichment_input.pickle_file = q.pickle_file;
+    genesetenrichment_input.geneset_name = q.geneset_name;
+    genesetenrichment_input.num_permutations = q.num_permutations;
+    gsea_output = await run_python("gsea.py", "/" + JSON.stringify(genesetenrichment_input));
+  } else if (q.method == "cerno") {
+    gsea_output = await run_rust("cerno", JSON.stringify(genesetenrichment_input));
+  } else {
+    throw "Unknown method:" + q.method;
+  }
   let result;
   let data_found = false;
   let image_found = false;

package/routes/termdb.cluster.js

@@ -36,7 +36,7 @@ function init({ genomes }) {
       const ds = g.datasets[q.dslabel];
       if (!ds)
         throw "invalid dataset name";
-      if (ds.__gdc && !ds.__gdc.doneCaching)
+      if (!ds.__gdc?.doneCaching)
         throw "The server has not finished caching the case IDs: try again in about 2 minutes.";
       if ([TermTypes.GENE_EXPRESSION, TermTypes.METABOLITE_INTENSITY, NUMERIC_DICTIONARY_TERM].includes(q.dataType)) {
         if (!ds.queries?.[q.dataType] && q.dataType !== NUMERIC_DICTIONARY_TERM)