@sjcrh/proteinpaint-server 2.189.0 → 2.190.0

package/routes/termdb.cluster.js

@@ -1,7 +1,6 @@
 import path from "path";
 import { run_R } from "@sjcrh/proteinpaint-r";
 import { run_rust } from "@sjcrh/proteinpaint-rust";
-import { termdbClusterPayload } from "#types/checkers";
 import * as utils from "#src/utils.js";
 import serverconfig from "#src/serverconfig.js";
 import { gdc_validate_query_geneExpression } from "#src/mds3.gdc.js";
@@ -14,22 +13,10 @@ import {
   NUMERIC_DICTIONARY_TERM,
   termType2label,
   ISOFORM_EXPRESSION,
+  SSGSEA,
   PROTEOME_ABUNDANCE
 } from "#shared/terms.js";
 import { formatElapsedTime } from "#shared/time.js";
-const api = {
-  endpoint: "termdb/cluster",
-  methods: {
-    get: {
-      ...termdbClusterPayload,
-      init
-    },
-    post: {
-      ...termdbClusterPayload,
-      init
-    }
-  }
-};
 function init({ genomes }) {
   return async (req, res) => {
     const q = req.query;
@@ -41,7 +28,9 @@ function init({ genomes }) {
       if (!ds) throw "invalid dataset name";
       if (ds.label === "GDC" && !ds.__gdc?.doneCaching)
         throw "The server has not finished caching the case IDs: try again in about 2 minutes.";
-      if ([GENE_EXPRESSION, ISOFORM_EXPRESSION, METABOLITE_INTENSITY, NUMERIC_DICTIONARY_TERM].includes(q.dataType)) {
+      if ([GENE_EXPRESSION, SSGSEA, ISOFORM_EXPRESSION, METABOLITE_INTENSITY, NUMERIC_DICTIONARY_TERM].includes(
+        q.dataType
+      )) {
         if (!ds.queries?.[q.dataType] && q.dataType !== NUMERIC_DICTIONARY_TERM)
           throw `no ${q.dataType} data on this dataset`;
         if (!q.terms) throw `missing gene list`;
@@ -461,7 +450,7 @@ async function validateNativeIsoform(q, ds) {
   };
 }
 export {
-  api,
+  init,
   validateQueryIsoformExpression,
   validate_query_geneExpression
 };

package/routes/termdb.config.js

@@ -12,20 +12,6 @@ import {
   DNA_METHYLATION,
   SSGSEA
 } from "#shared/terms.js";
-const api = {
-  endpoint: "termdb/config",
-  methods: {
-    get: {
-      init,
-      request: {
-        typeId: "any"
-      },
-      response: {
-        typeId: "any"
-      }
-    }
-  }
-};
 function init({ genomes }) {
   return async (req, res) => {
     const q = req.query;
@@ -69,7 +55,7 @@ function make(q, req, res, ds, genome) {
     defaultTw4correlationPlot: tdb.defaultTw4correlationPlot,
     authFilter: req.query.filter
   };
-  if (tdb.plotConfigByCohort) c.plotConfigByCohort = tdb.plotConfigByCohort;
+  if (tdb.plotConfigByCohort) c.plotConfigByCohort = structuredClone(tdb.plotConfigByCohort);
   if (tdb.multipleTestingCorrection) c.multipleTestingCorrection = tdb.multipleTestingCorrection;
   if (tdb.helpPages) c.helpPages = tdb.helpPages;
   if (tdb.minTimeSinceDx) c.minTimeSinceDx = tdb.minTimeSinceDx;
@@ -97,6 +83,7 @@ function make(q, req, res, ds, genome) {
   if (tdb.displaySampleIds) c.displaySampleIds = tdb.displaySampleIds(c.clientAuthResult);
   c.authFilter = req.query.filter;
   addScatterplots(c, ds, info);
+  tdb.pruneTermdbConfig?.(c, q, ds);
   res.send({ termdbConfig: c });
 }
 function addRestrictAncestries(c, tdb) {
@@ -235,6 +222,14 @@ function addNonDictionaryQueries(c, ds, genome) {
       }
     }
   }
+  if (q.geneRanking) {
+    q2.geneRanking = {
+      rankings: Object.fromEntries(Object.keys(q.geneRanking.rankings).map((k) => [k, true])),
+      modalities: q.geneRanking.modalities,
+      description: q.geneRanking.description,
+      appName: q.geneRanking.appName
+    };
+  }
   if (q.dnaMethylation) {
     q2.dnaMethylation = { unit: q.dnaMethylation.unit };
     if (q.dnaMethylation.promoter) {
@@ -347,6 +342,6 @@ function getSelectCohort(ds, req) {
   return copy;
 }
 export {
-  api,
-  getDsAllowedTermTypes
+  getDsAllowedTermTypes,
+  init
 };

package/routes/termdb.descrstats.js

@@ -1,20 +1,6 @@
-import { descrStatsPayload } from "#types/checkers";
 import { getData } from "#src/termdb.matrix.js";
 import computePercentile from "#shared/compute.percentile.js";
 import { roundValueAuto } from "#shared/roundValue.js";
-const api = {
-  endpoint: "termdb/descrstats",
-  methods: {
-    get: {
-      ...descrStatsPayload,
-      init
-    },
-    post: {
-      ...descrStatsPayload,
-      init
-    }
-  }
-};
 function init({ genomes }) {
   return async (req, res) => {
     const q = req.query;
@@ -121,9 +107,9 @@ function getStdDev(data) {
   return Math.sqrt(variance);
 }
 export {
-  api,
   getDescrStats,
   getMean,
   getStdDev,
-  getVariance
+  getVariance,
+  init
 };

package/routes/termdb.diffMeth.js

@@ -1,19 +1,13 @@
-import { diffMethPayload } from "#types/checkers";
+import { mayLog } from "#src/helpers.ts";
+import { run_R } from "@sjcrh/proteinpaint-r";
+import { formatElapsedTime } from "#shared";
 import { renderVolcano } from "../src/renderVolcano.ts";
-import { readCacheFileOrRecompute, resolveDaContext, resolveDmSampleGroups } from "../src/diffAnalysis.ts";
-const api = {
-  endpoint: "termdb/diffMeth",
-  methods: {
-    get: {
-      ...diffMethPayload,
-      init
-    },
-    post: {
-      ...diffMethPayload,
-      init
-    }
-  }
-};
+import { cacheOrRecompute } from "#src/utils/cacheOrRecompute.ts";
+import {
+  buildGroupValues,
+  canonicalizeSamplelst,
+  resolveDaContext
+} from "#src/utils/sampleGroups.ts";
 function init({ genomes }) {
   return async (req, res) => {
     try {
@@ -32,10 +26,9 @@ function init({ genomes }) {
         });
         return;
       }
-      const result = await readCacheFileOrRecompute({ daRequest: q, genomes });
-      if (result.kind !== "DM") throw new Error("expected DM result from readCacheFileOrRecompute");
-      const rendered = await renderVolcano(result.promoterData, q.volcanoRender);
-      rendered.cacheId = result.cacheId;
+      const { result, cacheId } = await getDmCacheResult(q, genomes);
+      const rendered = await renderVolcano(result.promoterRows, q.volcanoRender);
+      rendered.cacheId = cacheId;
       if (rendered.totalRows === 0)
         throw new Error("No promoters passed filtering. Try relaxing group criteria or selecting more samples.");
       const output = {
@@ -45,11 +38,97 @@ function init({ genomes }) {
       };
       res.send(output);
     } catch (e) {
-      res.send({ status: "error", error: e.message || e });
+      res.status(e.status || 500).send({ status: "error", error: e.message || e, code: e.code });
       if (e instanceof Error && e.stack) console.log(e);
     }
   };
 }
+function dmKeyInputs(req) {
+  return {
+    genome: req.genome,
+    dslabel: req.dslabel,
+    samplelst: canonicalizeSamplelst(req.samplelst),
+    min_samples_per_group: req.min_samples_per_group ?? null,
+    tw: req.tw ?? null,
+    tw2: req.tw2 ?? null,
+    filter: req.filter ?? null,
+    filter0: req.filter0 ?? null
+  };
+}
+async function getDmCacheResult(req, genomes) {
+  const { result, cacheId } = await cacheOrRecompute({
+    computeArgument: dmKeyInputs(req),
+    cacheSubdir: "dm",
+    computeFresh: async () => {
+      const { ds, term_results, term_results2 } = await resolveDaContext(req, genomes);
+      return runDmFresh(req, ds, term_results, term_results2);
+    }
+  });
+  return { result, cacheId };
+}
+async function runDmFresh(param, ds, term_results, term_results2) {
+  const groups = resolveDmSampleGroups(param, ds, term_results, term_results2);
+  if (groups.alerts.length) throw new Error(groups.alerts.join(" | "));
+  const q = ds.queries.dnaMethylation.promoter;
+  const diffMethInput = {
+    // Group 1 is control, group 2 is case (same convention as DE).
+    case: groups.group2names.join(","),
+    control: groups.group1names.join(","),
+    input_file: q.file,
+    min_samples_per_group: param.min_samples_per_group
+  };
+  if (param.tw) {
+    diffMethInput.conf1 = [...groups.conf1_group2, ...groups.conf1_group1];
+    diffMethInput.conf1_mode = param.tw.q.mode;
+    if (new Set(diffMethInput.conf1).size === 1) throw new Error("Confounding variable 1 has only one value");
+  }
+  if (param.tw2) {
+    diffMethInput.conf2 = [...groups.conf2_group2, ...groups.conf2_group1];
+    diffMethInput.conf2_mode = param.tw2.q.mode;
+    if (new Set(diffMethInput.conf2).size === 1) throw new Error("Confounding variable 2 has only one value");
+  }
+  const time1 = Date.now();
+  const result = JSON.parse(await run_R("diffMeth.R", JSON.stringify(diffMethInput)));
+  mayLog("Time taken to run diffMeth:", formatElapsedTime(Date.now() - time1));
+  const cacheResult = {
+    promoterRows: result.promoter_data,
+    sample_size1: groups.group1names.length,
+    sample_size2: groups.group2names.length
+  };
+  return cacheResult;
+}
+function resolveDmSampleGroups(param, ds, term_results, term_results2) {
+  if (param.samplelst?.groups?.length != 2)
+    throw new Error("Exactly 2 sample groups are required for differential methylation analysis.");
+  if (param.samplelst.groups[0].values?.length < 1)
+    throw new Error("Group 1 has no samples. Please select at least one sample.");
+  if (param.samplelst.groups[1].values?.length < 1)
+    throw new Error("Group 2 has no samples. Please select at least one sample.");
+  const q = ds.queries.dnaMethylation?.promoter;
+  if (!q) throw new Error("This dataset does not have promoter-level methylation data configured.");
+  if (!q.file) throw new Error("Promoter methylation data file is not configured for this dataset.");
+  const g1 = buildGroupValues(param.samplelst.groups[0].values, q, ds, param.tw, param.tw2, term_results, term_results2);
+  const g2 = buildGroupValues(param.samplelst.groups[1].values, q, ds, param.tw, param.tw2, term_results, term_results2);
+  const alerts = [];
+  if (g1.names.length < 1) alerts.push("No samples in group 1 have methylation data available.");
+  if (g2.names.length < 1) alerts.push("No samples in group 2 have methylation data available.");
+  const commonnames = g1.names.filter((x) => g2.names.includes(x));
+  if (commonnames.length)
+    alerts.push(
+      `${commonnames.length} sample(s) appear in both groups: ${commonnames.join(", ")}. Please remove duplicates.`
+    );
+  return {
+    group1names: g1.names,
+    group2names: g2.names,
+    conf1_group1: g1.conf1,
+    conf1_group2: g2.conf1,
+    conf2_group1: g1.conf2,
+    conf2_group2: g2.conf2,
+    alerts
+  };
+}
 export {
-  api
+  getDmCacheResult,
+  init,
+  resolveDmSampleGroups
 };

package/routes/termdb.geneRanking.js

@@ -0,0 +1,139 @@
+import path from "path";
+import fs from "fs";
+import { run_R } from "@sjcrh/proteinpaint-r";
+import serverconfig from "#src/serverconfig.js";
+import { clusterMethodLst, distanceMethodLst } from "#shared/clustering.js";
+function init({ genomes }) {
+  return async (req, res) => {
+    try {
+      const q = (req.method === "POST" ? req.body : req.query) || {};
+      if (q.for === "cluster") {
+        await handleCluster(q, res);
+      } else {
+        await handleData(q, res, genomes);
+      }
+    } catch (e) {
+      if (e instanceof Error && e.stack) console.log(e);
+      res.send({ error: e?.message || String(e) });
+    }
+  };
+}
+const fileCache = /* @__PURE__ */ new Map();
+function stripQuotes(s) {
+  if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') return s.slice(1, -1);
+  return s;
+}
+async function parseTsv(absPath) {
+  const text = await fs.promises.readFile(absPath, "utf8");
+  const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
+  if (lines.length === 0) return { columns: [], rows: [] };
+  const columns = lines[0].split("	").map(stripQuotes);
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const fields = lines[i].split("	").map(stripQuotes);
+    const normalizedFields = fields.length < columns.length ? fields.concat(Array(columns.length - fields.length).fill("")) : fields.slice(0, columns.length);
+    const row = normalizedFields.map((v) => {
+      if (v === "" || v === "NA" || v === "NaN") return null;
+      const n = Number(v);
+      return Number.isFinite(n) && v.trim() !== "" ? n : v;
+    });
+    rows.push(row);
+  }
+  return { columns, rows };
+}
+function zscorePerColumnIgnoringNull(matrix, ncol) {
+  const out = matrix.map((r) => [...r]);
+  for (let c = 0; c < ncol; c++) {
+    const vals = [];
+    for (const r of matrix) {
+      const v = r[c];
+      if (v !== null && v !== void 0 && Number.isFinite(v)) vals.push(v);
+    }
+    if (vals.length === 0) continue;
+    const mean = vals.reduce((s, v) => s + v, 0) / vals.length;
+    const sd = Math.sqrt(vals.reduce((s, v) => s + (v - mean) ** 2, 0) / vals.length);
+    for (let r = 0; r < matrix.length; r++) {
+      const v = matrix[r][c];
+      if (v === null || v === void 0 || !Number.isFinite(v)) out[r][c] = null;
+      else out[r][c] = sd === 0 ? 0 : (v - mean) / sd;
+    }
+  }
+  return out;
+}
+async function handleData(q, res, genomes) {
+  const genome = genomes[q.genome];
+  if (!genome) throw "invalid genome";
+  const ds = genome.datasets[q.dslabel];
+  if (!ds) throw "invalid dslabel";
+  const cfg = ds.queries?.geneRanking;
+  if (!cfg || !cfg.rankings) throw "geneRanking not configured for this dataset";
+  if (!q.key) {
+    res.send({ keys: Object.keys(cfg.rankings) });
+    return;
+  }
+  const relPath = cfg.rankings[q.key];
+  if (!relPath) throw "invalid key";
+  if (path.isAbsolute(relPath) || relPath.split(/[\\/]/).includes("..")) throw "invalid file path";
+  const absPath = path.resolve(serverconfig.tpmasterdir, relPath);
+  const tpRoot = path.resolve(serverconfig.tpmasterdir) + path.sep;
+  if (!absPath.startsWith(tpRoot)) throw "invalid file path";
+  const stat = await fs.promises.stat(absPath);
+  const cacheKey = `${q.genome}|${q.dslabel}|${q.key}`;
+  let entry = fileCache.get(cacheKey);
+  if (!entry || entry.mtimeMs !== stat.mtimeMs) {
+    entry = { parsed: await parseTsv(absPath), mtimeMs: stat.mtimeMs };
+    fileCache.set(cacheKey, entry);
+  }
+  res.send({ columns: entry.parsed.columns, rows: entry.parsed.rows });
+}
+async function handleCluster(q, res) {
+  const { row_names, col_names } = q;
+  if (!Array.isArray(q.matrix) || !Array.isArray(row_names) || !Array.isArray(col_names)) {
+    throw "matrix, row_names, and col_names are required";
+  }
+  if (q.matrix.length !== row_names.length) throw "matrix.length must equal row_names.length";
+  if (col_names.length < 2) throw "need at least 2 modalities to cluster";
+  const minAssays = Math.max(2, q.minAssays ?? 3);
+  const keptRows = [];
+  const keptNames = [];
+  for (let i = 0; i < q.matrix.length; i++) {
+    const row = q.matrix[i];
+    if (!Array.isArray(row) || row.length !== col_names.length) continue;
+    const nonNull = row.filter((v) => v !== null && v !== void 0 && Number.isFinite(v)).length;
+    if (nonNull < minAssays) continue;
+    keptRows.push(row.map((v) => v === null || v === void 0 || !Number.isFinite(v) ? null : v));
+    keptNames.push(row_names[i]);
+  }
+  if (keptRows.length < 3) throw `need at least 3 rows with \u2265${minAssays} non-null values for clustering`;
+  const zMatrix = zscorePerColumnIgnoringNull(keptRows, col_names.length);
+  const matrixForR = zMatrix.map((row) => row.map((v) => v === null ? 0 : v));
+  const clusterMethod = q.clusterMethod || "average";
+  const distanceMethod = q.distanceMethod || "euclidean";
+  if (!clusterMethodLst.find((i) => i.value == clusterMethod)) throw "Invalid cluster method";
+  if (!distanceMethodLst.find((i) => i.value == distanceMethod)) throw "Invalid distance method";
+  const inputData = {
+    matrix: matrixForR,
+    row_names: keptNames,
+    col_names,
+    cluster_method: clusterMethod,
+    distance_method: distanceMethod,
+    plot_image: false
+  };
+  const Routput = JSON.parse(await run_R("hclust.R", JSON.stringify(inputData)));
+  const rowOrderIdx = Routput.RowOrder.map((row) => keptNames.indexOf(row.name));
+  const orderedMatrix = rowOrderIdx.map((i) => zMatrix[i]);
+  res.send({
+    row: {
+      merge: Routput.RowMerge,
+      height: Routput.RowHeight,
+      order: Routput.RowOrder,
+      inputOrder: keptNames
+    },
+    usedRowNames: keptNames,
+    usedColNames: col_names,
+    matrix: orderedMatrix
+  });
+}
+export {
+  init
+};

package/routes/termdb.proteome.js

@@ -1,20 +1,6 @@
-import { termdbProteomePayload } from "#types/checkers";
 import { get_ds_tdb } from "#src/termdb.js";
 import * as utils from "#src/utils.js";
 import { mayLimitSamples } from "#src/mds3.filter.js";
-const api = {
-  endpoint: "termdb/proteome",
-  methods: {
-    get: {
-      ...termdbProteomePayload,
-      init
-    },
-    post: {
-      ...termdbProteomePayload,
-      init
-    }
-  }
-};
 function init({ genomes }) {
   return async (req, res) => {
     const q = req.query;
@@ -458,7 +444,7 @@ async function getProteomeValuesFromCohort(ds, param, q) {
   return { term2sample2value, controlSampleIds, bySampleId };
 }
 export {
-  api,
   countDistinctSamples,
+  init,
   validate_query_proteome
 };

package/routes/termdb.runChart.js

@@ -1,5 +1,19 @@
-import { runChartPayload } from "#types/checkers";
 import { getDateFromNumber, getNumberFromDate } from "#shared/terms.js";
+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) {
+      res.send(runChartErrorPayload(e.message || e));
+    }
+  };
+}
 function decimalYearToYearMonth(xRaw) {
   const date = getDateFromNumber(xRaw);
   const t = date.getTime();
@@ -26,19 +40,6 @@ function decimalYearToYearMonth(xRaw) {
   if (!Number.isFinite(month) || month < 1 || month > 12) return null;
   return { yearNum: year, monthNum: month };
 }
-const api = {
-  endpoint: "termdb/runChart",
-  methods: {
-    get: {
-      ...runChartPayload,
-      init
-    },
-    post: {
-      ...runChartPayload,
-      init
-    }
-  }
-};
 async function getRunChart(q, ds) {
   const xTermId = q.xtw["$id"] ?? q.xtw.term?.id;
   const yTermId = q.ytw ? q.ytw["$id"] ?? q.ytw.term?.id : void 0;
@@ -307,26 +308,11 @@ function buildOneSeries(aggregation, xTermId, yTermId, data) {
 function runChartErrorPayload(message) {
   return { error: String(message), series: [] };
 }
-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) {
-      res.send(runChartErrorPayload(e.message || e));
-    }
-  };
-}
 export {
-  api,
   buildFrequencyFromData,
   buildRunChartFromData,
   decimalYearToYearMonth,
   getRunChart,
+  init,
   runChartErrorPayload
 };

package/routes/termdb.sampleScatter.js

@@ -1,26 +1,11 @@
-import { termdbSampleScatterPayload } from "#types/checkers";
-import { getData } from "../src/termdb.matrix.js";
+import { getData } from "#src/termdb.matrix.js";
 import path from "path";
-import serverconfig from "../src/serverconfig.js";
+import serverconfig from "#src/serverconfig.js";
 import { schemeCategory20, getColors, mclass, dt2label, morigin, isNumericTerm } from "#shared";
-import { authApi } from "../src/auth.js";
+import { authApi } from "#src/auth.js";
 import { run_R } from "@sjcrh/proteinpaint-r";
-import { read_file } from "../src/utils.js";
-import { getDescrStats } from "#routes/termdb.descrstats.ts";
-import { isSingleCellTerm, SINGLECELL_GENE_EXPRESSION, SINGLECELL_CELLTYPE } from "#shared/terms.js";
-const api = {
-  endpoint: "termdb/sampleScatter",
-  methods: {
-    get: {
-      ...termdbSampleScatterPayload,
-      init
-    },
-    post: {
-      ...termdbSampleScatterPayload,
-      init
-    }
-  }
-};
+import { read_file } from "#src/utils.js";
+import { getDescrStats } from "./termdb.descrstats.ts";
 const refColor = "#F5F5DC";
 function init({ genomes }) {
   return async function(req, res) {
@@ -31,8 +16,6 @@ function init({ genomes }) {
       }
       const g = genomes[q.genome];
       const ds = g.datasets[q.dslabel];
-      if (q.singleCellPlot)
-        return getSingleCellScatter(req, res, ds);
       let refSamples = [], cohortSamples;
       const terms = [];
       if (q.colorTW) terms.push(q.colorTW);
@@ -121,80 +104,6 @@ function init({ genomes }) {
     }
   };
 }
-async function getSingleCellScatter(req, res, ds) {
-  const q = req.query;
-  const { name, sample } = q.singleCellPlot;
-  try {
-    const tw = q.colorTW;
-    if (!tw || !isSingleCellTerm(tw.term))
-      throw new Error("colorTW must be provided and be a single cell term for single cell scatter plot");
-    const arg = { plots: [name], sample };
-    if (tw.term.type == SINGLECELL_GENE_EXPRESSION) arg.gene = tw.term.gene;
-    else if (tw.term.type == SINGLECELL_CELLTYPE) arg.colorBy = tw.term.name;
-    else throw new Error(`unsupported single cell term type: ${tw.term.type}`);
-    const data = await ds.queries.singleCell.data.get(arg);
-    const plot = data.plots[0];
-    const cells = [...plot.expCells, ...plot.noExpCells];
-    const groups = tw.q?.customset?.groups;
-    const cat2GrpName = /* @__PURE__ */ new Map();
-    if (groups) {
-      for (const group of groups) {
-        for (const value of Object.values(group.values)) {
-          cat2GrpName.set(value.key, group.name);
-        }
-      }
-    }
-    const samples = cells.map((cell) => {
-      let category = cell.category;
-      const groupName = cat2GrpName.get(category);
-      if (groupName !== void 0) category = groupName;
-      const hidden = {
-        category: tw?.q?.hiddenValues ? category in tw.q.hiddenValues : false
-      };
-      return {
-        sample: cell.cellId,
-        sampleId: cell.cellId,
-        x: cell.x,
-        y: cell.y,
-        z: 0,
-        category,
-        shape: "Ref",
-        hidden,
-        geneExp: cell.geneExp
-      };
-    });
-    const [xMin, xMax, yMin, yMax] = samples.reduce(
-      (s, d) => [d.x < s[0] ? d.x : s[0], d.x > s[1] ? d.x : s[1], d.y < s[2] ? d.y : s[2], d.y > s[3] ? d.y : s[3]],
-      [samples[0].x, samples[0].x, samples[0].y, samples[0].y]
-    );
-    const categories = new Set(samples.map((s) => s.category));
-    const colorMap = {};
-    if (tw.term.type != SINGLECELL_GENE_EXPRESSION) {
-      const defaultK2c = getColors(categories.size);
-      const k2c = (category) => {
-        const dsTerm = ds.queries.singleCell?.terms ? ds.queries.singleCell.terms.find((t) => t.name == tw.term.name) : void 0;
-        return tw.term.values?.[category]?.color || dsTerm?.values?.[category]?.color || defaultK2c(category);
-      };
-      for (const category of categories) {
-        const color = k2c(category);
-        colorMap[category] = {
-          sampleCount: samples.filter((s) => s.category == category).length,
-          color,
-          key: category
-        };
-      }
-    }
-    const shapeLegend = [["Ref", { sampleCount: samples.length, shape: 0, key: "Ref" }]];
-    const colorLegend = Object.entries(colorMap);
-    res.send({
-      result: { Default: { samples, colorLegend, shapeLegend } },
-      range: { xMin, xMax, yMin, yMax }
-    });
-  } catch (e) {
-    console.log(e);
-    res.send({ error: e.message || e });
-  }
-}
 async function getSamples(ds, plot) {
   if (!plot.filterableSamples) await loadFile(plot, ds);
   return [readSamples(plot.referenceSamples), readSamples(plot.filterableSamples)];
@@ -518,7 +427,8 @@ async function trigger_getLowessCurve(q, res) {
   return res.send(lowessCurve);
 }
 export {
-  api,
+  init,
   mayInitiateScatterplots,
+  refColor,
   trigger_getLowessCurve
 };