@sjcrh/proteinpaint-server 2.183.2-0 → 2.184.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.183.2-0",
+  "version": "2.184.0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -66,7 +66,7 @@
     "@sjcrh/proteinpaint-r": "2.181.0",
     "@sjcrh/proteinpaint-rust": "2.183.0",
     "@sjcrh/proteinpaint-shared": "2.183.0",
-    "@sjcrh/proteinpaint-types": "2.183.1",
+    "@sjcrh/proteinpaint-types": "2.184.0",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
     "better-sqlite3": "^12.4.1",

package/routes/profile.barchart2.js

@@ -0,0 +1,114 @@
+import { ProfileScoresPayload } from "#types/checkers";
+import { getData } from "../src/termdb.matrix.js";
+const api = {
+  endpoint: "termdb/profileBarchart2Scores",
+  methods: {
+    get: {
+      ...ProfileScoresPayload,
+      init
+    },
+    post: {
+      ...ProfileScoresPayload,
+      init
+    }
+  }
+};
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const g = genomes[req.query.genome];
+      if (!g) throw "invalid genome name";
+      const ds = g.datasets?.[req.query.dslabel];
+      const result = await getScores(req.query, ds);
+      res.send(result);
+    } catch (e) {
+      console.log(e);
+      res.send({ status: "error", error: e.message || e });
+    }
+  };
+}
+function derivePrefix(query) {
+  const firstScoreId = query.scoreTerms?.[0]?.score?.term?.id;
+  if (firstScoreId?.startsWith("F")) return "F";
+  if (firstScoreId?.startsWith("A")) return "A";
+  for (const entry of query.filter?.lst || []) {
+    const id = entry.tvs?.term?.id;
+    if (id?.startsWith("F")) return "F";
+    if (id?.startsWith("A")) return "A";
+  }
+  throw "cannot determine cohort prefix from scoreTerms or filter term IDs";
+}
+async function getScores(query, ds) {
+  const { activeCohort, clientAuthResult } = query.__protected__;
+  const prefix = derivePrefix(query);
+  const facilityTermId = `${prefix}UNIT`;
+  const facilityTW = { term: { id: facilityTermId }, q: {} };
+  const terms = [facilityTW];
+  for (const t of query.scoreTerms) {
+    terms.push(t.score);
+    if (t.maxScore?.term) terms.push(t.maxScore);
+  }
+  if (!query.filterByUserSites) {
+    query.__protected__.ignoredTermIds.push(facilityTermId);
+  }
+  const cohortAuth = clientAuthResult[activeCohort];
+  const isPublic = !cohortAuth?.role || cohortAuth.role === "public";
+  const userSites = cohortAuth?.sites;
+  const raw = await getData(
+    {
+      terms,
+      filter: query.filter,
+      __protected__: query.__protected__
+    },
+    ds
+  );
+  if (raw.error) throw raw.error;
+  const sampleList = Object.values(raw.samples);
+  let sites = sampleList.map((s) => {
+    const val = s[facilityTW.$id].value;
+    let label = facilityTW.term.values?.[val]?.label || val;
+    if (label.length > 50) label = label.slice(0, 47) + "...";
+    return { value: val, label };
+  });
+  if (userSites && query.filterByUserSites) {
+    sites = sites.filter((s) => userSites.includes(s.value));
+  }
+  sites.sort((a, b) => a.label.localeCompare(b.label));
+  const samples = Object.values(raw.samples);
+  const eligibleSamples = userSites && query.filterByUserSites ? samples.filter((s) => userSites.includes(s[facilityTW.$id].value)) : samples;
+  const term2Score = {};
+  for (const d of query.scoreTerms) {
+    const score = computeMedianPercentage(d, eligibleSamples);
+    if (score !== null) term2Score[d.score.term.id] = score;
+  }
+  return {
+    term2Score,
+    // Public users see only aggregated scores — do not expose site IDs or names
+    sites: isPublic ? [] : sites,
+    n: eligibleSamples.length
+  };
+}
+function computeMedianPercentage(d, samples) {
+  const percentages = [];
+  for (const s of samples) {
+    const scoreValue = s[d.score.$id]?.value;
+    if (scoreValue == null) continue;
+    let maxScoreValue = null;
+    if (typeof d.maxScore === "number") {
+      maxScoreValue = d.maxScore;
+    } else {
+      maxScoreValue = s[d.maxScore.$id]?.value;
+    }
+    if (maxScoreValue == null || maxScoreValue === 0) continue;
+    const percentage = scoreValue / maxScoreValue * 100;
+    percentages.push(percentage);
+  }
+  if (percentages.length === 0) return null;
+  percentages.sort((a, b) => a - b);
+  const mid = Math.floor(percentages.length / 2);
+  const median = percentages.length % 2 !== 0 ? percentages[mid] : (percentages[mid - 1] + percentages[mid]) / 2;
+  return Math.round(median);
+}
+export {
+  api
+};

