@sjcrh/proteinpaint-server 2.44.0 → 2.46.1

package/routes/gdc.maf.js

@@ -0,0 +1,120 @@
+import path from "path";
+import got from "got";
+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/maf",
+  methods: {
+    all: {
+      init,
+      request: {
+        typeId: "GdcMafRequest"
+      },
+      response: {
+        typeId: "GdcMafResponse"
+        // will combine this with type checker
+        //valid: (t) => {}
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              experimentalStrategy: "WXS",
+              embedder: "localhost"
+            }
+          },
+          response: {
+            header: { status: 200 }
+          }
+        }
+      ]
+    }
+  }
+};
+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 filters = {
+    op: "and",
+    content: [
+      { op: "=", content: { field: "data_format", value: "MAF" } },
+      { op: "=", content: { field: "experimental_strategy", value: q.experimentalStrategy } },
+      { op: "=", content: { field: "analysis.workflow_type", value: allowedWorkflowType } },
+      { op: "=", content: { field: "access", value: "open" } }
+      // delete if later to support controlled files
+    ]
+  };
+  const case_filters = { op: "and", content: [] };
+  if (q.filter0) {
+    case_filters.content.push(q.filter0);
+  }
+  const { host, headers } = ds.getHostHeaders(q);
+  const data = {
+    filters,
+    case_filters,
+    size: maxFileNumber,
+    fields: [
+      "id",
+      "file_size",
+      "cases.project.project_id",
+      // for display only
+      "cases.submitter_id",
+      // used when listing all cases & files
+      "cases.samples.sample_type"
+      // may add diagnosis and primary site
+    ].join(",")
+  };
+  const response = await got.post(path.join(host.rest, "files"), { headers, body: JSON.stringify(data) });
+  let re;
+  try {
+    re = JSON.parse(response.body);
+  } catch (e) {
+    throw "invalid JSON from " + api.endpoint;
+  }
+  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
+    };
+    file.case_submitter_id = c.submitter_id;
+    if (c.samples) {
+      file.sample_types = c.samples.map((i) => i.sample_type).sort();
+    }
+    files.push(file);
+  }
+  const result = {
+    files,
+    filesTotal: re.data.pagination.total,
+    maxTotalSizeCompressed
+  };
+  return result;
+}
+export {
+  api,
+  maxTotalSizeCompressed
+};

package/routes/gdc.mafBuild.js

@@ -0,0 +1,106 @@
+import got from "got";
+import path from "path";
+import { run_rust_stream } from "@sjcrh/proteinpaint-rust";
+import serverconfig from "#src/serverconfig.js";
+import { maxTotalSizeCompressed } from "./gdc.maf.ts";
+const api = {
+  endpoint: "gdc/mafBuild",
+  methods: {
+    all: {
+      init,
+      request: {
+        typeId: "GdcMafBuildRequest"
+      },
+      response: {
+        typeId: null
+        // 'GdcMafBuildResponse'
+      }
+    }
+  }
+};
+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";
+      await buildMaf(req.query, res, ds);
+    } catch (e) {
+      if (e.stack)
+        console.log(e.stack);
+      res.send({ status: "error", error: e.message || e });
+    }
+  };
+}
+async function buildMaf(q, res, ds) {
+  const t0 = Date.now();
+  const { host, headers } = ds.getHostHeaders(q);
+  const fileLst2 = await getFileLstUnderSizeLimit(q.fileIdLst, host, headers);
+  if (serverconfig.debugmode)
+    console.log(
+      `${fileLst2.length} out of ${q.fileIdLst.length} input MAF files accepted by size limit`,
+      Date.now() - t0
+    );
+  const arg = {
+    fileIdLst: fileLst2,
+    columns: q.columns,
+    host: path.join(host.rest, "data")
+    // must use the /data/ endpoint from current host
+  };
+  const rustStream = run_rust_stream("gdcmaf", JSON.stringify(arg));
+  res.setHeader("Content-Type", "application/octet-stream");
+  res.setHeader("Content-Disposition", "attachment; filename=cohort.maf.gz");
+  rustStream.pipe(res);
+  rustStream.on("end", () => {
+    if (serverconfig.debugmode)
+      console.log("rust gdcmaf", Date.now() - t0);
+    res.end();
+  });
+  rustStream.on("error", (err) => {
+    console.error(err);
+    res.statusCode = 500;
+    res.end("Internal Server Error");
+  });
+}
+async function getFileLstUnderSizeLimit(lst, host, headers) {
+  if (lst.length == 0)
+    throw "fileIdLst[] not array or blank";
+  const data = {
+    filters: {
+      op: "in",
+      content: { field: "file_id", value: lst }
+    },
+    size: 1e4,
+    fields: "file_size"
+  };
+  const response = await got.post(path.join(host.rest, "files"), { headers, body: JSON.stringify(data) });
+  let re;
+  try {
+    re = JSON.parse(response.body);
+  } catch (e) {
+    throw "invalid json from getFileLstUnderSizeLimit";
+  }
+  if (!Array.isArray(re.data?.hits))
+    throw "re.data.hits[] not array";
+  const out = [];
+  let cumsize = 0;
+  for (const h of re.data.hits) {
+    if (cumsize >= maxTotalSizeCompressed)
+      break;
+    if (!h.id)
+      throw ".id missing";
+    if (!Number.isInteger(h.file_size))
+      throw ".file_size not integer";
+    cumsize += h.file_size;
+    out.push(h.id);
+  }
+  if (out.length == 0)
+    throw "no file available";
+  return out;
+}
+export {
+  api
+};

