@sjcrh/proteinpaint-server 2.155.0 → 2.155.1-0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.155.0",
+  "version": "2.155.1-0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",

package/routes/gdcGRIN2list.js

@@ -0,0 +1,124 @@
+import { gdcGRIN2listPayload } from "#types";
+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 maxFileSizeAllowed = 1e6;
+const maxTotalSizeCompressed = serverconfig.features.gdcMafMaxFileSize || 4e8;
+const api = {
+  endpoint: "gdc/GRIN2list",
+  methods: {
+    get: {
+      ...gdcGRIN2listPayload,
+      init
+    },
+    post: {
+      ...gdcGRIN2listPayload,
+      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";
+    if (h.file_size >= maxFileSizeAllowed)
+      continue;
+    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,86 @@
+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";
+      }
+      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");
+      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}`);
+      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);
+      }
+    } 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
+};