package/routes/termdb.config.js

@@ -194,6 +194,9 @@ function addNonDictionaryQueries(c, ds, genome) {
   }
   if (q.proteome) {
     q2.proteome = {};
+    if (q.proteome.overlayTerm) {
+      q2.proteome.overlayTerm = JSON.parse(JSON.stringify(q.proteome.overlayTerm));
+    }
     if (q.proteome.assays) {
       q2.proteome.assays = {};
       for (const assay in q.proteome.assays) {
@@ -203,11 +206,11 @@ function addNonDictionaryQueries(c, ds, genome) {
           for (const cohort in q.proteome.assays[assay].cohorts) {
             q2.proteome.assays[assay].cohorts[cohort] = {};
             const src = q.proteome.assays[assay].cohorts[cohort];
-            if ("filter" in src) {
-              q2.proteome.assays[assay].cohorts[cohort].filter = JSON.parse(JSON.stringify(src.filter));
+            if ("controlFilter" in src) {
+              q2.proteome.assays[assay].cohorts[cohort].controlFilter = JSON.parse(JSON.stringify(src.controlFilter));
             }
-            if ("overlayTerm" in src) {
-              q2.proteome.assays[assay].cohorts[cohort].overlayTerm = JSON.parse(JSON.stringify(src.overlayTerm));
+            if ("caseFilter" in src) {
+              q2.proteome.assays[assay].cohorts[cohort].caseFilter = JSON.parse(JSON.stringify(src.caseFilter));
             }
           }
         }

package/routes/termdb.proteome.js

@@ -28,16 +28,11 @@ function init({ genomes }) {
       const cohorts = [];
       for (const assayName in ds.queries.proteome.assays) {
         const assay = ds.queries.proteome.assays[assayName];
-        for (const cohort of assay.cohorts) {
+        for (const cohortName in assay.cohorts || {}) {
           const details = {
             dbfile: ds.queries.proteome.dbfile,
-            assayName,
-            cohortName: cohort.cohortName,
-            cohortControlFilter: cohort.controlFilter,
-            cohortCaseFilter: cohort.caseFilter,
-            PTMType: assay.PTMType,
-            assayColumnIdx: assay.columnIdx,
-            assayColumnValue: assay.columnValue
+            assay: assayName,
+            cohort: cohortName
           };
           const tw = {
             $id: "_",
@@ -214,16 +209,14 @@ async function validate_query_proteome(ds) {
   }
   for (const assayName in q.assays) {
     const assay = q.assays[assayName];
-    if (!assay.columnIdx) throw `queries.proteome.assays.${assayName}.columnIdx missing`;
-    if (!assay.columnValue) throw `queries.proteome.assays.${assayName}.columnValue missing`;
+    if (assay.columnIdx == null) throw `queries.proteome.assays.${assayName}.columnIdx missing`;
+    if (assay.columnValue == null) throw `queries.proteome.assays.${assayName}.columnValue missing`;
     if (assay.cohorts) {
-      console.log(`Validating assay "${assayName}" with multiple cohorts`);
-      for (const cohort of assay.cohorts) {
-        if (!cohort.cohortName) throw `Missing cohortName in queries.proteome.assays.${assayName}.cohorts`;
+      for (const cohortName in assay.cohorts) {
+        const cohort = assay.cohorts[cohortName];
         if (!cohort.controlFilter)
-          throw `Missing controlFilter in queries.proteome.assays.${assayName}.cohorts.${cohort.cohortName}`;
-        if (!cohort.caseFilter)
-          throw `Missing caseFilter in queries.proteome.assays.${assayName}.cohorts.${cohort.cohortName}`;
+          throw `Missing controlFilter in queries.proteome.assays.${assayName}.cohorts.${cohortName}`;
+        if (!cohort.caseFilter) throw `Missing caseFilter in queries.proteome.assays.${assayName}.cohorts.${cohortName}`;
       }
     } else {
       throw `Invalid assay structure for "${assayName}". Must have .cohorts`;
@@ -232,15 +225,56 @@ async function validate_query_proteome(ds) {
   q.find = async (arg) => {
     const proteins = arg?.proteins;
     if (!Array.isArray(proteins) || proteins.length == 0) throw "queries.proteome.find arg.proteins[] missing";
-    return findProteinsInCohort(q.db, proteins);
+    const matches = /* @__PURE__ */ new Set();
+    const details = arg?.proteomeDetails || {};
+    const assay = details.assay;
+    const cohort = details.cohort;
+    const MAX_FIND_RESULTS = 500;
+    const filters = [];
+    if (Object.keys(details).length) {
+      if (!assay || !cohort) throw "queries.proteome.find arg.proteomeDetails.{assay,cohort} missing";
+      const assayConfig = q.assays?.[assay];
+      if (!assayConfig) throw `queries.proteome.find invalid assay: ${assay}`;
+      const cohortConfig = assayConfig?.cohorts?.[cohort];
+      if (!cohortConfig) throw `queries.proteome.find invalid cohort: ${cohort}`;
+      const assayFilter = [{ columnIdx: assayConfig.columnIdx, columnValue: assayConfig.columnValue }];
+      const cohortFilter = (Array.isArray(cohortConfig.caseFilter) ? cohortConfig.caseFilter : []).filter(
+        (filter) => !!filter
+      );
+      if (!cohortFilter.length) throw `queries.proteome.find invalid cohort caseFilter: ${cohort}`;
+      filters.push(...assayFilter, ...cohortFilter);
+    }
+    for (const p of proteins) {
+      if (!p) continue;
+      const token = String(p).trim();
+      if (token.length < 2) continue;
+      const upperToken = `${token}\uFFFF`;
+      const rawRows = [];
+      if (filters?.length) {
+        const { conditions, params } = buildFilterClause(filters);
+        const sql = `SELECT DISTINCT gene, identifier FROM proteome_abundance WHERE gene >= ? COLLATE NOCASE AND gene < ? COLLATE NOCASE AND ${conditions.join(
+          " AND "
+        )} LIMIT ${MAX_FIND_RESULTS}`;
+        rawRows.push(...q.db.prepare(sql).all(token, upperToken, ...params));
+      } else {
+        rawRows.push(
+          ...q.db.prepare(
+            `SELECT DISTINCT gene, identifier FROM proteome_abundance WHERE gene >= ? COLLATE NOCASE AND gene < ? COLLATE NOCASE LIMIT ${MAX_FIND_RESULTS}`
+          ).all(token, upperToken)
+        );
+      }
+      for (const row of rawRows) {
+        if (!row?.gene || !row?.identifier) continue;
+        matches.add(`${row.gene}: ${row.identifier}`);
+      }
+    }
+    return [...matches];
   };
   q.get = async (param) => {
     if (!param?.terms?.length) throw "queries.proteome.get param.terms[] missing";
-    if (!param.proteomeDetails?.assayName || !param.proteomeDetails?.cohortName)
-      throw "queries.proteome.get param.proteomeDetails.{assayName,cohortName} missing";
-    if (!param.proteomeDetails?.cohortControlFilter || !param.proteomeDetails?.cohortCaseFilter || !param.proteomeDetails?.assayColumnIdx || !param.proteomeDetails?.assayColumnValue)
-      throw "queries.proteome.get param.proteomeDetails.{cohortControlFilter, cohortCaseFilter, assayColumnIdx, assayColumnValue} missing";
-    return await getProteomeValuesFromCohort(ds, param);
+    if (!param.proteomeDetails?.assay || !param.proteomeDetails?.cohort)
+      throw "queries.proteome.get param.proteomeDetails.{assay,cohort} missing";
+    return await getProteomeValuesFromCohort(ds, param, q);
   };
 }
 const columnIdxToName = {
@@ -267,32 +301,26 @@ function buildFilterClause(filters) {
   }
   return { conditions, params };
 }
-function findProteinsInCohort(db, proteins) {
-  const matches = [];
-  for (const p of proteins) {
-    if (!p) continue;
-    const rows = db.prepare("SELECT DISTINCT gene, identifier FROM proteome_abundance WHERE gene LIKE ? COLLATE NOCASE").all(`%${p}%`);
-    for (const row of rows) {
-      if (row.gene.toLowerCase().includes(p.toLowerCase())) {
-        matches.push(`${row.gene}: ${row.identifier}`);
-      }
-    }
-  }
-  return matches;
-}
 function queryDbRows(db, matchColumn, matchValue, filters) {
-  console.log(`Querying DB for ${matchColumn}=${matchValue} with filters:`, filters);
   const { conditions, params } = buildFilterClause(filters);
   const allConditions = [`${matchColumn} = ? COLLATE NOCASE`, ...conditions];
-  const sql = `SELECT identifier, protein_accession, modsite, gene, sample, value
+  const sql = `SELECT identifier, protein_accession, isoform, modsite, gene, sample, value
 		FROM proteome_abundance
 		WHERE ${allConditions.join(" AND ")}`;
-  console.log("Executing SQL:", sql);
   return db.prepare(sql).all(matchValue, ...params);
 }
-async function getProteomeValuesFromCohort(ds, param) {
+async function getProteomeValuesFromCohort(ds, param, q) {
   const db = ds.queries.proteome.db;
-  const { assayName, cohortName, PTMType, cohortControlFilter, cohortCaseFilter, assayColumnIdx, assayColumnValue } = param.proteomeDetails;
+  const { assay, cohort } = param.proteomeDetails;
+  const assayConfig = q.assays?.[assay];
+  if (!assayConfig) throw `queries.proteome.get invalid assay: ${assay}`;
+  const PTMType = q.assays[assay].PTMType;
+  const assayColumnIdx = assayConfig.columnIdx;
+  const assayColumnValue = assayConfig.columnValue;
+  const cohortConfig = assayConfig?.cohorts?.[cohort];
+  if (!cohortConfig) throw `queries.proteome.get invalid cohort: ${cohort}`;
+  const cohortControlFilter = cohortConfig.controlFilter;
+  const cohortCaseFilter = cohortConfig.caseFilter;
   const assayFilter = [{ columnIdx: assayColumnIdx, columnValue: assayColumnValue }];
   const term2sample2value = /* @__PURE__ */ new Map();
   const allEntries = [];
@@ -336,11 +364,13 @@ async function getProteomeValuesFromCohort(ds, param) {
         if (!entryMap.has(row.identifier)) {
           entryMap.set(row.identifier, {
             uniqueIdentifier: row.identifier,
-            assayName,
-            cohortName,
+            assayName: assay,
+            cohortName: cohort,
             PTMType,
             modSites: PTMType ? row.modsite || void 0 : void 0,
             proteinAccession: row.protein_accession,
+            isoform: row.isoform,
+            // refSeq transcript ID mapped from protein_accession
             geneName: row.gene,
             s2v: {}
           });