@sjcrh/proteinpaint-server 2.173.0 → 2.174.1

package/routes/termdb.chat.js

@@ -1,10 +1,12 @@
 import fs from "fs";
 import { ezFetch } from "#shared";
+import { get_samples } from "#src/termdb.sql.js";
 import { ChatPayload } from "#types/checkers";
 import serverconfig from "../src/serverconfig.js";
 import { mayLog } from "#src/helpers.ts";
 import Database from "better-sqlite3";
 import { formatElapsedTime } from "#shared";
+const num_filter_cutoff = 3;
 const api = {
   endpoint: "termdb/chat",
   methods: {
@@ -74,7 +76,19 @@ function init({ genomes }) {
           );
           mayLog("Time taken for summary agent:", formatElapsedTime(Date.now() - time12));
         } else if (classResult == "dge") {
-          ai_output_json = { type: "html", html: "DE agent not implemented yet" };
+          const time12 = (/* @__PURE__ */ new Date()).valueOf();
+          ai_output_json = await extract_DE_search_terms_from_query(
+            q.prompt,
+            serverconfig.llm_backend,
+            comp_model_name,
+            apilink,
+            dataset_db,
+            dataset_json,
+            ds
+          );
+          mayLog("Time taken for DE agent:", formatElapsedTime(Date.now() - time12));
+        } else if (classResult == "survival") {
+          ai_output_json = { type: "html", html: "survival agent has not been implemented yet" };
         } else {
           ai_output_json = { type: "html", html: "Unknown classification value" };
         }
@@ -163,6 +177,10 @@ async function call_sj_llm(prompt, model_name, apilink) {
     throw "SJ API request failed:" + error;
   }
 }
+function checkField(sentence) {
+  if (!sentence) return "";
+  else return sentence;
+}
 async function readJSONFile(file) {
   const json_file = await fs.promises.readFile(file);
   return JSON.parse(json_file.toString());
@@ -176,10 +194,12 @@ async function classify_query_by_dataset_type(user_prompt, comp_model_name, llm_
     }
   }
   const classification_ds = dataset_json.charts.filter((chart) => chart.type == "Classification");
