@molgenis/vip-report-template 7.1.3 → 8.0.0

package/tests/utils/query/queryFilterField.test.ts

@@ -23,7 +23,7 @@ describe("query filter fixed", () => {
       const value = ["x"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterField(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "f"], value, false, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "f"], value, false);
     });
 
     test("CHARACTER count=1 info", () => {
@@ -32,7 +32,7 @@ describe("query filter fixed", () => {
       const value = ["x"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterField(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "f"], value, false, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "f"], value, false);
     });
 
     test("STRING count=* info nested", () => {
@@ -41,17 +41,17 @@ describe("query filter fixed", () => {
       const value = ["x"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterField(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "p", "c"], value, true, true);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "p", "c"], value, true);
     });
 
     test("STRING count=* genotype", () => {
       const field = { id: "f", type: "STRING", number: { type: "OTHER" } } as FieldMetadata;
-      const sample = { item: { data: { index: 1 } } } as SampleContainer;
+      const sample = { item: { id: 1, data: { index: 1 } } } as SampleContainer;
       const config = { type: "genotype", id: "filter", field, sample } as ConfigFilterFormat;
       const value = ["x"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterField(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["s", 1, "f"], value, true, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["s", 1, "f"], value, true);
     });
 
     test("FLOAT count=1 info", () => {

package/tests/utils/query/queryFilterFixed.test.ts

@@ -27,7 +27,7 @@ describe("query filter fixed", () => {
       const value = ["chr1"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["c"], value, false, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["c"], value, false);
     });
 
     test("pos", () => {
@@ -43,7 +43,7 @@ describe("query filter fixed", () => {
       const value = ["id0"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["i"], value, true, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["i"], value, true);
     });
 
     test("ref", () => {
@@ -51,7 +51,7 @@ describe("query filter fixed", () => {
       const value = ["C"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["r"], value, false, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["r"], value, false);
     });
 
     test("alt", () => {
@@ -59,7 +59,7 @@ describe("query filter fixed", () => {
       const value = ["C"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["a"], value, true, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["a"], value, true);
     });
 
     test("qual", () => {
@@ -75,7 +75,7 @@ describe("query filter fixed", () => {
       const value = ["filter0"];
       vi.mocked(createQueryFilterString).mockReturnValue(query);
       expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
-      expect(createQueryFilterString).toHaveBeenCalledWith(["f"], value, true, false);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["f"], value, true);
     });
 
     test("invalid", () => {

package/tests/utils/query/querySample.test.ts

@@ -1,11 +1,12 @@
 import { afterEach, describe, expect, test, vi } from "vitest";
 import { createQuerySample } from "../../../src/utils/query/querySample.ts";
 import { ConfigVip } from "../../../src/types/config";
-import { SampleContainer } from "../../../src/utils/api.ts";
+import { MetadataContainer, SampleContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
 import { FieldMetadata } from "@molgenis/vip-report-vcf";
 import { createQueryFilterFieldCategorical } from "../../../src/utils/query/queryFilterField.ts";
 import { createSelectorSample } from "../../../src/utils/query/selector.ts";
 import { Query } from "@molgenis/vip-report-api";
+import { FieldMetadataWrapper } from "../../../src/utils/vcf.ts";
 
 describe("query sample", () => {
   vi.mock(import("../../../src/utils/query/selector.ts"));
@@ -23,21 +24,51 @@ describe("query sample", () => {
         number: { type: "NUMBER", count: 1 },
         categories: {},
       } as FieldMetadata;
-      const classes = "VUS,LP,P";
+      const classes = "U1,U2";
       const config = { filter_field, params: { vcf: { filter_samples: { classes } } } } as ConfigVip;
-      const sample = { item: { data: { index: 1 } } } as SampleContainer;
-
+      const sample = { item: { id: 7, data: {} } } as SampleContainer;
+      const fieldMetadata = { id: "GT", number: { type: "NUMBER", count: 1 } } as FieldMetadataWrapper;
+      const vcfMetadata = {
+        format: { GT: fieldMetadata },
+      } as Partial<VcfMetadataContainer> as VcfMetadataContainer;
+      const meta = {
+        app: {},
+        records: vcfMetadata,
+        variantTypeIds: { }
+      } as MetadataContainer
       const selector = ["x"];
-      const query: Query = { selector, operator: "==", args: "y" };
+      const completeQuery: Query = {
+        args: [
+          {
+            args: "y",
+            operator: "==",
+            selector: ["x",],
+          },
+          {
+            args: [
+              "HOM_REF",
+                "NO_CALL",
+                "UNAVAILABLE",
+              ],
+            operator: "!in",
+            selector: ["s",7,"GT_type",],
+          },
+        ],
+        operator: "and",
+      };
+      const query: Query = {
+            args: "y",
+            operator: "==",
+            selector: ["x",],
+      };
       vi.mocked(createSelectorSample).mockReturnValue(selector);
       vi.mocked(createQueryFilterFieldCategorical).mockReturnValue(query);
 
-      expect(createQuerySample(config, sample)).toStrictEqual(query);
+      expect(createQuerySample(config, sample, meta)).toStrictEqual(completeQuery);
       expect(createSelectorSample).toHaveBeenCalledWith(sample, filter_field);
       expect(createQueryFilterFieldCategorical).toHaveBeenCalledWith(selector, filter_field, [
-        "VUS",
-        "LP",
-        "P",
+        "U1",
+        "U2",
         "__null",
       ]);
     });
@@ -46,7 +77,16 @@ describe("query sample", () => {
       const classes = "VUS,LP,P";
       const config = { filter_field: null, params: { vcf: { filter_samples: { classes } } } } as ConfigVip;
       const sample = { item: { data: { index: 1 } } } as SampleContainer;
-      expect(createQuerySample(config, sample)).toStrictEqual(null);
+      const fieldMetadata = { id: "GT", number: { type: "NUMBER", count: 1 } } as FieldMetadataWrapper;
+      const vcfMetadata = {
+        format: { GT: fieldMetadata },
+      } as Partial<VcfMetadataContainer> as VcfMetadataContainer;
+      const meta = {
+        app: {},
+        records: vcfMetadata,
+        variantTypeIds: { }
+      } as MetadataContainer
+      expect(createQuerySample(config, sample, meta)).toStrictEqual(null);
     });
   });
 });

package/tests/utils/query/sort.test.ts

@@ -65,7 +65,7 @@ describe("sort utilities", () => {
   test("create record sort order from params sort order with nested path", () => {
     expect(
       createRecordSort(metadata, {
-        property: ["n", "n_object0", 1],
+        property: ["n", "n_object0", "n_string2"],
         compare: "asc",
       }),
     ).toStrictEqual({ orders: [{ field: nString2Meta, direction: DIRECTION_ASCENDING }] });

package/tests/utils/vcf.test.ts

@@ -32,6 +32,7 @@ describe("vcf", () => {
       a: ["C", "T"],
       q: null,
       f: [],
+      g: "TEST",
       n: {},
       s: [],
     },

package/vite.config.mts

@@ -10,6 +10,7 @@ export default defineConfig(({ command }) => ({
     pure: command === "build" ? ["console.log"] : [],
   },
   build: {
+    target: 'es2022',
     modulePreload: false,
     reportCompressedSize: false,
     // inline plugin build options
@@ -24,7 +25,7 @@ export default defineConfig(({ command }) => ({
   test: {
     coverage: {
       include: ["src/**"],
-      exclude: [...coverageConfigDefaults.exclude, "src/mocks/**"],
+      exclude: [...coverageConfigDefaults.exclude, "src/mocks/**", "**/*.precompiled.ts"],
       // TODO add .tsx once component tests are added
       extension: [".ts"],
       thresholds: {

package/src/mocks/GRCh37/decisionTree.json

@@ -1,355 +0,0 @@
-{
-  "rootNode": "filter",
-  "nodes": {
-    "filter": {
-      "label": "filter",
-      "type": "BOOL",
-      "description": "All filters passed",
-      "query": {
-        "field": "FILTER",
-        "operator": "==",
-        "value": ["PASS"]
-      },
-      "outcomeTrue": {
-        "nextNode": "vkgl"
-      },
-      "outcomeFalse": {
-        "nextNode": "exit_lq"
-      },
-      "outcomeMissing": {
-        "nextNode": "vkgl"
-      }
-    },
-    "spliceAI": {
-      "label": "spliceAI",
-      "type": "BOOL_MULTI",
-      "fields": [
-        "INFO/CSQ/SpliceAI_pred_DS_AG",
-        "INFO/CSQ/SpliceAI_pred_DS_AL",
-        "INFO/CSQ/SpliceAI_pred_DS_DG",
-        "INFO/CSQ/SpliceAI_pred_DS_DL"
-      ],
-      "outcomes": [
-        {
-          "operator": "OR",
-          "queries": [
-            {
-              "field": "INFO/CSQ/SpliceAI_pred_DS_AG",
-              "operator": ">",
-              "value": 0.42
-            },
-            {
-              "field": "INFO/CSQ/SpliceAI_pred_DS_AL",
-              "operator": ">",
-              "value": 0.42
-            },
-            {
-              "field": "INFO/CSQ/SpliceAI_pred_DS_DG",
-              "operator": ">",
-              "value": 0.42
-            },
-            {
-              "field": "INFO/CSQ/SpliceAI_pred_DS_DL",
-              "operator": ">",
-              "value": 0.42
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "exit_lp"
-          }
-        }
-      ],
-      "outcomeDefault": {
-        "nextNode": "annotSV"
-      },
-      "outcomeMissing": {
-        "nextNode": "annotSV"
-      }
-    },
-    "vkgl": {
-      "label": "VKGL",
-      "type": "CATEGORICAL",
-      "description": "VKGL classification",
-      "field": "INFO/CSQ/VKGL_CL",
-      "outcomeMap": {
-        "P": {
-          "nextNode": "exit_p"
-        },
-        "LP": {
-          "nextNode": "exit_lp"
-        },
-        "LB": {
-          "nextNode": "exit_lb"
-        },
-        "B": {
-          "nextNode": "exit_b"
-        }
-      },
-      "outcomeMissing": {
-        "nextNode": "clinVar"
-      },
-      "outcomeDefault": {
-        "nextNode": "clinVar"
-      }
-    },
-    "annotSV": {
-      "label": "AnnotSV",
-      "type": "CATEGORICAL",
-      "description": "VKGL classification",
-      "field": "INFO/CSQ/ASV_ACMG_class",
-      "outcomeMap": {
-        "5": {
-          "nextNode": "exit_p"
-        },
-        "4": {
-          "nextNode": "exit_lp"
-        },
-        "2": {
-          "nextNode": "exit_lb"
-        },
-        "1": {
-          "nextNode": "exit_b"
-        }
-      },
-      "outcomeMissing": {
-        "nextNode": "impact"
-      },
-      "outcomeDefault": {
-        "nextNode": "impact"
-      }
-    },
-    "gnomad": {
-      "label": "GnomAD",
-      "type": "BOOL_MULTI",
-      "description": "gnomAD_AF < 0.02 && gnomAD_HN < 5",
-      "fields": ["INFO/CSQ/gnomAD_AF", "INFO/CSQ/gnomAD_HN"],
-      "outcomes": [
-        {
-          "operator": "OR",
-          "queries": [
-            {
-              "field": "INFO/CSQ/gnomAD_AF",
-              "operator": ">=",
-              "value": 0.02
-            },
-            {
-              "field": "INFO/CSQ/gnomAD_HN",
-              "operator": ">=",
-              "value": 5
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "exit_lb"
-          }
-        }
-      ],
-      "outcomeDefault": {
-        "nextNode": "effect"
-      },
-      "outcomeMissing": {
-        "nextNode": "effect"
-      }
-    },
-    "effect": {
-      "label": "Effect",
-      "type": "BOOL",
-      "description": "Consequence contains 'missense'",
-      "query": {
-        "field": "INFO/CSQ/Consequence",
-        "operator": "contains",
-        "value": "missense_variant"
-      },
-      "outcomeTrue": {
-        "nextNode": "sift"
-      },
-      "outcomeFalse": {
-        "nextNode": "spliceAI"
-      },
-      "outcomeMissing": {
-        "nextNode": "spliceAI"
-      }
-    },
-    "clinVar": {
-      "label": "ClinVar",
-      "type": "BOOL_MULTI",
-      "fields": ["INFO/CSQ/CLIN_SIG"],
-      "outcomes": [
-        {
-          "queries": [
-            {
-              "field": "INFO/CSQ/CLIN_SIG",
-              "operator": "contains_any",
-              "value": [
-                "conflicting_interpretations_of_pathogenicity",
-                "conflicting_data_from_submitters",
-                "uncertain_significance"
-              ]
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "gnomad"
-          }
-        },
-        {
-          "queries": [
-            {
-              "field": "INFO/CSQ/CLIN_SIG",
-              "operator": "contains_any",
-              "value": ["likely_benign", "benign"]
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "exit_lb"
-          }
-        },
-        {
-          "queries": [
-            {
-              "field": "INFO/CSQ/CLIN_SIG",
-              "operator": "contains_any",
-              "value": ["likely_pathogenic", "pathogenic"]
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "exit_lp"
-          }
-        }
-      ],
-      "outcomeDefault": {
-        "nextNode": "gnomad"
-      },
-      "outcomeMissing": {
-        "nextNode": "gnomad"
-      }
-    },
-    "sift": {
-      "label": "SIFT",
-      "description": "SIFT qualitative prediction",
-      "type": "BOOL",
-      "query": {
-        "field": "INFO/CSQ/SIFT",
-        "operator": "<",
-        "value": 0.05
-      },
-      "outcomeTrue": {
-        "nextNode": "exit_lp"
-      },
-      "outcomeFalse": {
-        "nextNode": "polyphen"
-      },
-      "outcomeMissing": {
-        "nextNode": "polyphen"
-      }
-    },
-    "polyphen": {
-      "label": "PolyPhen",
-      "description": "PolyPhen qualitative prediction",
-      "type": "BOOL_MULTI",
-      "fields": ["INFO/CSQ/PolyPhen"],
-      "outcomes": [
-        {
-          "queries": [
-            {
-              "field": "INFO/CSQ/PolyPhen",
-              "operator": "<",
-              "value": 0.15
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "exit_lb"
-          }
-        },
-        {
-          "operator": "AND",
-          "queries": [
-            {
-              "field": "INFO/CSQ/PolyPhen",
-              "operator": ">",
-              "value": 0.15
-            },
-            {
-              "field": "INFO/CSQ/PolyPhen",
-              "operator": "<",
-              "value": 0.85
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "exit_vus"
-          }
-        },
-        {
-          "queries": [
-            {
-              "field": "INFO/CSQ/PolyPhen",
-              "operator": ">",
-              "value": 0.85
-            }
-          ],
-          "outcomeTrue": {
-            "nextNode": "exit_lp"
-          }
-        }
-      ],
-      "outcomeDefault": {
-        "nextNode": "impact"
-      },
-      "outcomeMissing": {
-        "nextNode": "impact"
-      }
-    },
-    "impact": {
-      "label": "IMPACT",
-      "type": "CATEGORICAL",
-      "description": "IMPACT rating",
-      "field": "INFO/CSQ/IMPACT",
-      "outcomeMap": {
-        "MODIFIER": {
-          "nextNode": "exit_lb"
-        },
-        "LOW": {
-          "nextNode": "exit_lb"
-        },
-        "MODERATE": {
-          "nextNode": "exit_vus"
-        },
-        "HIGH": {
-          "nextNode": "exit_lp"
-        }
-      },
-      "outcomeMissing": {
-        "nextNode": "exit_vus"
-      }
-    },
-    "exit_rm": {
-      "label": "Remove",
-      "description": "Low quality variants.",
-      "type": "LEAF",
-      "class": "LQ"
-    },
-    "exit_b": {
-      "label": "Benign",
-      "type": "LEAF",
-      "class": "B"
-    },
-    "exit_lb": {
-      "label": "Likely Benign",
-      "type": "LEAF",
-      "class": "LB"
-    },
-    "exit_vus": {
-      "label": "Unknown Significance",
-      "type": "LEAF",
-      "class": "VUS"
-    },
-    "exit_lp": {
-      "label": "Likely Pathogenic",
-      "type": "LEAF",
-      "class": "LP"
-    },
-    "exit_p": {
-      "label": "Pathogenic",
-      "type": "LEAF",
-      "class": "P"
-    }
-  }
-}