@molgenis/vip-report-template 6.1.1 → 7.0.0

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

@@ -0,0 +1,301 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createQueryFilterComposed } from "../../../src/utils/query/queryFilterComposed.ts";
+import {
+  ConfigFilterAllelicImbalance,
+  ConfigFilterComposed,
+  ConfigFilterDeNovo,
+  ConfigFilterHpo,
+  ConfigFilterInheritanceMatch,
+  ConfigFilterLocus,
+  ConfigFilterVipC,
+  ConfigFilterVipCS,
+  FilterValueHpo,
+  FilterValueLocus,
+  FilterValueVipC,
+  FilterValueVipCS,
+} from "../../../src/types/configFilterComposed";
+import { Query } from "@molgenis/vip-report-api";
+import {
+  createQueryFilterClosedInterval,
+  createQueryFilterClosedIntervalOutside,
+  createQueryFilterString,
+} from "../../../src/utils/query/queryFilter.ts";
+import { SampleContainer } from "../../../src/utils/api.ts";
+import { createQueryFilterFieldCategorical } from "../../../src/utils/query/queryFilterField.ts";
+
+describe("query composed filters", () => {
+  vi.mock(import("../../../src/utils/query/queryFilter.ts"));
+  vi.mock(import("../../../src/utils/query/queryFilterField.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("createQueryFilterComposed", () => {
+    const query: Query = { selector: "x", operator: "==", args: "y" };
+
+    test("hpo", () => {
+      const field = { id: "f", number: {}, categories: {} };
+      const config = { type: "composed", id: "composed/hpo", field: field } as ConfigFilterHpo;
+      const value = ["chr1"] as FilterValueHpo;
+      vi.mocked(createQueryFilterFieldCategorical).mockReturnValue(query);
+      expect(createQueryFilterComposed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterFieldCategorical).toHaveBeenCalledWith(["n", "f"], field, value);
+    });
+
+    describe("locus", () => {
+      const query: Query = { selector: "c", operator: "==", args: "chr1" };
+
+      test("locus chr+start+end", () => {
+        const queryPos: Query = { selector: "z", operator: "==", args: "y" };
+
+        const config = { type: "composed", id: "composed/locus" } as ConfigFilterLocus;
+        const value = { chromosome: "chr1", start: 1, end: 2 } as FilterValueLocus;
+        vi.mocked(createQueryFilterString).mockReturnValue(query);
+        vi.mocked(createQueryFilterClosedInterval).mockReturnValue(queryPos);
+        expect(createQueryFilterComposed(config, value)).toStrictEqual({
+          args: [query, queryPos],
+          operator: "and",
+        });
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+        expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["p"], { left: 1, right: 2 });
+      });
+
+      test("locus chr+start", () => {
+        const queryPos: Query = { selector: "z", operator: "==", args: "y" };
+
+        const config = { type: "composed", id: "composed/locus" } as ConfigFilterLocus;
+        const value = { chromosome: "chr1", start: 1 } as FilterValueLocus;
+        vi.mocked(createQueryFilterString).mockReturnValue(query);
+        vi.mocked(createQueryFilterClosedInterval).mockReturnValue(queryPos);
+        expect(createQueryFilterComposed(config, value)).toStrictEqual({
+          args: [query, queryPos],
+          operator: "and",
+        });
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+        expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["p"], { left: 1, right: undefined });
+      });
+
+      test("locus chr+end", () => {
+        const queryPos: Query = { selector: "z", operator: "==", args: "y" };
+
+        const config = { type: "composed", id: "composed/locus" } as ConfigFilterLocus;
+        const value = { chromosome: "chr1", end: 2 } as FilterValueLocus;
+        vi.mocked(createQueryFilterString).mockReturnValue(query);
+        vi.mocked(createQueryFilterClosedInterval).mockReturnValue(queryPos);
+        expect(createQueryFilterComposed(config, value)).toStrictEqual({
+          args: [query, queryPos],
+          operator: "and",
+        });
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+        expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["p"], { left: undefined, right: 2 });
+      });
+
+      test("locus chr", () => {
+        const config = { type: "composed", id: "composed/locus" } as ConfigFilterLocus;
+        const value = { chromosome: "chr1" } as FilterValueLocus;
+        vi.mocked(createQueryFilterString).mockReturnValue(query);
+        expect(createQueryFilterComposed(config, value)).toStrictEqual(query);
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+      });
+    });
+
+    describe("allelicImbalance", () => {
+      const config = {
+        type: "composed",
+        id: "composed/allelicImbalance",
+        sample: { item: { data: { index: 1 } } } as SampleContainer,
+        viabField: { id: "VIAB" },
+        genotypeField: { id: "GT" },
+      } as ConfigFilterAllelicImbalance;
+      const queryInterval: Query = { selector: "viab", operator: "==", args: "inside" };
+      const queryIntervalClosed: Query = { selector: "viab", operator: "==", args: "outside" };
+
+      const expectedTrueQuery = {
+        args: [
+          {
+            args: [
+              { selector: ["s", 1, "GT", "t"], operator: "in", args: ["hom_a", "hom_r"] },
+              { selector: "viab", operator: "==", args: "inside" },
+            ],
+            operator: "and",
+          },
+          {
+            args: [
+              { selector: ["s", 1, "GT", "t"], operator: "==", args: "het" },
+              { selector: "viab", operator: "==", args: "outside" },
+            ],
+            operator: "and",
+          },
+        ],
+        operator: "or",
+      };
+
+      test("true", () => {
+        vi.mocked(createQueryFilterClosedInterval).mockReturnValue(queryInterval);
+        vi.mocked(createQueryFilterClosedIntervalOutside).mockReturnValue(queryIntervalClosed);
+        expect(createQueryFilterComposed(config, ["true"])).toStrictEqual(expectedTrueQuery);
+        expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["s", 1, "VIAB"], { left: 0.02, right: 0.98 });
+        expect(createQueryFilterClosedIntervalOutside).toHaveBeenCalledWith(["s", 1, "VIAB"], {
+          left: 0.2,
+          right: 0.8,
+        });
+      });
+
+      const expectedFalseQuery = {
+        args: [
+          {
+            args: [
+              { selector: ["s", 1, "GT", "t"], operator: "in", args: ["hom_a", "hom_r"] },
+              { selector: "viab", operator: "==", args: "outside" },
+            ],
+            operator: "and",
+          },
+          {
+            args: [
+              { selector: ["s", 1, "GT", "t"], operator: "==", args: "het" },
+              { selector: "viab", operator: "==", args: "inside" },
+            ],
+            operator: "and",
+          },
+        ],
+        operator: "or",
+      };
+
+      test("false", () => {
+        vi.mocked(createQueryFilterClosedInterval).mockReturnValue(queryInterval);
+        vi.mocked(createQueryFilterClosedIntervalOutside).mockReturnValue(queryIntervalClosed);
+        expect(createQueryFilterComposed(config, ["false"])).toStrictEqual(expectedFalseQuery);
+        expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["s", 1, "VIAB"], {
+          left: 0.2,
+          right: 0.8,
+        });
+        expect(createQueryFilterClosedIntervalOutside).toHaveBeenCalledWith(["s", 1, "VIAB"], {
+          left: 0.02,
+          right: 0.98,
+        });
+      });
+
+      const expectedNullQuery = {
+        args: [
+          { selector: ["s", 1, "VIAB"], operator: "==", args: null },
+          { selector: ["s", 1, "VIAB"], operator: "==", args: undefined },
+        ],
+        operator: "or",
+      };
+
+      test("__null", () => {
+        vi.mocked(createQueryFilterClosedInterval).mockReturnValue(queryInterval);
+        vi.mocked(createQueryFilterClosedIntervalOutside).mockReturnValue(queryIntervalClosed);
+        expect(createQueryFilterComposed(config, ["__null"])).toStrictEqual(expectedNullQuery);
+      });
+
+      test("mixed", () => {
+        vi.mocked(createQueryFilterClosedInterval).mockReturnValue(queryInterval);
+        vi.mocked(createQueryFilterClosedIntervalOutside).mockReturnValue(queryIntervalClosed);
+
+        expect(createQueryFilterComposed(config, ["true", "__null"])).toStrictEqual({
+          args: [expectedTrueQuery, expectedNullQuery],
+          operator: "or",
+        });
+      });
+    });
+
+    describe("inheritanceMatch", () => {
+      const config = {
+        type: "composed",
+        id: "composed/inheritanceMatch",
+        sample: { item: { data: { index: 1 } } } as SampleContainer,
+        vimField: { id: "VIM" },
+      } as ConfigFilterInheritanceMatch;
+
+      test("true", () => {
+        expect(createQueryFilterComposed(config, ["true"])).toStrictEqual({
+          selector: ["s", 1, "VIM"],
+          operator: "==",
+          args: 1,
+        });
+      });
+
+      test("false", () => {
+        expect(createQueryFilterComposed(config, ["false"])).toStrictEqual({
+          selector: ["s", 1, "VIM"],
+          operator: "==",
+          args: 0,
+        });
+      });
+
+      test("potential", () => {
+        expect(createQueryFilterComposed(config, ["potential"])).toStrictEqual({
+          args: [
+            { selector: ["s", 1, "VIM"], operator: "==", args: null },
+            { selector: ["s", 1, "VIM"], operator: "==", args: undefined },
+          ],
+          operator: "or",
+        });
+      });
+    });
+
+    describe("deNovo", () => {
+      const config = {
+        type: "composed",
+        id: "composed/deNovo",
+        sample: { item: { data: { index: 1 } } } as SampleContainer,
+        vidField: { id: "VID" },
+      } as ConfigFilterDeNovo;
+
+      test("true", () => {
+        expect(createQueryFilterComposed(config, ["true"])).toStrictEqual({
+          selector: ["s", 1, "VID"],
+          operator: "==",
+          args: 1,
+        });
+      });
+
+      test("false", () => {
+        expect(createQueryFilterComposed(config, ["false"])).toStrictEqual({
+          selector: ["s", 1, "VID"],
+          operator: "==",
+          args: 0,
+        });
+      });
+
+      test("potential", () => {
+        expect(createQueryFilterComposed(config, ["potential"])).toStrictEqual({
+          args: [
+            { selector: ["s", 1, "VID"], operator: "==", args: null },
+            { selector: ["s", 1, "VID"], operator: "==", args: undefined },
+          ],
+          operator: "or",
+        });
+      });
+    });
+
+    test("vipC", () => {
+      const field = { id: "f", number: {}, categories: {} };
+      const config = { type: "composed", id: "composed/vipC", field: field } as ConfigFilterVipC;
+      const value = ["chr1"] as FilterValueVipC;
+      vi.mocked(createQueryFilterFieldCategorical).mockReturnValue(query);
+      expect(createQueryFilterComposed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterFieldCategorical).toHaveBeenCalledWith(["n", "f"], field, value);
+    });
+
+    test("vipCS", () => {
+      const sample = { item: { data: { index: 1 } } } as SampleContainer;
+      const field = { id: "f", number: {}, categories: {} };
+      const config = { type: "composed", id: "composed/vipCS", field, sample } as ConfigFilterVipCS;
+      const value = ["chr1"] as FilterValueVipCS;
+      vi.mocked(createQueryFilterFieldCategorical).mockReturnValue(query);
+      expect(createQueryFilterComposed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterFieldCategorical).toHaveBeenCalledWith(["s", 1, "f"], field, value);
+    });
+
+    test("invalid", () => {
+      const config = {
+        type: "composed",
+        id: "invalid",
+      } as ConfigFilterComposed;
+      expect(() => createQueryFilterComposed(config, ["value"])).toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { Query } from "@molgenis/vip-report-api";
+import { createQueryFilterClosedInterval, createQueryFilterString } from "../../../src/utils/query/queryFilter.ts";
+import { createQueryFilterField } from "../../../src/utils/query/queryFilterField.ts";
+import { ConfigFilterField, ConfigFilterFormat } from "../../../src/types/configFilter";
+import { FieldMetadata } from "@molgenis/vip-report-vcf";
+import { SampleContainer } from "../../../src/utils/api.ts";
+
+describe("query filter fixed", () => {
+  vi.mock(import("../../../src/utils/query/queryFilter.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("createQueryFilterFixed", () => {
+    const query: Query = { selector: "x", operator: "==", args: "y" };
+
+    test("CATEGORICAL count=1 info", () => {
+      const categories = { cat: { label: "my_label" } };
+      const field = { id: "f", type: "CATEGORICAL", number: { type: "NUMBER", count: 1 }, categories } as FieldMetadata;
+      const config = { type: "info", id: "filter", field } as ConfigFilterField;
+      const value = ["x"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterField(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "f"], value, false, false);
+    });
+
+    test("CHARACTER count=1 info", () => {
+      const field = { id: "f", type: "CHARACTER", number: { type: "NUMBER", count: 1 } } as FieldMetadata;
+      const config = { type: "info", id: "filter", field } as ConfigFilterField;
+      const value = ["x"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterField(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "f"], value, false, false);
+    });
+
+    test("STRING count=* info nested", () => {
+      const field = { id: "c", parent: { id: "p" }, type: "STRING", number: { type: "OTHER" } } as FieldMetadata;
+      const config = { type: "info", id: "filter", field } as ConfigFilterField;
+      const value = ["x"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterField(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["n", "p", "c"], value, true, 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 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);
+    });
+
+    test("FLOAT count=1 info", () => {
+      const field = { id: "f", type: "FLOAT", number: { type: "NUMBER", count: 1 } } as FieldMetadata;
+      const config = { type: "info", id: "filter", field } as ConfigFilterField;
+      const value = { left: 1.23, right: 3.45 };
+      vi.mocked(createQueryFilterClosedInterval).mockReturnValue(query);
+      expect(createQueryFilterField(config, value)).toStrictEqual(query);
+      expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["n", "f"], value);
+    });
+
+    test("INTEGER count=1 info", () => {
+      const field = { id: "f", type: "INTEGER", number: { type: "NUMBER", count: 1 } } as FieldMetadata;
+      const config = { type: "info", id: "filter", field } as ConfigFilterField;
+      const value = { left: 1, right: 3 };
+      vi.mocked(createQueryFilterClosedInterval).mockReturnValue(query);
+      expect(createQueryFilterField(config, value)).toStrictEqual(query);
+      expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["n", "f"], value);
+    });
+  });
+});

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

@@ -0,0 +1,86 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createQueryFilterFixed } from "../../../src/utils/query/queryFilterFixed.ts";
+import {
+  ConfigFilterAlt,
+  ConfigFilterChrom,
+  ConfigFilterFilter,
+  ConfigFilterId,
+  ConfigFilterPos,
+  ConfigFilterQual,
+  ConfigFilterRef,
+} from "../../../src/types/configFilter";
+import { createQueryFilterClosedInterval, createQueryFilterString } from "../../../src/utils/query/queryFilter.ts";
+import { Query } from "@molgenis/vip-report-api";
+
+describe("query filter fixed", () => {
+  vi.mock(import("../../../src/utils/query/queryFilter.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("createQueryFilterFixed", () => {
+    const query: Query = { selector: "x", operator: "==", args: "y" };
+
+    test("chrom", () => {
+      const config = { type: "fixed", id: "fixed/chrom" } as ConfigFilterChrom;
+      const value = ["chr1"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["c"], value, false, false);
+    });
+
+    test("pos", () => {
+      const config = { type: "fixed", id: "fixed/pos" } as ConfigFilterPos;
+      const value = { left: 1, right: 2 };
+      vi.mocked(createQueryFilterClosedInterval).mockReturnValue(query);
+      expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["p"], value);
+    });
+
+    test("id", () => {
+      const config = { type: "fixed", id: "fixed/id" } as ConfigFilterId;
+      const value = ["id0"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["i"], value, true, false);
+    });
+
+    test("ref", () => {
+      const config = { type: "fixed", id: "fixed/ref" } as ConfigFilterRef;
+      const value = ["C"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["r"], value, false, false);
+    });
+
+    test("alt", () => {
+      const config = { type: "fixed", id: "fixed/alt" } as ConfigFilterAlt;
+      const value = ["C"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["a"], value, true, false);
+    });
+
+    test("qual", () => {
+      const config = { type: "fixed", id: "fixed/qual" } as ConfigFilterQual;
+      const value = { left: 1, right: 2 };
+      vi.mocked(createQueryFilterClosedInterval).mockReturnValue(query);
+      expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["q"], value);
+    });
+
+    test("id", () => {
+      const config = { type: "fixed", id: "fixed/filter" } as ConfigFilterFilter;
+      const value = ["filter0"];
+      vi.mocked(createQueryFilterString).mockReturnValue(query);
+      expect(createQueryFilterFixed(config, value)).toStrictEqual(query);
+      expect(createQueryFilterString).toHaveBeenCalledWith(["f"], value, true, false);
+    });
+
+    test("invalid", () => {
+      const config = { type: "fixed", id: "fixed/invalid" } as ConfigFilterFilter;
+      expect(() => createQueryFilterFixed(config, ["value"])).toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,45 @@
+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 { 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";
+
+describe("query sample", () => {
+  vi.mock(import("../../../src/utils/query/selector.ts"));
+  vi.mock(import("../../../src/utils/query/queryFilterField.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("createQuerySample", () => {
+    test("create", () => {
+      const filter_field = {
+        id: "FORMAT/VIPC_S",
+        type: "CATEGORICAL",
+        number: { type: "NUMBER", count: 1 },
+        categories: {},
+      } as FieldMetadata;
+      const classes = "VUS,LP,P";
+      const config = { filter_field, params: { vcf: { filter_samples: { classes } } } } as ConfigVip;
+      const sample = { item: { data: { index: 1 } } } as SampleContainer;
+
+      const selector = ["x"];
+      const query: Query = { selector, operator: "==", args: "y" };
+      vi.mocked(createSelectorSample).mockReturnValue(selector);
+      vi.mocked(createQueryFilterFieldCategorical).mockReturnValue(query);
+
+      expect(createQuerySample(config, sample)).toStrictEqual(query);
+      expect(createSelectorSample).toHaveBeenCalledWith(sample, filter_field);
+      expect(createQueryFilterFieldCategorical).toHaveBeenCalledWith(selector, filter_field, [
+        "VUS",
+        "LP",
+        "P",
+        "__null",
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "vitest";
+import { createQueryVariantType } from "../../../src/utils/query/queryVariantType.ts";
+import { VariantType } from "../../../src/utils/variantType.ts";
+
+describe("query variant type", () => {
+  describe("createQueryVariantType", () => {
+    test("all", () => {
+      const variantType = { id: "all" } as VariantType;
+      expect(createQueryVariantType(variantType)).toStrictEqual(null);
+    });
+
+    test("snv", () => {
+      const variantType = { id: "snv" } as VariantType;
+      expect(createQueryVariantType(variantType)).toStrictEqual({
+        args: [
+          {
+            args: null,
+            operator: "==",
+            selector: ["n", "SVTYPE"],
+          },
+          { args: undefined, operator: "==", selector: ["n", "SVTYPE"] },
+        ],
+        operator: "or",
+      });
+    });
+
+    test("str", () => {
+      const variantType = { id: "str" } as VariantType;
+      expect(createQueryVariantType(variantType)).toStrictEqual({
+        args: "STR",
+        operator: "==",
+        selector: ["n", "SVTYPE"],
+      });
+    });
+
+    test("sv", () => {
+      const variantType = { id: "sv" } as VariantType;
+      expect(createQueryVariantType(variantType)).toStrictEqual({
+        args: [
+          {
+            args: "STR",
+            operator: "!=",
+            selector: ["n", "SVTYPE"],
+          },
+          { args: null, operator: "!=", selector: ["n", "SVTYPE"] },
+          {
+            args: undefined,
+            operator: "!=",
+            selector: ["n", "SVTYPE"],
+          },
+        ],
+        operator: "and",
+      });
+    });
+  });
+});

package/{src/__tests__/sortUtils.test.ts → tests/utils/query/sort.test.ts}

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "vitest";
-import { createRecordSort, DIRECTION_ASCENDING } from "../utils/sortUtils";
-import { FieldMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
-import { Metadata } from "@molgenis/vip-report-vcf/src/Vcf";
+import { createRecordSort, DIRECTION_ASCENDING } from "../../../src/utils/query/sort.ts";
+import { FieldMetadata, VcfMetadata } from "@molgenis/vip-report-vcf";
 
 describe("sort utilities", () => {
   const nString0Meta: FieldMetadata = {
@@ -47,7 +46,7 @@ describe("sort utilities", () => {
   nString2Meta.parent = nObject0Meta;
   nObject0Meta.nested?.items.push(nString1Meta, nString2Meta);
 
-  const metadata: Metadata = {
+  const metadata: VcfMetadata = {
     lines: [],
     info: { n_string0: nString0Meta, n_object0: nObject0Meta },
     format: {},