@sjcrh/proteinpaint-server 2.44.0 → 2.46.1

package/routes/gene2canonicalisoform.js

@@ -0,0 +1,41 @@
+const api = {
+  endpoint: "gene2canonicalisoform",
+  // should rename to simply 'canonicalIsoform' or 'isoform', gene and type: 'canonical' can be part of payload
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "any"
+      },
+      response: {
+        typeId: "any"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return function(req, res) {
+    try {
+      if (!req.query.gene)
+        throw ".gene missing";
+      const genome = genomes[req.query.genome];
+      if (!genome)
+        throw "unknown genome";
+      if (!genome.genedb.get_gene2canonicalisoform)
+        throw "gene2canonicalisoform not supported on this genome";
+      const data = genome.genedb.get_gene2canonicalisoform.get(req.query.gene);
+      res.send(data);
+    } catch (e) {
+      res.send({ error: e.message || e });
+      if (e.stack)
+        console.log(e.stack);
+    }
+  };
+}
+export {
+  api
+};

package/routes/genelookup.js

@@ -0,0 +1,52 @@
+import { getResult } from "#src/gene.js";
+function init({ genomes }) {
+  return (req, res) => {
+    try {
+      const q = req.query;
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome name";
+      const result = getResult(g, req.query);
+      res.send(result);
+    } catch (e) {
+      res.send({ error: e.message || e });
+      if (e.stack)
+        console.log(e.stack);
+    }
+  };
+}
+const api = {
+  endpoint: "genelookup",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "GeneLookupRequest"
+        //valid: default to type checker
+      },
+      response: {
+        typeId: "GeneLookupResponse"
+        // will combine this with type checker
+        //valid: (t) => {}
+      },
+      examples: [
+        {
+          request: {
+            body: { input: "kr", genome: "hg38-test" }
+          },
+          response: {
+            header: { status: 200 },
+            body: { hits: ["KRAS"] }
+          }
+        }
+      ]
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+export {
+  api
+};

package/routes/genomes.js

@@ -0,0 +1,144 @@
+import fs from "fs";
+import serverconfig from "#src/serverconfig.js";
+import { authApi } from "#src/auth.js";
+import { versionInfo } from "#src/health.ts";
+const api = {
+  endpoint: "genomes",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "any"
+      },
+      response: {
+        typeId: "any"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async function handle_genomes(req, res) {
+    try {
+      await fs.promises.stat(serverconfig.tpmasterdir);
+    } catch (e) {
+      let message = "Error with TP directory (" + e.code + ")";
+      const m = serverconfig.maintenance || {};
+      if ("start" in m && "stop" in m && m.tpMessage) {
+        const start = +new Date(m.start);
+        const stop = +new Date(m.stop);
+        const currTime = +/* @__PURE__ */ new Date();
+        if (start <= currTime && currTime <= stop) {
+          message = m.tpMessage;
+        }
+      }
+      res.send({ error: message });
+      return;
+    }
+    const hash = {};
+    if (req.query && req.query.genome) {
+      hash[req.query.genome] = clientcopy_genome(req.query.genome, genomes);
+    } else {
+      for (const genomename in genomes) {
+        hash[genomename] = clientcopy_genome(genomename, genomes);
+      }
+    }
+    let hasblat = false;
+    for (const n in genomes) {
+      if (genomes[n].blat)
+        hasblat = true;
+    }
+    res.send({
+      genomes: hash,
+      debugmode: serverconfig.debugmode,
+      headermessage: serverconfig.headermessage,
+      base_zindex: serverconfig.base_zindex,
+      codedate: versionInfo.codedate,
+      launchdate: versionInfo.launchdate,
+      hasblat,
+      features: serverconfig.features,
+      dsAuth: authApi.getDsAuth(req),
+      commonOverrides: serverconfig.commonOverrides,
+      targetPortal: serverconfig.targetPortal,
+      //sending target portal to the client
+      cardsPath: serverconfig.cards?.path
+    });
+  };
+}
+function clientcopy_genome(genomename, genomes) {
+  const g = genomes[genomename];
+  const g2 = {
+    species: g.species,
+    name: genomename,
+    hasSNP: g.snp ? true : false,
+    hasIdeogram: g.genedb.hasIdeogram,
+    fimo_motif: g.fimo_motif ? true : false,
+    blat: g.blat ? true : false,
+    geneset: g.geneset,
+    defaultcoord: g.defaultcoord,
+    isdefault: g.isdefault,
+    majorchr: g.majorchr,
+    majorchrorder: g.majorchrorder,
+    minorchr: g.minorchr,
+    tracks: g.tracks,
+    hicenzymefragment: g.hicenzymefragment,
+    datasets: {}
+  };
+  if (g.termdbs) {
+    g2.termdbs = {};
+    for (const k in g.termdbs) {
+      g2.termdbs[k] = { label: g.termdbs[k].label };
+    }
+  }
+  for (const dsname in g.datasets) {
+    const ds = g.datasets[dsname];
+    if (ds.isMds3) {
+      g2.datasets[ds.label] = {
+        isMds3: true,
+        noHandleOnClient: ds.noHandleOnClient,
+        label: ds.label
+      };
+      continue;
+    }
+    if (ds.isMds) {
+      g2.datasets[ds.label] = {
+        isMds: true,
+        mdsIsUninitiated: true,
+        noHandleOnClient: ds.noHandleOnClient,
+        label: ds.label
+      };
+      continue;
+    }
+    g2.datasets[ds.label] = {
+      isofficial: true,
+      legacyDsIsUninitiated: true,
+      // so client only gets copy_legacyDataset once
+      noHandleOnClient: ds.noHandleOnClient,
+      label: ds.label
+    };
+  }
+  if (g.hicdomain) {
+    g2.hicdomain = { groups: {} };
+    for (const s1 in g.hicdomain.groups) {
+      const tt = g.hicdomain.groups[s1];
+      g2.hicdomain.groups[s1] = {
+        name: tt.name,
+        reference: tt.reference,
+        sets: {}
+      };
+      for (const s2 in tt.sets) {
+        g2.hicdomain.groups[s1].sets[s2] = {
+          name: tt.sets[s2].name,
+          longname: tt.sets[s2].longname
+        };
+      }
+    }
+  }
+  return g2;
+}
+export {
+  api
+};

