@molgenis/vip-report-template 7.1.3 → 8.0.1

package/src/utils/config/configValidator.ts

@@ -1,374 +1,9 @@
-import Ajv, { JTDSchemaType } from "ajv/dist/jtd";
 import { Json } from "@molgenis/vip-report-api";
 import { ConfigValidationError } from "../error.ts";
-import {
-  ConfigJson,
-  ConfigJsonField,
-  ConfigJsonFilter,
-  ConfigJsonRecordsPerPageOption,
-  ConfigJsonSort,
-  ConfigJsonSortOrder,
-  ConfigJsonVariant,
-  ConfigJsonVariantConsequence,
-  ConfigJsonVariants,
-  ConfigJsonVip,
-  ConfigJsonVipParams,
-  ConfigJsonVipParamsCram,
-  ConfigJsonVipParamsVcf,
-} from "../../types/config";
+import { ConfigJson } from "../../types/config";
+import validate from "./configValidator.precompiled.ts";
 
-const ajv = new Ajv();
-
-// allow additional properties so we can extend config in vip without updating vip-report-template
-const schemaConfigJsonVipParamsVcf: JTDSchemaType<ConfigJsonVipParamsVcf> = {
-  properties: {
-    filter: {
-      properties: { classes: { type: "string" }, consequences: { type: "boolean" } },
-      additionalProperties: true,
-    },
-    filter_samples: {
-      properties: { classes: { type: "string" } },
-      additionalProperties: true,
-    },
-  },
-  additionalProperties: true,
-};
-
-// allow additional properties so we can extend config in vip without updating vip-report-template
-const schemaConfigJsonVipParamsCram: JTDSchemaType<ConfigJsonVipParamsCram> = {
-  properties: {
-    call_snv: { type: "boolean" },
-    call_str: { type: "boolean" },
-    call_sv: { type: "boolean" },
-    call_cnv: { type: "boolean" },
-  },
-  additionalProperties: true,
-};
-
-// allow additional properties so we can extend config in vip without updating vip-report-template
-const schemaConfigJsonVipParams: JTDSchemaType<ConfigJsonVipParams> = {
-  properties: {
-    vcf: schemaConfigJsonVipParamsVcf,
-  },
-  optionalProperties: {
-    cram: schemaConfigJsonVipParamsCram,
-  },
-  additionalProperties: true,
-};
-
-const schemaConfigJsonVip: JTDSchemaType<ConfigJsonVip> = {
-  properties: {
-    filter_field: {
-      properties: { type: { enum: ["genotype"] }, name: { type: "string" } },
-      optionalProperties: { label: { type: "string" }, description: { type: "string" } },
-    },
-    params: schemaConfigJsonVipParams,
-  },
-};
-
-const schemaConfigJsonField: JTDSchemaType<ConfigJsonField> = {
-  discriminator: "type",
-  mapping: {
-    fixed: {
-      properties: {
-        name: { enum: ["chrom", "pos", "id", "ref", "alt", "qual", "filter"] },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    info: {
-      properties: {
-        name: { type: "string" },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    format: {
-      properties: {
-        name: { type: "string" },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    genotype: {
-      properties: {
-        name: { type: "string" },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    composed: {
-      properties: {
-        name: {
-          enum: [
-            "clinVar",
-            "gene",
-            "genotype",
-            "genotype_maternal",
-            "genotype_paternal",
-            "gnomAdAf",
-            "hpo",
-            "inheritancePattern",
-            "locus",
-            "vipC",
-            "vipCS",
-            "vkgl",
-          ],
-        },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    group: {
-      // TODO deduplicate code, see mappings listed above
-      properties: {
-        fields: {
-          elements: {
-            discriminator: "type",
-            mapping: {
-              fixed: {
-                properties: {
-                  name: { enum: ["chrom", "pos", "id", "ref", "alt", "qual", "filter"] },
-                },
-                optionalProperties: {
-                  label: { type: "string" },
-                  description: { type: "string" },
-                },
-              },
-              info: {
-                properties: {
-                  name: { type: "string" },
-                },
-                optionalProperties: {
-                  label: { type: "string" },
-                  description: { type: "string" },
-                },
-              },
-              format: {
-                properties: {
-                  name: { type: "string" },
-                },
-                optionalProperties: {
-                  label: { type: "string" },
-                  description: { type: "string" },
-                },
-              },
-              genotype: {
-                properties: {
-                  name: { type: "string" },
-                },
-                optionalProperties: {
-                  label: { type: "string" },
-                  description: { type: "string" },
-                },
-              },
-              composed: {
-                properties: {
-                  name: {
-                    enum: [
-                      "clinVar",
-                      "gene",
-                      "genotype",
-                      "gnomAdAf",
-                      "hpo",
-                      "inheritancePattern",
-                      "locus",
-                      "ref",
-                      "vipC",
-                      "vipCS",
-                      "vkgl",
-                    ],
-                  },
-                },
-                optionalProperties: {
-                  label: { type: "string" },
-                  description: { type: "string" },
-                },
-              },
-            },
-          },
-        },
-      },
-    },
-  },
-};
-
-const schemaConfigJsonFilter: JTDSchemaType<ConfigJsonFilter> = {
-  discriminator: "type",
-  mapping: {
-    fixed: {
-      properties: {
-        name: { enum: ["chrom", "pos", "id", "ref", "alt", "qual", "filter"] },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    info: {
-      properties: {
-        name: { type: "string" },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    format: {
-      properties: {
-        name: { type: "string" },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    genotype: {
-      properties: {
-        name: { type: "string" },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-    composed: {
-      properties: {
-        name: {
-          enum: ["allelicImbalance", "deNovo", "hpo", "inheritanceMatch", "locus", "vipC", "vipCS"],
-        },
-      },
-      optionalProperties: {
-        label: { type: "string" },
-        description: { type: "string" },
-      },
-    },
-  },
-};
-
-const schemaConfigJsonSortOrder: JTDSchemaType<ConfigJsonSortOrder> = {
-  properties: {
-    direction: { enum: ["asc", "desc"] },
-    field: schemaConfigJsonField,
-  },
-};
-
-const schemaConfigJsonSort: JTDSchemaType<ConfigJsonSort> = {
-  properties: {
-    selected: { type: "boolean" },
-    orders: {
-      elements: schemaConfigJsonSortOrder,
-    },
-  },
-};
-
-const schemaConfigJsonRecordsPerPageOption: JTDSchemaType<ConfigJsonRecordsPerPageOption> = {
-  properties: {
-    number: { type: "uint16" },
-  },
-  optionalProperties: {
-    selected: { type: "boolean" },
-  },
-};
-
-const schemaConfigJsonVariants: JTDSchemaType<ConfigJsonVariants> = {
-  properties: {
-    cells: {
-      optionalProperties: {
-        all: { elements: schemaConfigJsonField },
-        snv: { elements: schemaConfigJsonField },
-        str: { elements: schemaConfigJsonField },
-        sv: { elements: schemaConfigJsonField },
-      },
-    },
-  },
-  optionalProperties: {
-    filters: {
-      optionalProperties: {
-        all: { elements: schemaConfigJsonFilter },
-        snv: { elements: schemaConfigJsonFilter },
-        str: { elements: schemaConfigJsonFilter },
-        sv: { elements: schemaConfigJsonFilter },
-      },
-    },
-    sorts: {
-      optionalProperties: {
-        all: { elements: schemaConfigJsonSort },
-        snv: { elements: schemaConfigJsonSort },
-        str: { elements: schemaConfigJsonSort },
-        sv: { elements: schemaConfigJsonSort },
-      },
-    },
-    recordsPerPage: {
-      optionalProperties: {
-        all: { elements: schemaConfigJsonRecordsPerPageOption },
-        snv: { elements: schemaConfigJsonRecordsPerPageOption },
-        str: { elements: schemaConfigJsonRecordsPerPageOption },
-        sv: { elements: schemaConfigJsonRecordsPerPageOption },
-      },
-    },
-  },
-};
-
-const schemaConfigJsonVariant: JTDSchemaType<ConfigJsonVariant> = {
-  properties: {
-    cells: {
-      optionalProperties: {
-        all: { elements: schemaConfigJsonField },
-        snv: { elements: schemaConfigJsonField },
-        str: { elements: schemaConfigJsonField },
-        sv: { elements: schemaConfigJsonField },
-      },
-    },
-  },
-  optionalProperties: {
-    sample_cells: {
-      optionalProperties: {
-        all: { elements: schemaConfigJsonField },
-        snv: { elements: schemaConfigJsonField },
-        str: { elements: schemaConfigJsonField },
-        sv: { elements: schemaConfigJsonField },
-      },
-    },
-  },
-};
-
-const schemaConfigJsonVariantConsequence: JTDSchemaType<ConfigJsonVariantConsequence> = {
-  optionalProperties: {
-    sample_cells: {
-      optionalProperties: {
-        all: { elements: schemaConfigJsonField },
-        snv: { elements: schemaConfigJsonField },
-        str: { elements: schemaConfigJsonField },
-        sv: { elements: schemaConfigJsonField },
-      },
-    },
-  },
-};
-
-const schema: JTDSchemaType<ConfigJson> = {
-  properties: {
-    vip: schemaConfigJsonVip,
-    sample_variants: schemaConfigJsonVariants,
-    variants: schemaConfigJsonVariants,
-    sample_variant: schemaConfigJsonVariant,
-    variant: schemaConfigJsonVariant,
-    sample_variant_consequence: schemaConfigJsonVariantConsequence,
-    variant_consequence: schemaConfigJsonVariantConsequence,
-  },
-};
-
-const validate = ajv.compile(schema);
+//se /scripts/validateConfig for instructions to update the schema
 
 export function validateConfig(json: Json): ConfigJson {
   const valid = validate(json);

package/src/utils/csq.ts

@@ -94,20 +94,15 @@ export function compareCsq(
   return compareCsqValue(aValue, bValue, direction);
 }
 
-export function compareCsqDefault(
-  aValue: Value[],
-  bValue: Value[],
-  pickIndex: number,
-  consequenceIndex: number,
-): number {
+export function compareCsqDefault(aValue: object, bValue: object, pickIndex: number, consequenceIndex: number): number {
   if (pickIndex !== -1) {
-    if (aValue[pickIndex] === "1") return bValue[pickIndex] === null ? -1 : 0;
-    if (bValue[pickIndex] === "1") return 1;
+    if (aValue["PICK"] === 1) return bValue["PICK"] === null ? -1 : 0;
+    if (bValue["PICK"] === 1) return 1;
   }
 
   if (consequenceIndex !== -1) {
-    const aIndex = getMostSevereConsequenceIndex(aValue[consequenceIndex] as string[]);
-    const bIndex = getMostSevereConsequenceIndex(bValue[consequenceIndex] as string[]);
+    const aIndex = getMostSevereConsequenceIndex(aValue["Consequence"] as string[]);
+    const bIndex = getMostSevereConsequenceIndex(bValue["Consequence"] as string[]);
     return aIndex - bIndex;
   } else {
     return 0;

package/src/utils/decisionTree.ts

@@ -29,17 +29,16 @@ export function getSampleTreePath(
   variant: Item<VcfRecord>,
   csqId: number,
 ): DecisionTreePath {
-  let decisionTreePath: DecisionTreePath;
   const fieldMetadata = getSampleField(metadata, "VIPP_S");
   if (fieldMetadata) {
     const value = getSampleValue(sample, variant, -1, fieldMetadata); // TODO replace with getSampleNestedValue once VIPP_S metadata is nested
-    if (value === undefined) throw new RuntimeError("required value must not be undefined");
-    if (!Array.isArray(value)) throw new RuntimeError();
-    const valueArray = value as string[];
-    if (valueArray.length <= csqId) throw new RuntimeError();
-    decisionTreePath = valueArray[csqId]!.split("&") as DecisionTreePath;
-  } else {
-    decisionTreePath = [];
+    if (value !== undefined) {
+      if (!Array.isArray(value)) throw new RuntimeError();
+      const valueArray = value as string[];
+      if (valueArray.length > csqId) {
+        return valueArray[csqId]!.split("&") as DecisionTreePath;
+      }
+    }
   }
-  return decisionTreePath;
+  return [];
 }

package/src/utils/query/query.ts

@@ -3,13 +3,14 @@ import { FilterValueMap } from "../../types/configFilter";
 import { VariantType } from "../variantType.ts";
 
 import { Config } from "../../types/config";
-import { SampleContainer } from "../api.ts";
+import { MetadataContainer, SampleContainer } from "../api.ts";
 import { createQueryFilters } from "./queryFilter.ts";
 import { createQueryVariantType } from "./queryVariantType.ts";
 import { createQuerySample } from "./querySample.ts";
 
 export function createQuery(
   config: Config,
+  meta: MetadataContainer,
   variantType: VariantType,
   sample: SampleContainer | null,
   filterValues: FilterValueMap,
@@ -22,7 +23,7 @@ export function createQuery(
   }
 
   if (sample !== null) {
-    const querySample = createQuerySample(config.vip, sample);
+    const querySample = createQuerySample(config.vip, sample, meta);
     if (querySample !== null) {
       queryParts.push(querySample);
     }

package/src/utils/query/queryFilter.ts

@@ -63,7 +63,6 @@ export function createQueryFilterString(
   selector: Selector,
   filterValue: FilterValueString,
   multiValue: boolean,
-  nestedValue: boolean,
 ): Query {
   // null values
   // multi=false --> value=null
@@ -74,7 +73,7 @@ export function createQueryFilterString(
   if (filterValues.length > 0) {
     queryParts.push({
       selector,
-      operator: nestedValue ? (multiValue ? "any_has_any" : "has_any") : multiValue ? "has_any" : "in",
+      operator: "in",
       args: filterValues,
     });
   }
@@ -82,7 +81,7 @@ export function createQueryFilterString(
   if (multiValue && filterValues.findIndex((value) => value === null) !== -1) {
     queryParts.push({
       selector,
-      operator: nestedValue ? (multiValue ? "any_has_any" : "has_any") : "==",
+      operator: "==",
       args: multiValue ? [] : null,
     });
   }

package/src/utils/query/queryFilterComposed.ts

@@ -68,7 +68,7 @@ function createQueryFilterHpo(filter: ConfigFilterHpo, filterValue: FilterValueH
 }
 
 function createQueryFilterLocus(filterValue: FilterValueLocus): Query {
-  const queryParts: Query[] = [createQueryFilterString(["c"], [filterValue.chromosome], false, false)];
+  const queryParts: Query[] = [createQueryFilterString(["c"], [filterValue.chromosome], false)];
 
   if (filterValue.start !== undefined || filterValue.end !== undefined) {
     const posQuery = createQueryFilterClosedInterval(["p"], { left: filterValue.start, right: filterValue.end });
@@ -83,8 +83,8 @@ function createQueryFilterAllelicImbalance(
   filterValue: FilterValueAllelicImbalance,
 ): Query {
   const viabSelector = createSelectorSample(filter.sample, filter.viabField);
-  const gtSelector = [...createSelectorSample(filter.sample, filter.genotypeField), "t"];
-
+  //GT_type is a technical field specific for the database, so no metadata present
+  const gtTypeSelector = ["s", filter.sample.item.id, "GT_type"];
   const queryParts: Query[] = [];
   if (filterValue.includes("true")) {
     const queryPartsTrue: Query[] = [];
@@ -93,8 +93,8 @@ function createQueryFilterAllelicImbalance(
         [
           {
             operator: "in",
-            selector: gtSelector,
-            args: ["hom_a", "hom_r"],
+            selector: gtTypeSelector,
+            args: ["HOM_ALT", "HOM_REF"],
           },
           createQueryFilterClosedInterval(viabSelector, { left: 0.02, right: 0.98 }),
         ],
@@ -106,8 +106,8 @@ function createQueryFilterAllelicImbalance(
         [
           {
             operator: "==",
-            selector: gtSelector,
-            args: "het",
+            selector: gtTypeSelector,
+            args: "HET",
           },
           createQueryFilterClosedIntervalOutside(viabSelector, { left: 0.2, right: 0.8 }),
         ],
@@ -123,8 +123,8 @@ function createQueryFilterAllelicImbalance(
         [
           {
             operator: "in",
-            selector: gtSelector,
-            args: ["hom_a", "hom_r"],
+            selector: gtTypeSelector,
+            args: ["HOM_ALT", "HOM_REF"],
           },
           createQueryFilterClosedIntervalOutside(viabSelector, { left: 0.02, right: 0.98 }),
         ],
@@ -136,8 +136,8 @@ function createQueryFilterAllelicImbalance(
         [
           {
             operator: "==",
-            selector: gtSelector,
-            args: "het",
+            selector: gtTypeSelector,
+            args: "HET",
           },
           createQueryFilterClosedInterval(viabSelector, { left: 0.2, right: 0.8 }),
         ],
@@ -231,7 +231,7 @@ function createQueryFilterDeNovo(filter: ConfigFilterDeNovo, filterValue: Filter
     });
     queryParts.push(createQueryComposed(queryPartsUndefined, "or"));
   }
-  return createQueryComposed(queryParts, "and");
+  return createQueryComposed(queryParts, "or");
 }
 
 function createQueryFilterVipC(filter: ConfigFilterVipC, filterValue: FilterValueVipC): Query {

package/src/utils/query/queryFilterField.ts

@@ -5,6 +5,7 @@ import {
   ConfigFilterFormat,
   FilterValue,
   FilterValueCategorical,
+  FilterValueFlag,
   FilterValueInterval,
   FilterValueString,
 } from "../../types/configFilter";
@@ -30,7 +31,7 @@ export function createQueryFilterField(filter: ConfigFilterField, filterValue: F
       query = createQueryFilterClosedInterval(selector, filterValue as FilterValueInterval);
       break;
     case "FLAG":
-      query = createQueryFilterFlag();
+      query = createQueryFilterFlag(selector, field, filterValue as FilterValueCategorical);
       break;
     default:
       throw new UnexpectedEnumValueException(field.type);
@@ -60,16 +61,22 @@ export function createQueryFilterFieldCategorical(
   filterValue: FilterValueCategorical,
 ): Query {
   const multiValue = field.number.count !== 1;
-  const nestedValue = field.parent !== undefined;
-  return createQueryFilterString(selector, filterValue, multiValue, nestedValue);
+  return createQueryFilterString(selector, filterValue, multiValue);
 }
 
-function createQueryFilterFlag(): Query {
-  throw new Error("not implemented"); // FIXME support flag filter queries
+function createQueryFilterFlag(selector: Selector, field: FieldMetadata, filterValue: FilterValueFlag): Query {
+  const values: string[] = [];
+  for (const value of filterValue) {
+    if (value === "true") {
+      values.push("1");
+    } else if (value === "false") {
+      values.push("__null");
+    }
+  }
+  return createQueryFilterFieldCategorical(selector, field, values);
 }
 
 function createQueryFilterFieldString(selector: Selector, field: FieldMetadata, filterValue: FilterValueString): Query {
   const multiValue = field.number.count !== 1;
-  const nestedValue = field.parent !== undefined;
-  return createQueryFilterString(selector, filterValue, multiValue, nestedValue);
+  return createQueryFilterString(selector, filterValue, multiValue);
 }

package/src/utils/query/queryFilterFixed.ts

@@ -17,25 +17,25 @@ export function createQueryFilterFixed(filter: ConfigFilterFixed, filterValue: F
   let query: Query;
   switch (filter.id) {
     case "fixed/chrom":
-      query = createQueryFilterString(["c"], filterValue as FilterValueChrom, false, false);
+      query = createQueryFilterString(["c"], filterValue as FilterValueChrom, false);
       break;
     case "fixed/pos":
       query = createQueryFilterClosedInterval(["p"], filterValue as FilterValuePos);
       break;
     case "fixed/id":
-      query = createQueryFilterString(["i"], filterValue as FilterValueId, true, false);
+      query = createQueryFilterString(["i"], filterValue as FilterValueId, true);
       break;
     case "fixed/ref":
-      query = createQueryFilterString(["r"], filterValue as FilterValueRef, false, false);
+      query = createQueryFilterString(["r"], filterValue as FilterValueRef, false);
       break;
     case "fixed/alt":
-      query = createQueryFilterString(["a"], filterValue as FilterValueAlt, true, false);
+      query = createQueryFilterString(["a"], filterValue as FilterValueAlt, true);
       break;
     case "fixed/qual":
       query = createQueryFilterClosedInterval(["q"], filterValue as FilterValueQual);
       break;
     case "fixed/filter":
-      query = createQueryFilterString(["f"], filterValue as FilterValueFilter, true, false);
+      query = createQueryFilterString(["f"], filterValue as FilterValueFilter, true);
       break;
     default:
       throw new UnexpectedEnumValueException(filter.id);

package/src/utils/query/querySample.ts

@@ -1,17 +1,28 @@
 import { Query } from "@molgenis/vip-report-api";
-import { SampleContainer } from "../api.ts";
+import { MetadataContainer, SampleContainer } from "../api.ts";
 import { createSelectorSample } from "./selector.ts";
 import { ConfigVip } from "../../types/config";
 import { FilterValueCategorical } from "../../types/configFilter";
 import { createQueryFilterFieldCategorical } from "./queryFilterField.ts";
+import { createQueryComposed } from "./query.ts";
 
-export function createQuerySample(config: ConfigVip, sample: SampleContainer): Query | null {
+export function createQuerySample(config: ConfigVip, sample: SampleContainer, meta: MetadataContainer): Query | null {
   const filterField = config.filter_field;
   if (filterField === null) return null;
 
   const filterValues = getFilterValues(config);
-  const selector = createSelectorSample(sample, filterField);
-  return createQueryFilterFieldCategorical(selector, filterField, filterValues);
+  const filterSelector = createSelectorSample(sample, filterField);
+  const classFilter = createQueryFilterFieldCategorical(filterSelector, filterField, filterValues);
+  const filters = [classFilter];
+  if (meta.records.format.GT !== undefined) {
+    const gtFilter = {
+      selector: ["s", sample.item.id, "GT_type"],
+      operator: "!in",
+      args: ["HOM_REF", "NO_CALL", "UNAVAILABLE"],
+    } as Query;
+    filters.push(gtFilter);
+  }
+  return createQueryComposed(filters, "and");
 }
 
 function getFilterValues(config: ConfigVip): FilterValueCategorical {