@sjcrh/proteinpaint-server 2.171.0 → 2.172.0

package/dataset/termdb.test.js

@@ -2,7 +2,7 @@ function termdb_test_default() {
   return {
     isMds3: true,
     isSupportedChartOverride: {
-      runChart: () => true,
+      runChart2: () => true,
       frequencyChart: () => true,
       report: () => true,
       summarizeMutationDiagnosis: () => true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.171.0",
+  "version": "2.172.0",
   "type": "module",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "src/app.js",
@@ -62,11 +62,11 @@
   },
   "dependencies": {
     "@sjcrh/augen": "2.143.0",
-    "@sjcrh/proteinpaint-python": "2.171.0-0",
+    "@sjcrh/proteinpaint-python": "2.172.0",
     "@sjcrh/proteinpaint-r": "2.152.1-0",
     "@sjcrh/proteinpaint-rust": "2.171.0",
     "@sjcrh/proteinpaint-shared": "2.171.0-0",
-    "@sjcrh/proteinpaint-types": "2.171.0",
+    "@sjcrh/proteinpaint-types": "2.172.0",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
     "better-sqlite3": "^12.4.1",

package/routes/termdb.runChart.js

@@ -0,0 +1,215 @@
+import { runChartPayload } from "#types/checkers";
+const api = {
+  endpoint: "termdb/runChart",
+  methods: {
+    get: {
+      ...runChartPayload,
+      init
+    },
+    post: {
+      ...runChartPayload,
+      init
+    }
+  }
+};
+async function getRunChart(q, ds) {
+  const terms = [];
+  let xTermId;
+  let yTermId;
+  if (q.term && q.term2) {
+    const tws = [
+      { term: q.term, q: { mode: "continuous" }, $id: q.term.id },
+      { term: q.term2, q: { mode: "continuous" }, $id: q.term2.id }
+    ];
+    terms.push(...tws);
+    xTermId = q.term.id;
+    yTermId = q.term2.id;
+  } else {
+    throw new Error("term and term2 must be provided");
+  }
+  if (!xTermId || !yTermId) {
+    throw new Error("Unable to determine term IDs for x and y axes");
+  }
+  const { getData } = await import("../src/termdb.matrix.js");
+  const data = await getData(
+    {
+      filter: q.filter,
+      terms,
+      __protected__: q.__protected__
+    },
+    ds,
+    true
+  );
+  if (data.error) throw new Error(data.error);
+  return buildRunChartFromData(q.aggregation, xTermId, yTermId, data);
+}
+function buildRunChartFromData(aggregation, xTermId, yTermId, data) {
+  const buckets = {};
+  let skippedSamples = 0;
+  for (const sampleId in data.samples || {}) {
+    const sample = data.samples[sampleId];
+    const xRaw = sample?.[xTermId]?.value ?? sample?.[xTermId]?.key;
+    const yRaw = sample?.[yTermId]?.value ?? sample?.[yTermId]?.key;
+    if (xRaw == null || yRaw == null) {
+      skippedSamples++;
+      console.log(
+        `Skipping sample ${sampleId}: Missing x or y value - xTermId=${xTermId} (value: ${xRaw}), yTermId=${yTermId} (value: ${yRaw})`
+      );
+      continue;
+    }
+    if (typeof xRaw !== "number") {
+      throw new Error(
+        `x value must be a number for sample ${sampleId}: xTermId=${xTermId}, received type ${typeof xRaw}, value: ${xRaw}`
+      );
+    }
+    let year = null;
+    let month = null;
+    const parts = String(xRaw).split(".");
+    year = Number(parts[0]);
+    if (parts.length > 1) {
+      const decimalPart = parts[1];
+      if (decimalPart.length === 2) {
+        const monthCandidate = Number(decimalPart);
+        if (monthCandidate >= 1 && monthCandidate <= 12) {
+          month = monthCandidate;
+        } else {
+          const frac = xRaw - year;
+          month = Math.floor(frac * 12) + 1;
+        }
+      } else {
+        const frac = xRaw - year;
+        month = Math.floor(frac * 12) + 1;
+      }
+    } else {
+      month = 1;
+    }
+    if (year == null || month == null || Number.isNaN(year) || Number.isNaN(month)) {
+      throw new Error(
+        `Invalid date value for sample ${sampleId}: xTermId=${xTermId}, xRaw=${xRaw}, parsed year=${year}, month=${month}`
+      );
+    }
+    const bucketKey = `${year}-${String(month).padStart(2, "0")}`;
+    const x = Number(`${year}.${String(month).padStart(2, "0")}`);
+    const date = new Date(year, month - 1, 1);
+    const xName = date.toLocaleString("en-US", { month: "long", year: "numeric" });
+    if (!buckets[bucketKey]) {
+      buckets[bucketKey] = {
+        x,
+        xName,
+        ySum: 0,
+        count: 0,
+        success: 0,
+        total: 0,
+        countSum: 0,
+        sortKey: year * 100 + month,
+        yValues: []
+      };
+    }
+    if (aggregation === "proportion") {
+      if (typeof yRaw === "boolean") {
+        buckets[bucketKey].success += yRaw ? 1 : 0;
+        buckets[bucketKey].total += 1;
+      } else if (typeof yRaw === "number") {
+        const yn = Number(yRaw);
+        if (!Number.isFinite(yn)) {
+          throw new Error(
+            `Non-finite y value for proportion aggregation in sample ${sampleId}: yTermId=${yTermId}, yRaw=${yRaw}`
+          );
+        }
+        if (yn <= 1 && yn >= 0) {
+          buckets[bucketKey].success += yn;
+          buckets[bucketKey].total += 1;
+        } else {
+          buckets[bucketKey].success += yn;
+          buckets[bucketKey].total += 1;
+        }
+      } else if (typeof yRaw === "object" && yRaw != null) {
+        const s = Number(yRaw.success ?? yRaw.y ?? yRaw.value ?? NaN);
+        const t = Number(yRaw.total ?? yRaw.n ?? 1);
+        if (!Number.isFinite(s) || !Number.isFinite(t)) {
+          throw new Error(
+            `Non-finite success or total value for proportion aggregation in sample ${sampleId}: yTermId=${yTermId}, success=${s}, total=${t}`
+          );
+        }
+        buckets[bucketKey].success += s;
+        buckets[bucketKey].total += t;
+      } else {
+        throw new Error(
+          `Invalid y value type for proportion aggregation in sample ${sampleId}: yTermId=${yTermId}, type=${typeof yRaw}, value=${yRaw}`
+        );
+      }
+    } else if (aggregation === "count") {
+      const yn = Number(yRaw);
+      if (!Number.isFinite(yn)) {
+        throw new Error(
+          `Non-finite y value for count aggregation in sample ${sampleId}: yTermId=${yTermId}, yRaw=${yRaw}`
+        );
+      }
+      buckets[bucketKey].countSum += yn;
+      buckets[bucketKey].count += 1;
+    } else {
+      const yn = Number(yRaw);
+      if (!Number.isFinite(yn)) {
+        throw new Error(
+          `Non-finite y value for mean aggregation in sample ${sampleId}: yTermId=${yTermId}, yRaw=${yRaw}`
+        );
+      }
+      buckets[bucketKey].ySum += yn;
+      buckets[bucketKey].count += 1;
+      buckets[bucketKey].yValues.push(yn);
+    }
+  }
+  if (skippedSamples > 0) {
+    console.log(`buildRunChartFromData: Skipped ${skippedSamples} sample(s) due to missing x or y values`);
+  }
+  const points = Object.values(buckets).sort((a, b) => a.sortKey - b.sortKey).map((b) => {
+    if (aggregation === "proportion") {
+      const total = b.total || 0;
+      const succ = b.success || 0;
+      const y = total ? Math.round(succ / total * 1e3) / 1e3 : 0;
+      return { x: b.x, xName: b.xName, y, sampleCount: total };
+    } else if (aggregation === "count") {
+      const y = Math.round((b.countSum || 0) * 100) / 100;
+      return { x: b.x, xName: b.xName, y, sampleCount: b.count };
+    } else {
+      const avg = b.count ? Math.round(b.ySum / b.count * 100) / 100 : 0;
+      return { x: b.x, xName: b.xName, y: avg, sampleCount: b.count };
+    }
+  });
+  const yValues = points.map((p) => p.y).filter((v) => typeof v === "number" && !Number.isNaN(v));
+  const median = yValues.length > 0 ? (() => {
+    const sorted = [...yValues].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  })() : 0;
+  return {
+    status: "ok",
+    series: [
+      {
+        median,
+        points
+      }
+    ]
+  };
+}
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const q = req.query;
+      const genome = genomes[q.genome];
+      if (!genome) throw new Error("invalid genome name");
+      const ds = genome.datasets?.[q.dslabel];
+      if (!ds) throw new Error("invalid ds");
+      const result = await getRunChart(q, ds);
+      res.send(result);
+    } catch (e) {
+      console.log(e.stack);
+      res.send({ error: e.message || e });
+    }
+  };
+}
+export {
+  api,
+  buildRunChartFromData,
+  getRunChart
+};