+  if (classification_ds.length == 0) throw "Classification information is not present in the dataset file.";
+  if (classification_ds[0].TrainingData.length == 0) throw "No training data is provided for the classification agent.";
   let train_iter = 0;
   let training_data = "";
   if (classification_ds.length > 0 && classification_ds[0].TrainingData.length > 0) {
-    contents += classification_ds.SystemPrompt;
+    contents += checkField(dataset_json.DatasetPrompt) + checkField(classification_ds[0].SystemPrompt);
     for (const train_data of classification_ds[0].TrainingData) {
       train_iter += 1;
       training_data += "Example question" + train_iter.toString() + ": " + train_data.question + " Example answer" + train_iter.toString() + ":" + JSON.stringify(train_data.answer) + " ";
@@ -194,25 +214,307 @@ async function classify_query_by_dataset_type(user_prompt, comp_model_name, llm_
   } else {
     throw "Unknown LLM backend";
   }
-  mayLog("response:", response);
   return JSON.parse(response);
 }
+async function extract_DE_search_terms_from_query(prompt, llm_backend_type, comp_model_name, apilink, dataset_db, dataset_json, ds) {
+  if (dataset_json.hasDE) {
+    const dataset_db_output = await parse_dataset_db(dataset_db);
+    const Schema = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $ref: "#/definitions/DEType",
+      definitions: {
+        DEType: {
+          type: "object",
+          properties: {
+            group1: {
+              type: "array",
+              items: { $ref: "#/definitions/FilterTerm" },
+              description: "Name of group1 which is an array of filter terms"
+            },
+            group2: {
+              type: "array",
+              items: { $ref: "#/definitions/FilterTerm" },
+              description: "Name of group2 which is an array of filter terms"
+            },
+            method: {
+              type: "string",
+              enum: ["edgeR", "limma", "wilcoxon"],
+              description: "Method used for carrying out differential gene expression analysis"
+            }
+          },
+          required: ["group1", "group2"],
+          additionalProperties: false
+        },
+        FilterTerm: {
+          anyOf: [{ $ref: "#/definitions/CategoricalFilterTerm" }, { $ref: "#/definitions/NumericFilterTerm" }]
+        },
+        CategoricalFilterTerm: {
+          type: "object",
+          properties: {
+            term: { type: "string", description: "Name of categorical term" },
+            category: { type: "string", description: "The category of the term" },
+            join: {
+              type: "string",
+              enum: ["and", "or"],
+              description: "join term to be used only when there is more than one filter term and should be placed from the 2nd filter term onwards describing how it connects to the previous term"
+            }
+          },
+          required: ["term", "category"],
+          additionalProperties: false
+        },
+        NumericFilterTerm: {
+          type: "object",
+          properties: {
+            term: { type: "string", description: "Name of numeric term" },
+            start: { type: "number", description: "start position (or lower limit) of numeric term" },
+            stop: { type: "number", description: "stop position (or upper limit) of numeric term" },
+            join: {
+              type: "string",
+              enum: ["and", "or"],
+              description: "join term to be used only when there is more than one filter term and should be placed from the 2nd filter term onwards describing how it connects to the previous term"
+            }
+          },
+          required: ["term"],
+          additionalProperties: false
+        }
+      }
+    };
+    const DE_ds = dataset_json.charts.filter((chart) => chart.type == "DE");
+    if (DE_ds.length == 0) throw "DE information is not present in the dataset file.";
+    if (DE_ds[0].TrainingData.length == 0) throw "No training data is provided for the DE agent.";
+    let train_iter = 0;
+    let training_data = "";
+    for (const train_data of DE_ds[0].TrainingData) {
+      train_iter += 1;
+      training_data += "Example question" + train_iter.toString() + ": " + train_data.question + " Example answer" + train_iter.toString() + ":" + JSON.stringify(train_data.answer) + " ";
+    }
+    const system_prompt = "I am an assistant that extracts the groups from the user prompt to carry out differential gene expression. The final output must be in the following JSON with NO extra comments. The schema is as follows: " + JSON.stringify(Schema) + ' . "group1" and "group2" fields are compulsory. Both "group1" and "group2" consist of an array of filter variables. There are two kinds of filter variables: "Categorical" and "Numeric". "Categorical" variables are those variables which can have a fixed set of values e.g. gender, race. They are defined by the "CategoricalFilterTerm" which consists of "term" (a field from the sqlite3 db)  and "category" (a value of the field from the sqlite db).  "Numeric" variables are those which can have any numeric value. They are defined by "NumericFilterTerm" and contain  the subfields "term" (a field from the sqlite3 db), "start" an optional filter which is defined when a lower cutoff is defined in the user input for the numeric variable and "stop" an optional filter which is defined when a higher cutoff is defined in the user input for the numeric variable. ' + // May consider deprecating this natural language description after units tests are implemented
+    checkField(dataset_json.DatasetPrompt) + checkField(DE_ds[0].SystemPrompt) + "The sqlite db in plain language is as follows:\n" + dataset_db_output.rag_docs.join(",") + " training data is as follows:" + training_data + " Question: {" + prompt + "} answer:";
+    let response;
+    if (llm_backend_type == "SJ") {
+      response = await call_sj_llm(system_prompt, comp_model_name, apilink);
+    } else if (llm_backend_type == "ollama") {
+      response = await call_ollama(system_prompt, comp_model_name, apilink);
+    } else {
+      throw "Unknown LLM backend";
+    }
+    return await validate_DE_response(response, ds, dataset_db_output.db_rows);
+  } else {
+    return { type: "html", html: "Differential gene expression not supported for this dataset" };
+  }
+}
+async function validate_DE_response(response, ds, db_rows) {
+  const response_type = JSON.parse(response);
+  let html = "";
+  let group1;
+  let samples1lst;
+  const name1 = generate_group_name(response_type.group1, db_rows);
+  if (!response_type.group1) {
+    html += "group1 not present in DE output";
+  } else {
+    const validated_filters = validate_filter(response_type.group1, ds, name1);
+    if (validated_filters.html.length > 0) {
+      html += validated_filters.html;
+    } else {
+      const samples1 = await get_samples({ filter: validated_filters.simplefilter }, ds, true);
+      samples1lst = samples1.map((item) => ({
+        sampleId: item.id,
+        sample: item.name
+      }));
+      group1 = {
+        name: name1,
+        in: true,
+        values: samples1lst
+      };
+    }
+  }
+  let group2;
+  let samples2lst;
+  const name2 = generate_group_name(response_type.group2, db_rows);
+  if (!response_type.group2) {
+    html += "group2 not present in DE output";
+  } else {
+    const validated_filters = validate_filter(response_type.group2, ds, name2);
+    if (validated_filters.html.length > 0) {
+      html += validated_filters.html;
+    } else {
+      const samples2 = await get_samples({ filter: validated_filters.simplefilter }, ds, true);
+      samples2lst = samples2.map((item) => ({
+        sampleId: item.id,
+        sample: item.name
+      }));
+      group2 = {
+        name: name2,
+        in: true,
+        values: samples2lst
+      };
+    }
+  }
+  let settings;
+  if (response_type.method) {
+    if (response_type.method == "edgeR" || response_type.method == "limma" || response_type.method == "wilcoxon") {
+      settings = { volcano: { method: response_type.method } };
+    } else {
+      html += "Unknown DE method: " + response_type.method;
+    }
+  }
+  if (html.length > 0) {
+    html = removeLastOccurrence(
+      html,
+      "For now, the maximum number of filter terms supported through the chatbot is " + num_filter_cutoff
+      // Remove duplicated statements in error message
+    );
+    return { type: "html", html };
+  } else {
+    const pp_plot_json = { childType: "volcano", termType: "geneExpression", chartType: "differentialAnalysis" };
+    const groups = [group1, group2];
+    const tw = {
+      q: {
+        groups
+      },
+      term: {
+        name: name1 + " vs " + name2,
+        type: "samplelst",
+        values: {
+          [name1]: {
+            color: "purple",
+            key: name1,
+            label: name1,
+            list: samples1lst
+          },
+          [name2]: {
+            color: "blue",
+            key: name2,
+            label: name2,
+            list: samples2lst
+          }
+        }
+      }
+    };
+    pp_plot_json.state = {
+      customTerms: [
+        {
+          name: name1 + " vs " + name2,
+          tw
+        }
+      ],
+      groups
+    };
+    pp_plot_json.samplelst = { groups };
+    pp_plot_json.tw = tw;
+    pp_plot_json.settings = settings;
+    return { type: "plot", plot: pp_plot_json };
+  }
+}
+function generate_group_name(filters, db_rows) {
+  let name = "";
+  let iter = 0;
+  for (const filter of filters) {
+    if (iter > 0 && !filter.join) {
+      name += "&";
+    }
+    if (filter.join && filter.join == "and") {
+      name += "&";
+    }
+    if (filter.join && filter.join == "or") {
+      name += "|";
+    }
+    if (filter.category) {
+      name += find_label(filter, db_rows);
+    }
+    if (filter.start) {
+      name += filter.term + ">=" + filter.start.toString();
+    }
+    if (filter.stop) {
+      name += filter.term + "<=" + filter.stop.toString();
+    }
+    iter += 1;
+  }
+  return name;
+}
+function find_label(filter, db_rows) {
+  let label = "";
+  for (const row of db_rows) {
+    if (row.name == filter.term) {
+      for (const value of row.values) {
+        if (value.value && value.value.label && filter.category == value.key) {
+          label = value.value.label;
+          break;
+        }
+      }
+      break;
+    }
+  }
+  return label;
+}
 async function extract_summary_terms(prompt, llm_backend_type, comp_model_name, apilink, dataset_db, dataset_json, genedb, ds) {
-  const rag_docs = await parse_dataset_db(dataset_db);
+  const dataset_db_output = await parse_dataset_db(dataset_db);
   const genes_list = await parse_geneset_db(genedb);
-  const StringifiedSchema = '{"$schema":"http://json-schema.org/draft-07/schema#","$ref":"#/definitions/SummaryType","definitions":{"SummaryType":{"type":"object","properties":{"term":{"type":"string"},"term2":{"type":"string"},"simpleFilter":{"type":"array","items":{"$ref":"#/definitions/FilterTerm"}}},"required":["term","simpleFilter"],"additionalProperties":false},"FilterTerm":{"anyOf":[{"$ref":"#/definitions/CategoricalFilterTerm"},{"$ref":"#/definitions/NumericFilterTerm"}]},"CategoricalFilterTerm":{"type":"object","properties":{"term":{"type":"string"},"category":{"type":"string"}},"required":["term","category"],"additionalProperties":false},"NumericFilterTerm":{"type":"object","properties":{"term":{"type":"string"},"start":{"type":"number"},"stop":{"type":"number"}},"required":["term"],"additionalProperties":false}}}';
+  const Schema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    $ref: "#/definitions/SummaryType",
+    definitions: {
+      SummaryType: {
+        type: "object",
+        properties: {
+          term: { type: "string", description: "Name of 1st term" },
+          term2: { type: "string", description: "Name of 2nd term" },
+          simpleFilter: {
+            type: "array",
+            items: { $ref: "#/definitions/FilterTerm" },
+            description: "Optional simple filter terms"
+          }
+        },
+        required: ["term", "simpleFilter"],
+        additionalProperties: false
+      },
+      FilterTerm: {
+        anyOf: [{ $ref: "#/definitions/CategoricalFilterTerm" }, { $ref: "#/definitions/NumericFilterTerm" }]
+      },
+      CategoricalFilterTerm: {
+        type: "object",
+        properties: {
+          term: { type: "string", description: "Name of categorical term" },
+          category: { type: "string", description: "The category of the term" },
+          join: {
+            type: "string",
+            enum: ["and", "or"],
+            description: "join term to be used only when there there is more than one filter term and should be placed in the 2nd filter term describing how it connects to the 1st term"
+          }
+        },
+        required: ["term", "category"],
+        additionalProperties: false
+      },
+      NumericFilterTerm: {
+        type: "object",
+        properties: {
+          term: { type: "string", description: "Name of numeric term" },
+          start: { type: "number", description: "start position (or lower limit) of numeric term" },
+          stop: { type: "number", description: "stop position (or upper limit) of numeric term" },
+          join: {
+            type: "string",
+            enum: ["and", "or"],
+            description: "join term to be used only when there there is more than one filter term and should be placed in the 2nd filter term describing how it connects to the 1st term"
+          }
+        },
+        required: ["term"],
+        additionalProperties: false
+      }
+    }
+  };
   const words = prompt.replace(/[^a-zA-Z0-9\s]/g, "").split(/\s+/).map((str) => str.toLowerCase());
   const common_genes = words.filter((item) => genes_list.includes(item));
   const summary_ds = dataset_json.charts.filter((chart) => chart.type == "Summary");
