@sjcrh/proteinpaint-server 2.188.1 → 2.190.0

package/routes/termdb.chat3.js

@@ -1,209 +0,0 @@
-import { ChatPayload } from "#types/checkers";
-import { mayLog } from "#src/helpers.ts";
-import { formatElapsedTime } from "#shared";
-import { readJSONFile, parse_geneset_db, getChatRelatedPlotTypes } from "./chat/utils.ts";
-import { classifyQuery } from "./chat/classify1.ts";
-import { classifyPlotType } from "./chat/plot.ts";
-import { classifyNotPlot } from "./chat/classify2.ts";
-import { inferScaffold } from "./chat/scaffold.ts";
-import serverconfig from "../src/serverconfig.js";
-import { getDsAllowedTermTypes } from "./termdb.config.ts";
-import { phrase2entity } from "./chat/phrase2entity.ts";
-import { inferTermObjFromEntity } from "./chat/entity2termObj.ts";
-import { resolveToTwTvs } from "./chat/entity2twTvs.ts";
-import { answerDataQueries } from "./chat/dataQueries.ts";
-import path from "path";
-import fs from "fs";
-import { resolveToPlotState } from "./chat/scaffold2state.ts";
-const api = {
-  endpoint: "termdb/chat3",
-  methods: {
-    get: {
-      ...ChatPayload,
-      init
-    },
-    post: {
-      ...ChatPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    const q = req.query;
-    try {
-      const genome = genomes[q.genome];
-      if (!genome) throw "invalid genome";
-      const ds = genome.datasets?.[q.dslabel];
-      if (!ds) throw "invalid dslabel";
-      const aiFilesDir = serverconfig.binpath + "/../../dataset/ai/" + q.dslabel;
-      let agentFiles = [];
-      try {
-        agentFiles = await fs.readdirSync(aiFilesDir).filter((file) => file.endsWith(".json"));
-      } catch (err) {
-        if (err.code === "ENOENT") throw new Error(`Directory not found: ${aiFilesDir}`);
-        if (err.code === "ENOTDIR") throw new Error(`Path is not a directory: ${aiFilesDir}`);
-        throw err;
-      }
-      const llm = serverconfig.llm;
-      if (!llm) throw "serverconfig.llm is not configured";
-      if (llm.provider !== "SJ" && llm.provider !== "ollama" && llm.provider !== "huggingface" && llm.provider !== "azure") {
-        throw "llm.provider must be 'SJ', 'ollama', 'huggingface', or 'azure'";
-      }
-      let rawFilter;
-      if (typeof q.filter === "string") {
-        try {
-          rawFilter = JSON.parse(q.filter);
-        } catch (e) {
-          throw new Error("Failed to parse filter JSON string: " + e);
-        }
-      } else {
-        rawFilter = q.filter;
-      }
-      const filter = rawFilter && typeof rawFilter === "object" ? rawFilter : {};
-      const lst = Array.isArray(filter.lst) ? filter.lst : [];
-      const cohortFilter = lst.find((item) => item.tag === "cohortFilter");
-      const cohortKey = cohortFilter ? cohortFilter.tvs.values[0].key : "";
-      const supportedPlotTypes = ds.cohort.termdb.q?.getSupportedChartTypes(req)?.[cohortKey];
-      const chatSupportedPlotTypes = getChatRelatedPlotTypes(supportedPlotTypes);
-      const genedb = serverconfig.tpmasterdir + "/" + genome.genedb.dbfile;
-      const allowedTermTypes = getDsAllowedTermTypes(ds);
-      const ai_output_json = await run_chat_pipeline(
-        q.prompt,
-        llm,
-        ds,
-        genedb,
-        agentFiles,
-        aiFilesDir,
-        chatSupportedPlotTypes,
-        allowedTermTypes,
-        genome
-        // 	testing
-      );
-      mayLog("From init: Final AI output JSON:", JSON.stringify(ai_output_json));
-      res.send(ai_output_json);
-    } catch (e) {
-      if (e.stack) mayLog(e.stack);
-      res.send({ error: e?.message || e });
-    }
-  };
-}
-async function run_chat_pipeline(userPrompt, llm, ds, genedb, agentFiles, aiFilesDir, supportedPlotTypes, allowedTermTypes, genome) {
-  if (!fs.existsSync(path.join(aiFilesDir, "main.json")))
-    throw "Main data file is not specified for dataset:" + ds.label;
-  const dataset_json = await readJSONFile(path.join(aiFilesDir, "main.json"));
-  const time1 = (/* @__PURE__ */ new Date()).valueOf();
-  const class_response = await classifyQuery(userPrompt, llm);
-  mayLog("Time taken for classification:", formatElapsedTime(Date.now() - time1));
-  let ai_output_json;
-  if (class_response.type === "notplot") {
-    const time2 = (/* @__PURE__ */ new Date()).valueOf();
-    const notPlotResult = await classifyNotPlot(userPrompt, llm, agentFiles, aiFilesDir);
-    mayLog("Time taken for classify2:", formatElapsedTime(Date.now() - time2));
-    if (notPlotResult.type === "html") {
-      ai_output_json = notPlotResult;
-    } else {
-      ai_output_json = {
-        type: "text",
-        text: "Your query does not appear to be related to the available data visualizations. Please try rephrasing your question."
-      };
-    }
-  } else if (class_response.type === "binaryQuery") {
-    const answer = await answerDataQueries(userPrompt, llm, allowedTermTypes);
-    if (!answer) throw "Couldn't decide if this is data related query!";
-    mayLog("Data Binary Query: ", answer);
-    ai_output_json = answer;
-  } else if (class_response.type === "plot") {
-    let time = (/* @__PURE__ */ new Date()).valueOf();
-    const plotType = await classifyPlotType(userPrompt, llm);
-    mayLog("Time taken to classify plot type:", formatElapsedTime(Date.now() - time));
-    if (!supportedPlotTypes.includes(plotType)) {
-      const log = 'Plot type: "' + plotType + '" is not supported.';
-      ai_output_json = {
-        type: "text",
-        text: log
-      };
-      mayLog(log);
-      return ai_output_json;
-    }
-    const genes_list = await parse_geneset_db(genedb);
-    mayLog("#################################################");
-    mayLog("####### First phase: Infer Plot Scaffolds #######");
-    mayLog("#################################################");
-    time = (/* @__PURE__ */ new Date()).valueOf();
-    const dataset_db = serverconfig.tpmasterdir + "/" + ds.cohort.db.file;
-    const scaffoldResult = await inferScaffold(
-      userPrompt,
-      plotType,
-      llm,
-      genome,
-      genes_list,
-      allowedTermTypes,
-      dataset_json,
-      ds,
-      dataset_db
-    );
-    mayLog("ScaffoldResult: ", scaffoldResult);
-    if (plotType === "hiercluster" && "plot" in scaffoldResult && scaffoldResult.type === "plot" || "text" in scaffoldResult && scaffoldResult.type === "text") {
-      return scaffoldResult;
-    }
-    mayLog("Time taken to infer scaffold:", formatElapsedTime(Date.now() - time));
-    if (!scaffoldResult)
-      throw "Scaffold result is empty or undefined, which is unexpected. Please check the inferScaffold agent for potential issues.";
-    if ("type" in scaffoldResult && scaffoldResult.type === "text") {
-      return scaffoldResult;
-    }
-    const subplotType = scaffoldResult.plotType === "summary" ? scaffoldResult.chartType : void 0;
-    mayLog("#################################################");
-    mayLog("####### Second phase: From Scaffolds's phrases infer Entities #######");
-    mayLog("#################################################");
-    time = (/* @__PURE__ */ new Date()).valueOf();
-    const phrase2entityResult = await phrase2entity(
-      scaffoldResult,
-      plotType,
-      llm,
-      genes_list,
-      dataset_json,
-      ds
-    );
-    mayLog("Time taken to phrase 2 entity:", formatElapsedTime(Date.now() - time));
-    if ("type" in phrase2entityResult && phrase2entityResult.type === "text") {
-      return phrase2entityResult;
-    }
-    mayLog(phrase2entityResult);
-    mayLog("#################################################");
-    mayLog("####### Third phase: From Entities infer Term Objects #######");
-    mayLog("#################################################");
-    time = (/* @__PURE__ */ new Date()).valueOf();
-    const termObj = await inferTermObjFromEntity(
-      phrase2entityResult,
-      plotType,
-      llm,
-      dataset_db,
-      genes_list
-    );
-    mayLog("Time taken to infer term objects:", formatElapsedTime(Date.now() - time));
-    mayLog("Inferred termObj from entity:", JSON.stringify(termObj));
-    mayLog("#################################################");
-    mayLog("####### Fourth phase: From Term Objects to TwTvs Objects #######");
-    mayLog("#################################################");
-    time = (/* @__PURE__ */ new Date()).valueOf();
-    const twTvsObj = await resolveToTwTvs(termObj, plotType, llm, dataset_db);
-    mayLog("Time taken to resolve to TwTvs object from termObj:", formatElapsedTime(Date.now() - time));
-    if ("type" in twTvsObj && twTvsObj.type === "text") {
-      return twTvsObj;
-    }
-    mayLog("twTvsObj:", twTvsObj);
-    mayLog("#################################################");
-    mayLog("####### Fifth/Final phase: From TwTvs Objects to Plot States #######");
-    mayLog("#################################################");
-    time = (/* @__PURE__ */ new Date()).valueOf();
-    ai_output_json = resolveToPlotState(twTvsObj, plotType, subplotType);
-    mayLog("Time taken to resolve to plot state:", formatElapsedTime(Date.now() - time));
-  }
-  return ai_output_json;
-}
-export {
-  api,
-  run_chat_pipeline
-};

package/routes/termdb.cohort.summary.js

@@ -1,37 +0,0 @@
-import { termdbCohortSummaryPayload } from "#types/checkers";
-import { get_ds_tdb } from "#src/termdb.js";
-import { get_samples } from "#src/termdb.sql.js";
-import { authApi } from "#src/auth.js";
-const api = {
-  endpoint: "termdb/cohort/summary",
-  methods: {
-    get: {
-      ...termdbCohortSummaryPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    const q = req.query;
-    try {
-      const genome = genomes[q.genome];
-      if (!genome) throw "invalid genome";
-      const [ds] = get_ds_tdb(genome, q);
-      authApi.mayAdjustFilter(req.query, ds, []);
-      let count;
-      if (q.filter?.lst?.length) {
-        const samples = await get_samples(q, ds);
-        count = samples.length;
-      } else count = ds.cohort.termdb.q?.getCohortSampleCount?.(q.cohort) || 1;
-      res.send({ count });
-    } catch (e) {
-      res.send({ error: e.message || e });
-      if (e.stack) console.log(e.stack);
-      else console.log(e);
-    }
-  };
-}
-export {
-  api
-};

package/routes/termdb.cohorts.js

@@ -1,41 +0,0 @@
-import { termdbCohortsPayload } from "#types/checkers";
-import { get_ds_tdb } from "#src/termdb.js";
-const api = {
-  endpoint: "termdb/cohorts",
-  methods: {
-    get: {
-      ...termdbCohortsPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    const q = req.query;
-    try {
-      const genome = genomes[q.genome];
-      if (!genome) throw "invalid genome";
-      const [ds] = get_ds_tdb(genome, q);
-      const result = getCohortsData(ds);
-      res.send(result);
-    } catch (e) {
-      res.send({ error: e.message || e });
-      if (e.stack) console.log(e.stack);
-      else console.log(e);
-    }
-  };
-}
-function getCohortsData(ds) {
-  if (!ds.cohort.db) return { cohorts: [], features: [], cfeatures: [] };
-  const features = ds.cohort.db.connection.prepare("select * from features").all();
-  const cohorts = ds.cohort.db.connection.prepare(
-    `select * from cohorts where cohort in (select distinct(cohort) from cohort_features)
-		 order by sample_count desc`
-  ).all();
-  const cfeatures = ds.cohort.db.connection.prepare("select * from cohort_features").all();
-  return { cohorts, features, cfeatures };
-}
-export {
-  api,
-  getCohortsData
-};

package/routes/termdb.dapVolcano.js

@@ -1,80 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import { dapVolcanoPayload } from "#types/checkers";
-import { get_ds_tdb } from "#src/termdb.js";
-import { renderVolcano } from "../src/renderVolcano.ts";
-import serverconfig from "../src/serverconfig.js";
-import { countDistinctSamples } from "./termdb.proteome.ts";
-const api = {
-  endpoint: "termdb/dapVolcano",
-  methods: {
-    get: {
-      ...dapVolcanoPayload,
-      init
-    },
-    post: {
-      ...dapVolcanoPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    try {
-      const q = req.query;
-      const genome = genomes[q.genome];
-      if (!genome) throw "invalid genome";
-      const [ds] = get_ds_tdb(genome, q);
-      const proteomeConfig = ds.queries?.proteome;
-      if (!proteomeConfig) throw "proteome not configured for this dataset";
-      const organismConfig = proteomeConfig.organisms?.[q.organism];
-      if (!organismConfig) throw "invalid organism";
-      const assayConfig = organismConfig.assays?.[q.assay];
-      if (!assayConfig) throw "invalid assay";
-      const cohortConfig = assayConfig.cohorts?.[q.cohort];
-      if (!cohortConfig) throw "invalid cohort";
-      if (!cohortConfig.DAPfile) throw "DAP file not configured for this cohort";
-      const organismFilter = [{ columnIdx: organismConfig.columnIdx, columnValue: organismConfig.columnValue }];
-      const assayFilter = [{ columnIdx: assayConfig.columnIdx, columnValue: assayConfig.columnValue }];
-      const db = proteomeConfig.db;
-      const controlCount = countDistinctSamples(db, [...organismFilter, ...assayFilter, ...cohortConfig.controlFilter]);
-      const caseCount = countDistinctSamples(db, [...organismFilter, ...assayFilter, ...cohortConfig.caseFilter]);
-      if (q.countsOnly) {
-        res.send({ sample_size1: controlCount, sample_size2: caseCount });
-        return;
-      }
-      const filePath = path.join(serverconfig.tpmasterdir, cohortConfig.DAPfile);
-      const content = await fs.readFile(filePath, "utf8");
-      const lines = content.trim().split("\n");
-      const rustRows = [];
-      for (let i = 1; i < lines.length; i++) {
-        const parts = lines[i].split("	");
-        if (parts.length < 4) continue;
-        const fc = Number(parts[2]);
-        if (!Number.isFinite(fc)) continue;
-        const pValue = Number(parts[3]);
-        if (!Number.isFinite(pValue)) continue;
-        rustRows.push({
-          gene_name: parts[0],
-          gene: parts[1],
-          fold_change: fc,
-          original_p_value: pValue,
-          adjusted_p_value: pValue
-        });
-      }
-      const rendered = await renderVolcano(rustRows, q.volcanoRender);
-      for (const d of rendered.dots) delete d.adjusted_p_value;
-      res.send({
-        data: rendered,
-        sample_size1: controlCount,
-        sample_size2: caseCount
-      });
-    } catch (e) {
-      res.send({ status: "error", error: e.message || e });
-      if (e instanceof Error && e.stack) console.log(e);
-    }
-  };
-}
-export {
-  api
-};

package/routes/termdb.dmr.js

@@ -1,93 +0,0 @@
-import { TermdbDmrPayload } from "#types/checkers";
-import { run_rust } from "@sjcrh/proteinpaint-rust";
-import { run_R } from "@sjcrh/proteinpaint-r";
-import { invalidcoord } from "#shared/common.js";
-import { mayLog } from "#src/helpers.ts";
-import serverconfig from "#src/serverconfig.js";
-import { formatElapsedTime } from "#shared";
-const api = {
-  endpoint: "termdb/dmr",
-  methods: {
-    get: {
-      ...TermdbDmrPayload,
-      init
-    },
-    post: {
-      ...TermdbDmrPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    try {
-      const q = req.query;
-      const genome = genomes[q.genome];
-      if (!genome) throw "unknown genome";
-      const ds = genome.datasets?.[q.dslabel];
-      if (!ds) throw "unknown ds";
-      if (!ds.queries?.dnaMethylation) throw new Error("This dataset does not support DNA methylation analysis.");
-      if (!Array.isArray(q.group1) || q.group1.length == 0)
-        throw new Error("Group 1 has no samples. Please select at least one sample.");
-      if (!Array.isArray(q.group2) || q.group2.length == 0)
-        throw new Error("Group 2 has no samples. Please select at least one sample.");
-      if (invalidcoord(genome, q.chr, q.start, q.stop))
-        throw new Error(`Invalid genomic coordinates: ${q.chr}:${q.start}-${q.stop}`);
-      const SERVER_MAX_REGION_BP = 1e7;
-      const span = q.stop - q.start;
-      if (span > SERVER_MAX_REGION_BP)
-        throw new Error(
-          `Region too large (${(span / 1e6).toFixed(1)} Mb). Server maximum is ${SERVER_MAX_REGION_BP / 1e6} Mb.`
-        );
-      const group1 = q.group1.map((s) => s.sample).filter(Boolean);
-      const group2 = q.group2.map((s) => s.sample).filter(Boolean);
-      if (group1.length < 3)
-        throw new Error(`Group 1 needs at least 3 samples with methylation data, got ${group1.length}.`);
-      if (group2.length < 3)
-        throw new Error(`Group 2 needs at least 3 samples with methylation data, got ${group2.length}.`);
-      const useR = q.backend === "r";
-      const dmrInput = {
-        probe_h5_file: ds.queries.dnaMethylation.file,
-        cachedir: serverconfig.cachedir,
-        genome: q.genome,
-        chr: q.chr,
-        start: q.start,
-        stop: q.stop,
-        case: group2.join(","),
-        control: group1.join(","),
-        fdr_cutoff: q.fdr_cutoff,
-        lambda: q.lambda,
-        C: q.C,
-        blockWidth: q.blockWidth,
-        devicePixelRatio: q.devicePixelRatio,
-        maxLoessRegion: q.maxLoessRegion,
-        colors: q.colors
-      };
-      const time1 = Date.now();
-      const result = useR ? JSON.parse(await run_R("dmrcate_full.R", JSON.stringify(dmrInput))) : JSON.parse(await run_rust("dmrcate", JSON.stringify(dmrInput)));
-      mayLog(`DMR analysis (${useR ? "R" : "Rust"}) time:`, formatElapsedTime(Date.now() - time1));
-      if (result.error) throw new Error(result.error);
-      if (result.diagnostic?.probes) {
-        const p = result.diagnostic.probes;
-        mayLog(
-          `${useR ? "R" : "Rust"} probes logFC:`,
-          p.logFC,
-          "fdr:",
-          p.fdr?.map((f) => f.toExponential(4))
-        );
-      }
-      res.send({
-        status: "ok",
-        dmrs: result.dmrs,
-        diagnostic: result.diagnostic
-      });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      res.send({ error: msg });
-      if (e instanceof Error && e.stack) console.log(e);
-    }
-  };
-}
-export {
-  api
-};

package/routes/termdb.filterTermValues.js

@@ -1,89 +0,0 @@
-import { FilterTermValuesPayload } from "#types/checkers";
-import { getData } from "../src/termdb.matrix.js";
-import { authApi } from "#src/auth.js";
-import { filterJoin } from "#shared/filter.js";
-import { get_samples } from "../src/termdb.sql.js";
-const api = {
-  endpoint: "termdb/filterTermValues",
-  methods: {
-    get: {
-      ...FilterTermValuesPayload,
-      init
-    },
-    post: {
-      ...FilterTermValuesPayload,
-      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];
-      res.send(await getFilters(req.query, ds));
-    } catch (e) {
-      if (e.stack) console.log(e.stack);
-      res.send({ status: "error", error: e.message || e });
-    }
-  };
-}
-async function getFilters(query, ds) {
-  const samplesPerFilter = await getSamplesPerFilter(query, ds);
-  const filtersData = await getData(
-    {
-      terms: query.terms,
-      __protected__: query.__protected__
-    },
-    ds
-  );
-  const tw2List = {};
-  for (const tw of query.terms) {
-    const values = getList(samplesPerFilter, filtersData, tw, query.showAll);
-    tw2List[tw.term.id] = values;
-  }
-  return { ...tw2List };
-}
-async function getSamplesPerFilter(q, ds) {
-  q.ds = ds;
-  const samples = {};
-  const userFilter = q.filter ? structuredClone(q.filter) : null;
-  if (!q.filterByUserSites) {
-    q.__protected__.ignoredTermIds.push(q.facilityTW.term.id);
-    authApi.mayAdjustFilter(q, ds, q.terms);
-  }
-  for (const id in q.filters) {
-    const termfilter = id == q.facilityTW.term.id ? userFilter : q.filter;
-    let filter = q.filters[id];
-    if (q.filter) filter = filterJoin([termfilter, q.filters[id]]);
-    const result = (await get_samples({ filter, __protected__: q.__protected__ }, q.ds)).map((i) => i.id);
-    samples[id] = Array.from(new Set(result));
-  }
-  return samples;
-}
-function getList(samplesPerFilter, filtersData, tw, showAll) {
-  const values = Object.values(tw.term.values);
-  values.sort((v1, v2) => v1.label.localeCompare(v2.label));
-  const twSamples = samplesPerFilter[tw.term.id];
-  const data = [];
-  for (const sample of twSamples) {
-    data.push(filtersData.samples[sample]);
-  }
-  const annotations = data.filter((s) => s != void 0).map((sample) => sample[tw.$id]?.value);
-  const sampleValues = Array.from(new Set(annotations));
-  const filteredValues = [];
-  for (const value of values) {
-    let label = value.label.replace(/["']/g, "");
-    if (label.length > 50) label = label.slice(0, 47) + "...";
-    const disabled = !sampleValues.includes(value.key || value.label);
-    if (!showAll && disabled) continue;
-    filteredValues.push({ value: value.key || value.label, label, disabled });
-  }
-  filteredValues.unshift({ label: "", value: "" });
-  filteredValues.sort((a, b) => a.label.localeCompare(b.label));
-  return filteredValues;
-}
-export {
-  api
-};

package/routes/termdb.isoformAvailability.js

@@ -1,35 +0,0 @@
-import { TermdbIsoformAvailabilityPayload } from "#types/checkers";
-const api = {
-  endpoint: "termdb/isoformAvailability",
-  methods: {
-    get: {
-      ...TermdbIsoformAvailabilityPayload,
-      init
-    },
-    post: {
-      ...TermdbIsoformAvailabilityPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return (req, res) => {
-    try {
-      const q = req.query;
-      const genome = genomes[q.genome];
-      if (!genome) throw "invalid genome";
-      const ds = genome.datasets?.[q.dslabel];
-      if (!ds) throw "invalid dslabel";
-      const isoQ = ds.queries?.isoformExpression;
-      if (!isoQ) throw "isoformExpression not configured for this dataset";
-      const itemSet = new Set(isoQ.availableItems || []);
-      const available = (q.isoforms || []).filter((id) => itemSet.has(id));
-      res.send({ available });
-    } catch (e) {
-      res.send({ error: e.message || e });
-    }
-  };
-}
-export {
-  api
-};

package/routes/termdb.numericcategories.js

@@ -1,46 +0,0 @@
-import { numericCategoriesPayload } from "#types/checkers";
-import * as termdbsql from "#src/termdb.sql.js";
-const api = {
-  endpoint: "termdb/numericcategories",
-  methods: {
-    get: {
-      ...numericCategoriesPayload,
-      init
-    },
-    post: {
-      ...numericCategoriesPayload,
-      init
-    }
-  }
-};
-function init({ genomes }) {
-  return async (req, res) => {
-    const q = req.query;
-    try {
-      const g = genomes[req.query.genome];
-      if (!g) throw "invalid genome name";
-      const ds = g.datasets[req.query.dslabel];
-      if (!ds) throw "invalid dataset name";
-      const tdb = ds.cohort.termdb;
-      if (!tdb) throw "invalid termdb object";
-      const result = await trigger_getnumericcategories(q, tdb, ds);
-      res.send(result);
-    } catch (e) {
-      res.send({ error: e instanceof Error ? e.message : e });
-      if (e instanceof Error && e.stack) console.log(e);
-    }
-  };
-}
-async function trigger_getnumericcategories(q, tdb, ds) {
-  if (!q.tid) throw ".tid missing";
-  const arg = {
-    ds,
-    term_id: q.tid,
-    filter: q.filter
-  };
-  const lst = await termdbsql.get_summary_numericcategories(arg);
-  return { lst };
-}
-export {
-  api
-};