package/routes/gdc.topMutatedGenes.js

@@ -0,0 +1,465 @@
+import { mclasscnvgain, mclasscnvloss, dtsnvindel } from "#shared/common.js";
+import got from "got";
+import serverconfig from "#src/serverconfig.js";
+const api = {
+  endpoint: "gdc/topMutatedGenes",
+  methods: {
+    all: {
+      init,
+      request: {
+        typeId: "GdcTopMutatedGeneRequest"
+      },
+      response: {
+        typeId: "GdcTopMutatedGeneResponse"
+      }
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    const q = req.query;
+    const g = genomes.hg38;
+    if (!g)
+      throw "hg38 missing";
+    const ds = g.datasets.GDC;
+    if (!ds)
+      throw "hg38 GDC missing";
+    try {
+      const genes = await getGenesGraphql(q, ds);
+      const payload = { genes };
+      res.send(payload);
+    } catch (e) {
+      res.send({ status: "error", error: e.message || e });
+    }
+  };
+}
+const queryV1 = {
+  query: `
+query GenesTable_relayQuery(
+  $genesTable_filters: FiltersArgument
+  $genesTable_size: Int
+  $genesTable_offset: Int
+  $score: String
+  $ssmCase: FiltersArgument
+  $geneCaseFilter: FiltersArgument
+  $ssmTested: FiltersArgument
+  $cnvTested: FiltersArgument
+  $cnvGainFilters: FiltersArgument
+  $cnvLossFilters: FiltersArgument
+) {
+  genesTableViewer: viewer {
+    explore {
+      cases {
+        hits(first: 0, filters: $ssmTested) {
+          total
+        }
+      }
+      filteredCases: cases {
+        hits(first: 0, filters: $geneCaseFilter) {
+          total
+        }
+      }
+      cnvCases: cases {
+        hits(first: 0, filters: $cnvTested) {
+          total
+        }
+      }
+      genes {
+        hits(first: $genesTable_size, offset: $genesTable_offset, filters: $genesTable_filters, score: $score) {
+          total
+          edges {
+            node {
+              id
+              numCases: score
+              symbol
+              name
+              cytoband
+              biotype
+              gene_id
+              is_cancer_gene_census
+              ssm_case: case {
+                hits(first: 0, filters: $ssmCase) {
+                  total
+                }
+              }
+              cnv_case: case {
+                hits(first: 0, filters: $cnvTested) {
+                  total
+                }
+              }
+              case_cnv_gain: case {
+                hits(first: 0, filters: $cnvGainFilters) {
+                  total
+                }
+              }
+              case_cnv_loss: case {
+                hits(first: 0, filters: $cnvLossFilters) {
+                  total
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`,
+  getVariables: (q) => {
+    const variables = {
+      genesTable_filters: { op: "and", content: [] },
+      genesTable_size: q.maxGenes || 50,
+      genesTable_offset: 0,
+      score: "case.project.project_id",
+      ssmCase: {
+        op: "and",
+        content: [
+          {
+            op: "in",
+            content: {
+              field: "cases.available_variation_data",
+              value: ["ssm"]
+            }
+          },
+          {
+            op: "NOT",
+            content: {
+              field: "genes.case.ssm.observation.observation_id",
+              value: "MISSING"
+            }
+          }
+        ]
+      },
+      geneCaseFilter: {
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["ssm"]
+            },
+            op: "in"
+          }
+        ],
+        op: "and"
+      },
+      ssmTested: {
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["ssm"]
+            },
+            op: "in"
+          }
+        ],
+        op: "and"
+      },
+      cnvTested: {
+        op: "and",
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["cnv"]
+            },
+            op: "in"
+          }
+        ]
+      },
+      cnvGainFilters: {
+        op: "and",
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["cnv"]
+            },
+            op: "in"
+          },
+          {
+            content: {
+              field: "cnvs.cnv_change",
+              value: ["Gain"]
+            },
+            op: "in"
+          }
+        ]
+      },
+      cnvLossFilters: {
+        op: "and",
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["cnv"]
+            },
+            op: "in"
+          },
+          {
+            content: {
+              field: "cnvs.cnv_change",
+              value: ["Loss"]
+            },
+            op: "in"
+          }
+        ]
+      }
+    };
+    if (q.filter0) {
+      variables.genesTable_filters.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.geneCaseFilter.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.cnvTested.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.cnvGainFilters.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.cnvLossFilters.content.push(JSON.parse(JSON.stringify(q.filter0)));
+    }
+    if (q.geneFilter == "CGC") {
+      variables.genesTable_filters.content.push(geneCGC());
+      variables.geneCaseFilter.content.push(geneCGC());
+      variables.cnvTested.content.push(geneCGC());
+      variables.cnvGainFilters.content.push(geneCGC());
+      variables.cnvLossFilters.content.push(geneCGC());
+    }
+    return variables;
+  }
+};
+const queryV2 = {
+  query: `
+          query GenesTable(
+            $caseFilters: FiltersArgument
+            $genesTable_filters: FiltersArgument
+            $genesTable_size: Int
+            $genesTable_offset: Int
+            $score: String
+            $ssmCase: FiltersArgument
+            $geneCaseFilter: FiltersArgument
+            $ssmTested: FiltersArgument
+            $cnvTested: FiltersArgument
+            $cnvGainFilters: FiltersArgument
+            $cnvLossFilters: FiltersArgument
+            $sort: [Sort]
+          ) {
+            genesTableViewer: viewer {
+              explore {
+                cases {
+                  hits(first: 0, case_filters: $ssmTested) {
+                    total
+                  }
+                }
+                filteredCases: cases {
+                  hits(first: 0, case_filters: $geneCaseFilter) {
+                    total
+                  }
+                }
+                cnvCases: cases {
+                  hits(first: 0, case_filters: $cnvTested) {
+                    total
+                  }
+                }
+                genes {
+                  hits(
+                    first: $genesTable_size
+                    offset: $genesTable_offset
+                    filters: $genesTable_filters
+                    case_filters: $caseFilters
+                    score: $score
+                    sort: $sort
+                  ) {
+                    total
+                    edges {
+                      node {
+                        id
+                        numCases: score
+                        symbol
+                        name
+                        cytoband
+                        biotype
+                        gene_id
+                        is_cancer_gene_census
+                        ssm_case: case {
+                          hits(first: 0, filters: $ssmCase) {
+                            total
+                          }
+                        }
+                        cnv_case: case {
+                          hits(first: 0, filters: $cnvTested) {
+                            total
+                          }
+                        }
+                        case_cnv_gain: case {
+                          hits(first: 0, filters: $cnvGainFilters) {
+                            total
+                          }
+                        }
+                        case_cnv_loss: case {
+                          hits(first: 0, filters: $cnvLossFilters) {
+                            total
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }`,
+  getVariables: (q) => {
+    const variables = {
+      caseFilters: { op: "and", content: [] },
+      genesTable_filters: { op: "and", content: [] },
+      genesTable_size: q.maxGenes || 50,
+      genesTable_offset: 0,
+      score: "case.project.project_id",
+      ssmCase: {
+        op: "and",
+        content: [
+          {
+            op: "in",
+            content: {
+              field: "cases.available_variation_data",
+              value: ["ssm"]
+            }
+          },
+          {
+            op: "NOT",
+            content: {
+              field: "genes.case.ssm.observation.observation_id",
+              value: "MISSING"
+            }
+          }
+        ]
+      },
+      geneCaseFilter: {
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["ssm"]
+            },
+            op: "in"
+          }
+        ],
+        op: "and"
+      },
+      ssmTested: {
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["ssm"]
+            },
+            op: "in"
+          }
+        ],
+        op: "and"
+      },
+      cnvTested: {
+        op: "and",
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["cnv"]
+            },
+            op: "in"
+          }
+        ]
+      },
+      cnvGainFilters: {
+        op: "and",
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["cnv"]
+            },
+            op: "in"
+          },
+          {
+            content: {
+              field: "cnvs.cnv_change",
+              value: ["Gain"]
+            },
+            op: "in"
+          }
+        ]
+      },
+      cnvLossFilters: {
+        op: "and",
+        content: [
+          {
+            content: {
+              field: "cases.available_variation_data",
+              value: ["cnv"]
+            },
+            op: "in"
+          },
+          {
+            content: {
+              field: "cnvs.cnv_change",
+              value: ["Loss"]
+            },
+            op: "in"
+          }
+        ]
+      }
+    };
+    if (q.filter0) {
+      variables.caseFilters.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.geneCaseFilter.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.cnvLossFilters.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.cnvGainFilters.content.push(JSON.parse(JSON.stringify(q.filter0)));
+      variables.cnvTested.content.push(JSON.parse(JSON.stringify(q.filter0)));
+    }
+    if (q.geneFilter == "CGC") {
+      variables.genesTable_filters.content.push(geneCGC());
+      variables.cnvLossFilters.content.push(geneCGC());
+      variables.cnvGainFilters.content.push(geneCGC());
+    }
+    return variables;
+  }
+};
+async function getGenesGraphql(q, ds) {
+  let query, variables;
+  const { host, headers } = ds.getHostHeaders(q);
+  if (serverconfig.features?.geneExpHost) {
+    query = queryV1.query;
+    variables = queryV1.getVariables(q);
+  } else {
+    query = queryV2.query;
+    variables = queryV2.getVariables(q);
+  }
+  const response = await got.post(host.graphql, {
+    headers,
+    body: JSON.stringify({ query, variables })
+  });
+  const re = JSON.parse(response.body);
+  const genes = [];
+  for (const g of re.data.genesTableViewer.explore.genes.hits.edges) {
+    if (typeof g.node != "object")
+      throw "node missing from re.data.genesTableViewer.explore.genes.hits.edges[]";
+    const mutationStat = [];
+    if (Number.isInteger(g.node.case_cnv_gain?.hits?.total) && g.node.case_cnv_gain.hits.total > 0)
+      mutationStat.push({ class: mclasscnvgain, count: g.node.case_cnv_gain.hits.total });
+    if (Number.isInteger(g.node.case_cnv_loss?.hits?.total) && g.node.case_cnv_loss.hits.total > 0)
+      mutationStat.push({ class: mclasscnvloss, count: g.node.case_cnv_loss.hits.total });
+    if (Number.isInteger(g.node.ssm_case?.hits?.total) && g.node.ssm_case.hits.total > 0)
+      mutationStat.push({ dt: dtsnvindel, count: g.node.ssm_case.hits.total });
+    genes.push({
+      gene: g.node.symbol,
+      mutationStat
+    });
+  }
+  return genes;
+}
+function geneCGC() {
+  return {
+    content: {
+      field: "genes.is_cancer_gene_census",
+      value: ["true"]
+    },
+    op: "in"
+  };
+}
+export {
+  api
+};