-  if (summary_ds.length == 0) throw "summary information not present in dataset file";
-  if (summary_ds[0].TrainingData.length == 0) throw "no training data provided for summary agent";
+  if (summary_ds.length == 0) throw "Summary information is not present in the dataset file.";
+  if (summary_ds[0].TrainingData.length == 0) throw "No training data is provided for the summary agent.";
   let train_iter = 0;
   let training_data = "";
   for (const train_data of summary_ds[0].TrainingData) {
     train_iter += 1;
     training_data += "Example question" + train_iter.toString() + ": " + train_data.question + " Example answer" + train_iter.toString() + ":" + JSON.stringify(train_data.answer) + " ";
   }
-  let system_prompt = "I am an assistant that extracts the summary terms from user query. The final output must be in the following JSON format with NO extra comments. The JSON schema is as follows: " + StringifiedSchema + ' term and term2 (if present) should ONLY contain names of the fields from the sqlite db. The "simpleFilter" field is optional and should contain an array of JSON terms with which the dataset will be filtered. A variable simultaneously CANNOT be part of both "term"/"term2" and "simpleFilter". There are two kinds of filter variables: "Categorical" and "Numeric". "Categorical" variables are those variables which can have a fixed set of values e.g. gender, race. They are defined by the "CategoricalFilterTerm" which consists of "term" (a field from the sqlite3 db)  and "category" (a value of the field from the sqlite db).  "Numeric" variables are those which can have any numeric value. They are defined by "NumericFilterTerm" and contain  the subfields "term" (a field from the sqlite3 db), "start" an optional filter which is defined when a lower cutoff is defined in the user input for the numeric variable and "stop" an optional filter which is defined when a higher cutoff is defined in the user input for the numeric variable. ' + summary_ds.SystemPrompt + rag_docs.join(",") + " training data is as follows:" + training_data;
+  let system_prompt = "I am an assistant that extracts the summary terms from user query. The final output must be in the following JSON format with NO extra comments. The JSON schema is as follows: " + JSON.stringify(Schema) + ' term and term2 (if present) should ONLY contain names of the fields from the sqlite db. The "simpleFilter" field is optional and should contain an array of JSON terms with which the dataset will be filtered. A variable simultaneously CANNOT be part of both "term"/"term2" and "simpleFilter". There are two kinds of filter variables: "Categorical" and "Numeric". "Categorical" variables are those variables which can have a fixed set of values e.g. gender, race. They are defined by the "CategoricalFilterTerm" which consists of "term" (a field from the sqlite3 db)  and "category" (a value of the field from the sqlite db).  "Numeric" variables are those which can have any numeric value. They are defined by "NumericFilterTerm" and contain  the subfields "term" (a field from the sqlite3 db), "start" an optional filter which is defined when a lower cutoff is defined in the user input for the numeric variable and "stop" an optional filter which is defined when a higher cutoff is defined in the user input for the numeric variable. ' + // May consider deprecating this natural language description after unit tests are implemented
+  checkField(dataset_json.DatasetPrompt) + checkField(summary_ds[0].SystemPrompt) + "\n The DB content is as follows: " + dataset_db_output.rag_docs.join(",") + " training data is as follows:" + training_data;
   if (dataset_json.hasGeneExpression) {
     if (common_genes.length > 0) {
       system_prompt += "\n List of relevant genes are as follows (separated by comma(,)):" + common_genes.join(",");
@@ -250,7 +552,7 @@ function validate_summary_response(response, common_genes, dataset_json, ds) {
     }
   }
   if (response_type.simpleFilter && response_type.simpleFilter.length > 0) {
-    const validated_filters = validate_filter(response_type.simpleFilter, ds);
+    const validated_filters = validate_filter(response_type.simpleFilter, ds, "");
     if (validated_filters.html.length > 0) {
       html += validated_filters.html;
     } else {
@@ -283,56 +585,112 @@ function validate_term(response_term, common_genes, dataset_json, ds) {
   }
   return { term_type, html };
 }
-function validate_filter(filters, ds) {
+function countOccurrences(str, word) {
+  if (word === "") return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = str.indexOf(word, pos)) !== -1) {
+    count++;
+    pos += word.length;
+  }
+  return count;
+}
+function removeLastOccurrence(str, word) {
+  const index = str.lastIndexOf(word);
+  if (index === -1) return str;
+  const occurrences = countOccurrences(str, word);
+  if (occurrences === 1) {
+    return str;
+  } else {
+    return str.slice(0, index) + str.slice(index + word.length);
+  }
+}
+function validate_filter(filters, ds, group_name) {
   if (!Array.isArray(filters)) throw "filter is not array";
+  let filter_result = { html: "" };
+  if (filters.length <= 2) {
+    filter_result = generate_filter_term(filters, ds);
+  } else {
+    if (filters.length > num_filter_cutoff) {
+      filter_result.html = "For now, the maximum number of filter terms supported through the chatbot is " + num_filter_cutoff;
+      if (group_name.length > 0) {
+        filter_result.html += " . The number of filter terms for group " + group_name + " is " + filters.length + "\n";
+      } else {
+        filter_result.html += "The number of filter terms for this query is " + filters.length;
+      }
+    } else {
+      for (let i = 0; i < filters.length - 1; i++) {
+        const filter_lst = [];
+        if (i == 0) {
+          filter_lst.push(filters[i]);
+        } else {
+          filter_lst.push(filter_result.simplefilter);
+        }
+        filter_lst.push(filters[i + 1]);
+        filter_result = generate_filter_term(filter_lst, ds);
+      }
+    }
+  }
+  return { simplefilter: filter_result.simplefilter, html: filter_result.html };
+}
+function generate_filter_term(filters, ds) {
   let invalid_html = "";
-  const localfilter = { type: "tvslst", in: true, join: "", lst: [] };
-  if (filters.length > 1) localfilter.join = "and";
+  const localfilter = { type: "tvslst", in: true, lst: [] };
   for (const f of filters) {
-    const term = ds.cohort.termdb.q.termjsonByOneid(f.term);
-    if (!term) {
-      invalid_html += "invalid filter id:" + f.term;
+    if (f.type == "tvslst") {
+      localfilter.lst.push(f);
     } else {
-      if (term.type == "categorical") {
-        let cat;
-        for (const ck in term.values) {
-          if (ck == f.category) cat = ck;
-          else if (term.values[ck].label == f.category) cat = ck;
+      const term = ds.cohort.termdb.q.termjsonByOneid(f.term);
+      if (!term) {
+        invalid_html += "invalid filter id:" + f.term;
+      } else {
+        if (f.join) {
+          localfilter.join = f.join;
         }
-        if (!cat) invalid_html += "invalid category from " + JSON.stringify(f);
-        localfilter.lst.push({
-          type: "tvs",
-          tvs: {
-            term,
-            values: [{ key: cat }]
+        if (term.type == "categorical") {
+          let cat;
+          for (const ck in term.values) {
+            if (ck == f.category) cat = ck;
+            else if (term.values[ck].label == f.category) cat = ck;
           }
-        });
-      } else if (term.type == "float" || term.type == "integer") {
-        const numeric = {
-          type: "tvs",
-          tvs: {
-            term,
-            ranges: []
+          if (!cat) invalid_html += "invalid category from " + JSON.stringify(f);
+          localfilter.lst.push({
+            type: "tvs",
+            tvs: {
+              term,
+              values: [{ key: cat }]
+            }
+          });
+        } else if (term.type == "float" || term.type == "integer") {
+          const numeric = {
+            type: "tvs",
+            tvs: {
+              term,
+              ranges: []
+            }
+          };
+          const range = {};
+          if (f.start && !f.stop) {
+            range.start = Number(f.start);
+            range.stopunbounded = true;
+          } else if (f.stop && !f.start) {
+            range.stop = Number(f.stop);
+            range.startunbounded = true;
+          } else if (f.start && f.stop) {
+            range.start = Number(f.start);
+            range.stop = Number(f.stop);
+          } else {
+            invalid_html += "Neither greater or lesser defined";
           }
-        };
-        const range = {};
-        if (f.start && !f.stop) {
-          range.start = Number(f.start);
-          range.stopunbounded = true;
-        } else if (f.stop && !f.start) {
-          range.stop = Number(f.stop);
-          range.startunbounded = true;
-        } else if (f.start && f.stop) {
-          range.start = Number(f.start);
-          range.stop = Number(f.stop);
-        } else {
-          invalid_html += "Neither greater or lesser defined";
+          numeric.tvs.ranges.push(range);
+          localfilter.lst.push(numeric);
         }
-        numeric.tvs.ranges.push(range);
-        localfilter.lst.push(numeric);
       }
     }
   }
+  if (filters.length > 1 && !localfilter.join) {
+    localfilter.join = "and";
+  }
   return { simplefilter: localfilter, html: invalid_html };
 }
 async function parse_geneset_db(genedb) {
@@ -354,6 +712,7 @@ async function parse_geneset_db(genedb) {
 async function parse_dataset_db(dataset_db) {
   const db = new Database(dataset_db);
   const rag_docs = [];
+  const db_rows = [];
   try {
     const desc_rows = db.prepare("SELECT * from termhtmldef").all();
     const description_map = [];
@@ -364,7 +723,6 @@ async function parse_dataset_db(dataset_db) {
       description_map.push({ name, description });
     });
     const term_db_rows = db.prepare("SELECT * from terms").all();
-    const db_rows = [];
     term_db_rows.forEach((row) => {
       const found = description_map.find((item) => item.name === row.id);
       if (found) {
@@ -395,15 +753,15 @@ async function parse_dataset_db(dataset_db) {
   } finally {
     db.close();
   }
-  return rag_docs;
+  return { db_rows, rag_docs };
 }
 function parse_db_rows(db_row) {
-  let output_string = "Name of the field is:" + db_row.name + ". This field is of the type:" + db_row.term_type + ". Description: " + db_row.description;
+  let output_string = 'Name of the field is:"' + db_row.name + '". This field is of the type:' + db_row.term_type + ". Description: " + db_row.description;
   if (db_row.values.length > 0) {
     output_string += "This field contains the following possible values.";
     for (const value of db_row.values) {
       if (value.value && value.value.label) {
-        output_string += "The key is " + value.key + " and the label is " + value.value.label + ".";
+        output_string += 'The key is "' + value.key + '" and the label is "' + value.value.label + '".';
       }
     }
   }

package/routes/termdb.cluster.js

@@ -69,7 +69,7 @@ async function getResult(q, ds) {
     ({ term2sample2value, byTermId, bySampleId } = await getNumericDictTermAnnotation(q, ds));
   } else {
     ;
-    ({ term2sample2value, byTermId, bySampleId, skippedSexChrGenes } = await ds.queries[q.dataType].get(_q));
+    ({ term2sample2value, byTermId, bySampleId, skippedSexChrGenes } = await ds.queries[q.dataType].get(_q, ds));
   }
   const noValueTerms = [];
   for (const [term, obj] of term2sample2value) {
@@ -206,6 +206,7 @@ async function validate_query_geneExpression(ds, genome) {
   const q = ds.queries.geneExpression;
   if (!q) return;
   q.geneExpression2bins = {};
+  if (typeof q.get == "function") return;
   if (q.src == "gdcapi") {
     gdc_validate_query_geneExpression(ds, genome);
     return;

package/routes/termdb.config.js

@@ -78,6 +78,7 @@ function make(q, req, res, ds, genome) {
   if (ds.assayAvailability) c.assayAvailability = ds.assayAvailability;
   if (ds.cohort.correlationVolcano) c.correlationVolcano = ds.cohort.correlationVolcano;
   if (ds.cohort.boxplots) c.boxplots = ds.cohort.boxplots;
+  if (tdb.maxGeneVariantGeneSetSize) c.maxGeneVariantGeneSetSize = tdb.maxGeneVariantGeneSetSize;
   addRestrictAncestries(c, tdb);
   addScatterplots(c, ds);
   addMatrixplots(c, ds);