package/routes/healthcheck.js

@@ -0,0 +1,30 @@
+import { getStat } from "#src/health.ts";
+const api = {
+  endpoint: "healthcheck",
+  methods: {
+    get: {
+      init({ genomes }) {
+        return async (req, res) => {
+          try {
+            const health = await getStat(genomes);
+            res.send(health);
+          } catch (e) {
+            res.send({ status: "error", error: e.message || e });
+          }
+        };
+      },
+      request: {
+        typeId: null
+        //valid: default to type checker
+      },
+      response: {
+        typeId: "HealthCheckResponse"
+        // will combine this with type checker
+        //valid: (t) => {}
+      }
+    }
+  }
+};
+export {
+  api
+};

package/routes/hicdata.js

@@ -0,0 +1,98 @@
+import { fileurl } from "#src/utils.js";
+import { spawn } from "child_process";
+import readline from "readline";
+import serverconfig from "#src/serverconfig.js";
+const api = {
+  endpoint: "hicdata",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "HicdataRequest"
+      },
+      response: {
+        typeId: "HicdataResponse"
+      }
+      /*
+      examples: [
+      	{
+      		request: {
+      			body: {
+      				genome: 'hg38-test',
+      				dslabel: 'TermdbTest',
+      				embedder: 'localhost',
+      				gettermbyid: 'subcohort'
+      			}
+      		},
+      		response: {
+      			header: { status: 200 }
+      		}
+      	}
+      ]
+      */
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init() {
+  return async (req, res) => {
+    try {
+      const payload = await handle_hicdata(req.query);
+      res.send(payload);
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+function handle_hicdata(q) {
+  return new Promise((resolve, reject) => {
+    const [e, file, isurl] = fileurl({ query: q });
+    if (e)
+      reject({ error: "illegal file name" });
+    const matrixType = q.matrixType == "log(oe)" ? "oe" : q.matrixType ? q.matrixType : "observed";
+    const par = [matrixType, q.nmeth || "NONE", file, q.pos1, q.pos2, q.isfrag ? "FRAG" : "BP", q.resolution];
+    const ps = spawn(serverconfig.hicstraw, par);
+    const rl = readline.createInterface({ input: ps.stdout });
+    const items = [];
+    const erroutput = [];
+    let linenot3fields = 0;
+    let fieldnotnumerical = 0;
+    rl.on("line", (line) => {
+      const l = line.split("	");
+      if (l.length != 3) {
+        linenot3fields++;
+        return;
+      }
+      const n1 = Number.parseInt(l[0]);
+      const n2 = Number.parseInt(l[1]);
+      const v = q.matrixType == "log(oe)" ? Math.log(Number.parseFloat(l[2])) : Number.parseFloat(l[2]);
+      if (Number.isNaN(n1) || Number.isNaN(n2) || Number.isNaN(v)) {
+        fieldnotnumerical++;
+        return;
+      }
+      if (q.mincutoff != void 0 && v <= q.mincutoff) {
+        return;
+      }
+      items.push([n1, n2, v]);
+    });
+    ps.stderr.on("data", (i) => erroutput.push(i));
+    ps.on("close", () => {
+      const err = erroutput.join("");
+      if (err)
+        reject({ error: err });
+      if (linenot3fields)
+        reject({ error: linenot3fields + " lines have other than 3 fields" });
+      if (fieldnotnumerical)
+        reject({ error: fieldnotnumerical + " lines have non-numerical values in any of the 3 fields" });
+      resolve({ items });
+    });
+  });
+}
+export {
+  api
+};

package/routes/hicstat.js

@@ -0,0 +1,55 @@
+import { fileurl, file_is_readable } from "#src/utils.js";
+import { do_hicstat } from "#src/hicstat.ts";
+const api = {
+  endpoint: "hicstat",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "HicstatRequest"
+      },
+      response: {
+        typeId: "HicstatResponse"
+      },
+      examples: [
+        {
+          request: {
+            body: {
+              genome: "hg19",
+              file: "proteinpaint_demo/hg19/hic/hic_demo.hic",
+              embedder: "localhost"
+            }
+          },
+          response: {
+            header: { status: 200 }
+          }
+        }
+      ]
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init() {
+  return async (req, res) => {
+    try {
+      const [e, file, isurl] = fileurl(req);
+      if (e)
+        throw "illegal file name";
+      if (!isurl) {
+        await file_is_readable(file);
+      }
+      const out = await do_hicstat(file, isurl);
+      res.send({ out });
+    } catch (e) {
+      res.send({ error: e?.message || e });
+      if (e instanceof Error && e.stack)
+        console.log(e);
+    }
+  };
+}
+export {
+  api
+};

package/routes/isoformlst.js

@@ -0,0 +1,57 @@
+const api = {
+  // route endpoint
+  // - no need for trailing slash
+  // - should be a noun (method is based on HTTP GET, POST, etc)
+  // - don't add 'Data' as response is assumed to be data
+  endpoint: "isoformlst",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "any"
+      },
+      response: {
+        typeId: "any"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return function handle_isoformlst(req, res) {
+    try {
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome";
+      if (!Array.isArray(req.query.lst))
+        throw ".lst missing";
+      const lst = [];
+      for (const isoform of req.query.lst) {
+        if (g.genomicNameRegexp.test(isoform))
+          continue;
+        const tmp = g.genedb.getjsonbyisoform.all(isoform);
+        lst.push(
+          tmp.map((i) => {
+            const j = JSON.parse(i.genemodel);
+            if (i.isdefault)
+              j.isdefault = true;
+            return j;
+          })
+        );
+      }
+      res.send({ lst });
+    } catch (e) {
+      res.send({ error: e.message || e });
+      if (e.stack)
+        console.log(e.stack);
+      else
+        console.trace(e);
+    }
+  };
+}
+export {
+  api
+};

package/routes/ntseq.js

@@ -0,0 +1,43 @@
+import { get_fasta } from "#src/utils.js";
+const api = {
+  endpoint: "ntseq",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "any"
+      },
+      response: {
+        typeId: "any"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async function handle_ntseq(req, res) {
+    try {
+      if (!req.query.coord)
+        throw "coord missing";
+      const g = genomes[req.query.genome];
+      if (!g)
+        throw "invalid genome";
+      if (!g.genomefile)
+        throw "no sequence file available";
+      const seq = await get_fasta(g, req.query.coord);
+      res.send({
+        seq: seq.split("\n").slice(1).join("")
+      });
+    } catch (e) {
+      res.send({ error: e.message || e });
+      if (e.stack)
+        console.log(e.stack);
+    }
+  };
+}
+export {
+  api
+};

package/routes/pdomain.js

@@ -0,0 +1,61 @@
+const api = {
+  // route endpoint
+  // - no need for trailing slash
+  // - should be a noun (method is based on HTTP GET, POST, etc)
+  // - don't add 'Data' as response is assumed to be data
+  endpoint: "pdomain",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "any"
+      },
+      response: {
+        typeId: "any"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return function handle_pdomain(req, res) {
+    try {
+      const gn = req.query.genome;
+      if (!gn)
+        throw "no genome";
+      const g = genomes[gn];
+      if (!g)
+        throw "invalid genome " + gn;
+      if (!g.proteindomain) {
+        return res.send({ lst: [] });
+      }
+      if (!Array.isArray(req.query.isoforms))
+        throw "isoforms[] missing";
+      const lst = [];
+      for (const isoform of req.query.isoforms) {
+        if (g.genomicNameRegexp.test(isoform))
+          continue;
+        const tmp = g.proteindomain.getbyisoform.all(isoform);
+        lst.push({
+          name: isoform,
+          pdomains: tmp.map((i) => {
+            const j = JSON.parse(i.data);
+            j.refseq = isoform;
+            return j;
+          })
+        });
+      }
+      res.send({ lst });
+    } catch (e) {
+      res.send({ error: e.message || e });
+      if (e.stack)
+        console.log(e.stack);
+    }
+  };
+}
+export {
+  api
+};

package/routes/snp.js

@@ -0,0 +1,107 @@
+import * as utils from "#src/utils.js";
+const api = {
+  // route endpoint
+  // - no need for trailing slash
+  // - should be a noun (method is based on HTTP GET, POST, etc)
+  // - don't add 'Data' as response is assumed to be data
+  endpoint: "snp",
+  methods: {
+    get: {
+      init,
+      request: {
+        typeId: "any"
+      },
+      response: {
+        typeId: "any"
+      }
+    },
+    post: {
+      alternativeFor: "get",
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async function handle_snp(req, res) {
+    try {
+      const n = req.query.genome;
+      if (!n)
+        throw "no genome";
+      res.send({ results: await searchSNP(req.query, genomes[n]) });
+    } catch (e) {
+      if (e.stack)
+        console.log(e.stack);
+      return res.send({ error: e.message || e });
+    }
+  };
+}
+async function searchSNP(q, genome) {
+  if (!genome)
+    throw "invalid genome";
+  if (!genome.snp)
+    throw "snp is not configured for this genome";
+  const hits = [];
+  if (q.byCoord) {
+    if (genome.genomicNameRegexp.test(q.chr))
+      throw "invalid chr name";
+    if (!Array.isArray(q.ranges))
+      throw "ranges not an array";
+    for (const r of q.ranges) {
+      if (!Number.isInteger(r.start) || !Number.isInteger(r.stop) || r.start < 0 || r.stop < r.start)
+        throw "invalid start/stop";
+      if (r.stop - r.start >= 100) {
+        throw "range too big";
+      }
+      const snps = await utils.query_bigbed_by_coord(genome.snp.bigbedfile, q.chr, r.start, r.stop);
+      for (const snp of snps) {
+        const hit = snp2hit(snp);
+        if (q.alleleLst) {
+          let missing = false;
+          for (const i of q.alleleLst) {
+            if (i && !hit.alleles.includes(i)) {
+              missing = true;
+              break;
+            }
+          }
+          if (missing)
+            continue;
+        }
+        hits.push(hit);
+      }
+    }
+  } else if (q.byName) {
+    if (!Array.isArray(q.lst))
+      throw ".lst[] missing";
+    for (const n of q.lst) {
+      if (genome.genomicNameRegexp.test(n))
+        continue;
+      const snps = await utils.query_bigbed_by_name(genome.snp.bigbedfile, n);
+      for (const snp of snps) {
+        const hit = snp2hit(snp);
+        hits.push(hit);
+      }
+    }
+  } else {
+    throw "unknown query method";
+  }
+  return hits;
+}
+function snp2hit(snp) {
+  const fields = snp.split("	");
+  const ref = fields[4];
+  const alts = fields[6].split(",").filter(Boolean);
+  const observed = ref + "/" + alts.join("/");
+  const hit = {
+    chrom: fields[0],
+    chromStart: Number(fields[1]),
+    chromEnd: Number(fields[2]),
+    name: fields[3],
+    observed,
+    alleles: [ref, ...alts]
+  };
+  return hit;
+}
+export {
+  api,
+  searchSNP
+};