@molgenis/vip-report-template 7.1.3 → 8.0.1

package/src/utils/query/selector.ts

@@ -17,25 +17,10 @@ export function createInfoSortPath(field: FieldMetadata): SortPath {
 
 function selector(field: FieldMetadata): SelectorPart[] {
   const selector: Selector = [];
-  let currentField: FieldMetadata | undefined = field;
-  do {
-    if (currentField.parent && currentField.parent.nested) {
-      const items = currentField.parent.nested.items;
-      let i;
-      for (i = 0; i < items.length; ++i) {
-        if (items[i]!.id === currentField.id) {
-          break;
-        }
-      }
-      selector.push(i);
-      if (currentField.parent.number.count !== 1) {
-        selector.push("*");
-      }
-    } else {
-      selector.push(currentField.id);
-    }
-    currentField = currentField.parent;
-  } while (currentField);
-  selector.reverse();
+  const currentField: FieldMetadata | undefined = field;
+  if (currentField.parent) {
+    selector.push(currentField.parent.id);
+  }
+  selector.push(currentField.id);
   return selector;
 }

package/src/utils/query/sort.ts

@@ -1,5 +1,5 @@
 import { FieldMetadata, VcfMetadata } from "@molgenis/vip-report-vcf";
-import { CompareFn, SortOrder, SortPath } from "@molgenis/vip-report-api";
+import { SortOrder, SortPath } from "@molgenis/vip-report-api";
 import { ConfigSort, ConfigSortOrder } from "../../types/configSort";
 
 import { createInfoSortPath } from "./selector.ts";
@@ -68,16 +68,16 @@ function createField(property: string | SortPath, recordsMeta: VcfMetadata): Fie
 
   if (path.length === 3) {
     const pathIndex = path[2];
-    if (typeof pathIndex !== "number") throw new InvalidSortPathError(path);
+    if (typeof pathIndex !== "string") throw new InvalidSortPathError(path);
     if (field.nested === undefined) throw new InvalidSortPathError(path);
 
-    field = field.nested.items[pathIndex];
+    field = field.nested.items.find((item) => item.id === path[2]);
     if (field === undefined) throw new InvalidSortPathError(path);
   }
   return field;
 }
 
-function createDirection(compare?: "asc" | "desc" | CompareFn): Direction {
+function createDirection(compare?: "asc" | "desc"): Direction {
   if (compare === undefined) return DIRECTION_ASCENDING;
   else if (compare === DIRECTION_ASCENDING) return DIRECTION_ASCENDING;
   else if (compare === DIRECTION_DESCENDING) return DIRECTION_DESCENDING;

package/src/utils/vcf.ts

@@ -6,6 +6,7 @@ import {
   RecordSample,
   Value,
   ValueDescription,
+  ValueObject,
   ValueString,
   VcfMetadata,
   VcfRecord,
@@ -38,7 +39,11 @@ function createFieldMapTypedRec(keyPrefix: string, fieldMetadataList: FieldMetad
   fieldMetadataList.forEach((fieldMetadata, index) => {
     const key = `${keyPrefix}/${fieldMetadata.id}`;
     if (fieldMetadata.nested) {
-      const nestedFields = createFieldMapTypedRec(key, fieldMetadata.nested.items);
+      const nestedItemsArray = Object.keys(fieldMetadata.nested?.items)
+        .map(Number)
+        .sort((a, b) => a - b)
+        .map((index) => fieldMetadata.nested?.items[index]) as FieldMetadata[];
+      const nestedFields = createFieldMapTypedRec(key, nestedItemsArray);
       Object.assign(fields, nestedFields);
 
       // add parent field, but update items with items in nestedFields
@@ -47,7 +52,7 @@ function createFieldMapTypedRec(keyPrefix: string, fieldMetadataList: FieldMetad
         index,
         nested: {
           ...fieldMetadata.nested,
-          items: fieldMetadata.nested.items.map((field) => nestedFields[`${key}/${field.id}`]!),
+          items: nestedItemsArray.map((field) => nestedFields[`${key}/${field.id}`]!),
         },
       };
     } else {
@@ -89,7 +94,7 @@ function mapFieldValue(value: Value | Genotype | undefined, fieldMetadata: Field
   } else if (fieldMetadata.number.count === 1) {
     definedValue = value !== undefined ? value : null;
   } else {
-    definedValue = value !== undefined && value !== null ? value : [];
+    definedValue = value !== undefined && value !== null && value !== "" ? value : [];
   }
   return mapFieldValueDefined(definedValue, fieldMetadata);
 }
@@ -100,6 +105,7 @@ function getFieldValue(
   fieldMetadata: FieldMetadataWrapper,
 ): FieldValue {
   let value: Value | Genotype | undefined;
+  let multiValueArray;
   if (fieldMetadata.parent) {
     if (fieldMetadata.parent.id in valueContainer) {
       const parentValue = valueContainer[fieldMetadata.parent.id]!;
@@ -112,11 +118,15 @@ function getFieldValue(
       } else {
         if (parentValueArray.length < valueIndex) throw new RuntimeError();
         const multiValue = parentValueArray[valueIndex]!;
-        if (!Array.isArray(multiValue)) throw new InvalidVcfError();
-        const multiValueArray = multiValue as Value[];
-
-        if (multiValueArray.length < fieldMetadata.index) throw new InvalidVcfError();
-        value = multiValueArray[fieldMetadata.index]!;
+        if (!Array.isArray(multiValue)) {
+          multiValueArray = multiValue as ValueObject;
+          if (multiValueArray === null) throw new InvalidVcfError();
+          value = multiValueArray[fieldMetadata.id]!;
+        } else {
+          multiValueArray = multiValue as Value[];
+          if (multiValueArray.length < fieldMetadata.index) throw new InvalidVcfError();
+          value = multiValueArray[fieldMetadata.index]!;
+        }
       }
     } else {
       value = undefined;
@@ -128,7 +138,6 @@ function getFieldValue(
       value = undefined;
     }
   }
-
   return mapFieldValue(value, fieldMetadata);
 }
 
@@ -188,7 +197,7 @@ function createCategoricalValue(infoMetadata: FieldMetadata, value: ValueString)
   if (infoMetadata.categories === undefined) throw new RuntimeError();
 
   let valueDescription: ValueDescription | null;
-  if (value !== null) {
+  if (value !== null && value !== "") {
     if (!(value in infoMetadata.categories)) {
       throw new RuntimeError(
         `invalid categorical field '${infoMetadata.id}' value '${value}' is not one of [${Object.keys(infoMetadata.categories).join(", ")}]`,
@@ -202,7 +211,7 @@ function createCategoricalValue(infoMetadata: FieldMetadata, value: ValueString)
 }
 
 function getRecordSample(sample: SampleContainer, record: Item<VcfRecord>): RecordSample {
-  const recordSample = record.data.s[sample.item.data.index];
+  const recordSample = record.data.s[sample.item.data.index as number];
   if (recordSample === undefined) throw new ArrayIndexOutOfBoundsException();
   return recordSample;
 }

package/src/views/Help.tsx

@@ -91,11 +91,11 @@ export const Help: Component = () => {
                   <tbody>
                     <tr>
                       <th>Filename:</th>
-                      <td>{metadata()?.htsFile.uri}</td>
+                      <td>{metadata().app.htsFile?.uri}</td>
                     </tr>
                     <tr>
                       <th>Assembly:</th>
-                      <td>{metadata()?.htsFile.genomeAssembly}</td>
+                      <td>{metadata().app.htsFile?.genomeAssembly}</td>
                     </tr>
                   </tbody>
                 </Table>

package/src/views/SampleVariant.tsx

@@ -5,11 +5,14 @@ import { getConfig, getMetadata, getRecordById, getSampleById } from "./data/dat
 import { parseVariantType } from "../utils/variantType.ts";
 import { VariantContainer } from "../components/VariantContainer.tsx";
 import { VariantBreadcrumb } from "../components/VariantBreadcrumb.tsx";
+import { Item, Sample } from "@molgenis/vip-report-api";
+import { getPedigreeSamples } from "../utils/sample.ts";
 
 export const SampleVariant: Component<RouteSectionProps> = (props) => {
   const variantType = () => parseVariantType(props.params.variantType);
   const sample = createAsync(() => getSampleById(props.params.sampleId));
-  const record = createAsync(() => getRecordById(props.params.variantId));
+  const samples = (): Item<Sample>[] => (sample() ? getPedigreeSamples(sample()!) : []);
+  const record = createAsync(() => getRecordById(props.params.variantId, samples()));
   const metadata = createAsync(() => getMetadata());
   const config = createAsync(() => getConfig());
 

package/src/views/Samples.tsx

@@ -4,7 +4,7 @@ import { PageChangeEvent, Pager } from "../components/Pager";
 import { SearchBox } from "../components/SearchBox";
 import { Breadcrumb } from "../components/Breadcrumb";
 import { useStore } from "../store";
-import { Params, Query, QueryClause } from "@molgenis/vip-report-api";
+import { Params, Query, QueryClause, SortOrder } from "@molgenis/vip-report-api";
 import { Loader } from "../components/Loader";
 import { fetchSamples } from "../utils/api.ts";
 import { Checkbox, CheckboxEvent } from "../components/form/Checkbox.tsx";
@@ -33,11 +33,11 @@ export const Samples: Component = () => {
   function createQuery(search: string | undefined, probandFilterValue: boolean | undefined): Query | null {
     const searchQuery: QueryClause | undefined =
       search !== undefined && search !== ""
-        ? { selector: ["person", "individualId"], operator: "~=", args: search }
+        ? { selector: ["sample", "individualId"], operator: "~=", args: search }
         : undefined;
     const probandQuery: QueryClause | undefined =
       probandFilterValue !== undefined && probandFilterValue
-        ? { selector: ["proband"], operator: "==", args: probandFilterValue }
+        ? { selector: ["sample", "proband"], operator: "==", args: probandFilterValue }
         : undefined;
     if (searchQuery !== undefined || probandQuery != undefined) {
       const args: QueryClause[] = [];
@@ -57,9 +57,16 @@ export const Samples: Component = () => {
     return null;
   }
 
+  const sortOrder: SortOrder[] = [
+    { property: ["sample", "familyId"], compare: "asc" },
+    { property: ["sample", "proband"], compare: "desc" },
+    { property: ["sample", "individualId"], compare: "asc" },
+  ];
+
   const params = (): Params => {
     return {
       query: createQuery(searchQuery(), probandFilterValue()) || undefined,
+      sort: sortOrder,
       page: page() || undefined,
     };
   };

package/src/views/data/data.tsx

@@ -1,5 +1,5 @@
 import { query } from "@solidjs/router";
-import { DecisionTree, Item } from "@molgenis/vip-report-api";
+import { DecisionTree, Item, Sample } from "@molgenis/vip-report-api";
 import { VcfRecord } from "@molgenis/vip-report-vcf";
 import {
   fetchConfig,
@@ -24,7 +24,7 @@ export const getSampleById = query(
 );
 
 export const getRecordById = query(
-  (id: string | undefined): Promise<Item<VcfRecord>> => fetchRecordById(parseId(id)),
+  (id: string | undefined, samples?: Item<Sample>[]): Promise<Item<VcfRecord>> => fetchRecordById(parseId(id), samples),
   "variant",
 );
 

package/tests/utils/config/configFiltersComposed.test.ts

@@ -36,6 +36,7 @@ describe("config filters composed", () => {
       const configBase: ConfigJsonFilterComposed = {
         type: "composed",
         name: "hpo",
+        defaultValue: "TEST"
       };
       const sample = {
         phenotypes: [
@@ -56,6 +57,7 @@ describe("config filters composed", () => {
         const filter = initConfigFilterComposed(configBase, configVip, metadata, sample) as ConfigFilterHpo;
         expect(filter.type).toStrictEqual("composed");
         expect(filter.id).toStrictEqual("hpo");
+        expect(filter.defaultValue).toStrictEqual("TEST");
         expect(filter.field).toStrictEqual({
           ...fieldHpo,
           categories: {

package/tests/utils/config/configFiltersField.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test, vi } from "vitest";
 import { SampleContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
 import { initConfigFiltersGenotype, initConfigFiltersInfo } from "../../../src/utils/config/configFiltersField.ts";
 import { FieldMetadataWrapper, getInfoFieldsRegex, getSampleFieldsRegex } from "../../../src/utils/vcf.ts";
-import { ConfigJsonFieldGenotype, ConfigJsonFieldInfo } from "../../../src/types/config";
+import {ConfigJsonFieldGenotype, ConfigJsonFieldInfo, ConfigJsonFilterInfo} from "../../../src/types/config";
 
 describe("config filters field", () => {
   vi.mock(import("../../../src/utils/vcf.ts"));
@@ -15,11 +15,12 @@ describe("config filters field", () => {
     const metadata = {} as VcfMetadataContainer;
 
     test("config matches one field", () => {
-      const config: ConfigJsonFieldInfo = {
+      const config: ConfigJsonFilterInfo = {
         type: "info",
         name: "field",
         label: "my_field_label",
         description: "my_field_description",
+        defaultValue: "TEST"
       };
       const field = {
         id: "INFO/field",
@@ -35,6 +36,7 @@ describe("config filters field", () => {
       expect(filter.field).toStrictEqual(field);
       expect(filter.label()).toStrictEqual("my_field_label");
       expect(filter.description()).toStrictEqual("my_field_description");
+      expect(filter.defaultValue).toStrictEqual("TEST");
 
       expect(getInfoFieldsRegex).toHaveBeenCalledWith(metadata, /^field$/);
     });

package/tests/utils/config/configFiltersFixed.test.ts

@@ -4,66 +4,83 @@ import { initConfigFilterFixed } from "../../../src/utils/config/configFiltersFi
 describe("config filters fixed", () => {
   describe("initConfigFilterFixed", () => {
     test("chrom", () => {
-      const filter = initConfigFilterFixed({ type: "fixed", name: "chrom" });
+      const filter = initConfigFilterFixed({ type: "fixed", name: "chrom", defaultValue: "test" });
 
       expect(filter.type).toStrictEqual("fixed");
       expect(filter.id).toStrictEqual("chrom");
       expect(filter.label()).toStrictEqual("Chromosome");
       expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual("test");
     });
 
     test("pos", () => {
-      const filter = initConfigFilterFixed({ type: "fixed", name: "pos" });
+      const filter = initConfigFilterFixed({ type: "fixed", name: "pos", defaultValue: "test" });
 
       expect(filter.type).toStrictEqual("fixed");
       expect(filter.id).toStrictEqual("pos");
       expect(filter.label()).toStrictEqual("Position");
       expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual("test");
     });
 
     test("id", () => {
-      const filter = initConfigFilterFixed({ type: "fixed", name: "id" });
+      const filter = initConfigFilterFixed({ type: "fixed", name: "id", defaultValue: "test" });
 
       expect(filter.type).toStrictEqual("fixed");
       expect(filter.id).toStrictEqual("id");
       expect(filter.label()).toStrictEqual("Identifiers");
       expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual("test");
     });
 
     test("ref", () => {
-      const filter = initConfigFilterFixed({ type: "fixed", name: "ref" });
+      const filter = initConfigFilterFixed({ type: "fixed", name: "ref", defaultValue: "test" });
 
       expect(filter.type).toStrictEqual("fixed");
       expect(filter.id).toStrictEqual("ref");
       expect(filter.label()).toStrictEqual("Reference");
       expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual("test");
     });
 
     test("alt", () => {
-      const filter = initConfigFilterFixed({ type: "fixed", name: "alt" });
+      const filter = initConfigFilterFixed({ type: "fixed", name: "alt", defaultValue: "test" });
 
       expect(filter.type).toStrictEqual("fixed");
       expect(filter.id).toStrictEqual("alt");
       expect(filter.label()).toStrictEqual("Alt");
       expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual("test");
     });
 
     test("qual", () => {
-      const filter = initConfigFilterFixed({ type: "fixed", name: "qual" });
+      const filter = initConfigFilterFixed({ type: "fixed", name: "qual", defaultValue: "test" });
 
       expect(filter.type).toStrictEqual("fixed");
       expect(filter.id).toStrictEqual("qual");
       expect(filter.label()).toStrictEqual("Quality");
       expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual("test");
     });
 
     test("filter", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "filter", defaultValue: "test" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("filter");
+      expect(filter.label()).toStrictEqual("Filter");
+      expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual("test");
+    });
+
+    test("filter without default", () => {
       const filter = initConfigFilterFixed({ type: "fixed", name: "filter" });
 
       expect(filter.type).toStrictEqual("fixed");
       expect(filter.id).toStrictEqual("filter");
       expect(filter.label()).toStrictEqual("Filter");
       expect(filter.description()).toStrictEqual(null);
+      expect(filter.defaultValue).toStrictEqual(undefined);
     });
 
     test("filter with custom label and description", () => {

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

@@ -8,9 +8,10 @@ import { createQuerySample } from "../../../src/utils/query/querySample.ts";
 import { createQueryFilters } from "../../../src/utils/query/queryFilter.ts";
 import { Query } from "@molgenis/vip-report-api";
 import { Config, ConfigFilters, ConfigVariants, ConfigVip, ConfigVipParams } from "../../../src/types/config";
-import { SampleContainer } from "../../../src/utils/api.ts";
+import { MetadataContainer, SampleContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
 import { VariantType } from "../../../src/utils/variantType.ts";
 import { ConfigFilterFixed } from "../../../src/types/configFilter";
+import { FieldMetadataWrapper } from "../../../src/utils/vcf.ts";
 
 describe("query", () => {
   vi.mock(import("../../../src/utils/query/queryFilter.ts"));
@@ -33,11 +34,20 @@ describe("query", () => {
       const queryVariantType: Query = { selector: "a", operator: "==", args: "b" };
       const querySample: Query = { selector: "c", operator: "==", args: "d" };
       const queryFilters: Query = { selector: "e", operator: "==", args: "f" };
+      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
       vi.mocked(createQueryVariantType).mockReturnValue(queryVariantType);
       vi.mocked(createQuerySample).mockReturnValue(querySample);
       vi.mocked(createQueryFilters).mockReturnValue(queryFilters);
 
-      expect(createQuery(config, variantType, sample, filterValues)).toStrictEqual({
+      expect(createQuery(config, meta, variantType, sample, filterValues)).toStrictEqual({
         args: [
           { selector: "a", operator: "==", args: "b" },
           { selector: "c", operator: "==", args: "d" },
@@ -46,28 +56,46 @@ describe("query", () => {
         operator: "and",
       });
       expect(createQueryVariantType).toHaveBeenCalledWith(variantType);
-      expect(createQuerySample).toHaveBeenCalledWith(configVip, sample);
+      expect(createQuerySample).toHaveBeenCalledWith(configVip, sample, meta);
       expect(createQueryFilters).toHaveBeenCalledWith(configFilters, filterValues);
     });
 
     test("sample", () => {
       const querySample: Query = { selector: "c", operator: "==", args: "d" };
+      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
       vi.mocked(createQueryVariantType).mockReturnValue(null);
       vi.mocked(createQuerySample).mockReturnValue(querySample);
       vi.mocked(createQueryFilters).mockReturnValue(null);
 
-      expect(createQuery(config, variantType, sample, filterValues)).toStrictEqual(querySample);
+      expect(createQuery(config, meta, variantType, sample, filterValues)).toStrictEqual(querySample);
       expect(createQueryVariantType).toHaveBeenCalledWith(variantType);
-      expect(createQuerySample).toHaveBeenCalledWith(configVip, sample);
+      expect(createQuerySample).toHaveBeenCalledWith(configVip, sample, meta);
       expect(createQueryFilters).toHaveBeenCalledWith(configFilters, filterValues);
     });
 
     test("variant type=null, sample=null and filters=null", () => {
       const variantType = { id: "all" } as VariantType;
+      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
       vi.mocked(createQueryVariantType).mockReturnValue(null);
       vi.mocked(createQueryFilters).mockReturnValue(null);
 
-      expect(createQuery(config, variantType, null, filterValues)).toStrictEqual(null);
+      expect(createQuery(config, meta, variantType, null, filterValues)).toStrictEqual(null);
       expect(createQueryVariantType).toHaveBeenCalledWith(variantType);
       expect(createQueryFilters).toHaveBeenCalledWith(configFilters, filterValues);
     });

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

@@ -175,7 +175,7 @@ describe("query filters", () => {
 
     test("multi_value=false nested_value=false args=single", () => {
       const value: FilterValueString = ["y"];
-      expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+      expect(createQueryFilterString(selector, value, false)).toStrictEqual({
         selector: ["x"],
         operator: "in",
         args: ["y"],
@@ -184,45 +184,18 @@ describe("query filters", () => {
 
     test("multi_value=false nested_value=false args=multi", () => {
       const value: FilterValueString = ["y", "z"];
-      expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+      expect(createQueryFilterString(selector, value, false)).toStrictEqual({
         selector: ["x"],
         operator: "in",
         args: ["y", "z"],
       });
     });
 
-    test("multi_value=true nested_value=false args=single", () => {
-      const value: FilterValueString = ["y"];
-      expect(createQueryFilterString(selector, value, true, false)).toStrictEqual({
-        selector: ["x"],
-        operator: "has_any",
-        args: ["y"],
-      });
-    });
-
-    test("multi_value=false nested_value=true args=single", () => {
-      const value: FilterValueString = ["y"];
-      expect(createQueryFilterString(selector, value, false, true)).toStrictEqual({
-        selector: ["x"],
-        operator: "has_any",
-        args: ["y"],
-      });
-    });
-
-    test("multi_value=true nested_value=true args=single", () => {
-      const value: FilterValueString = ["y"];
-      expect(createQueryFilterString(selector, value, true, true)).toStrictEqual({
-        selector: ["x"],
-        operator: "any_has_any",
-        args: ["y"],
-      });
-    });
-
     describe("categorical select null", () => {
       test("categorical __null", () => {
         const value: FilterValueString = ["__null"];
 
-        expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+        expect(createQueryFilterString(selector, value, false)).toStrictEqual({
           selector: ["x"],
           operator: "in",
           args: [null],
@@ -232,7 +205,7 @@ describe("query filters", () => {
       test("categorical category and __null", () => {
         const value: FilterValueString = ["c0", "__null"];
 
-        expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+        expect(createQueryFilterString(selector, value, false)).toStrictEqual({
           selector: ["x"],
           operator: "in",
           args: ["c0", null],

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

@@ -57,7 +57,7 @@ describe("query composed filters", () => {
           args: [query, queryPos],
           operator: "and",
         });
-        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false);
         expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["p"], { left: 1, right: 2 });
       });
 
@@ -72,7 +72,7 @@ describe("query composed filters", () => {
           args: [query, queryPos],
           operator: "and",
         });
-        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false);
         expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["p"], { left: 1, right: undefined });
       });
 
@@ -87,7 +87,7 @@ describe("query composed filters", () => {
           args: [query, queryPos],
           operator: "and",
         });
-        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false);
         expect(createQueryFilterClosedInterval).toHaveBeenCalledWith(["p"], { left: undefined, right: 2 });
       });
 
@@ -96,7 +96,7 @@ describe("query composed filters", () => {
         const value = { chromosome: "chr1" } as FilterValueLocus;
         vi.mocked(createQueryFilterString).mockReturnValue(query);
         expect(createQueryFilterComposed(config, value)).toStrictEqual(query);
-        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false, false);
+        expect(createQueryFilterString).toHaveBeenCalledWith(["c"], ["chr1"], false);
       });
     });
 
@@ -104,9 +104,9 @@ describe("query composed filters", () => {
       const config = {
         type: "composed",
         id: "composed/allelicImbalance",
-        sample: { item: { data: { index: 1 } } } as SampleContainer,
+        sample: { item: { id: 1, data: { index: 1 } } } as SampleContainer,
         viabField: { id: "VIAB" },
-        genotypeField: { id: "GT" },
+        genotypeField: { id: "GT_type" },
       } as ConfigFilterAllelicImbalance;
       const queryInterval: Query = { selector: "viab", operator: "==", args: "inside" };
       const queryIntervalClosed: Query = { selector: "viab", operator: "==", args: "outside" };
@@ -115,14 +115,14 @@ describe("query composed filters", () => {
         args: [
           {
             args: [
-              { selector: ["s", 1, "GT", "t"], operator: "in", args: ["hom_a", "hom_r"] },
+              { selector: ["s", 1, "GT_type"], operator: "in", args: ["HOM_ALT", "HOM_REF"] },
               { selector: "viab", operator: "==", args: "inside" },
             ],
             operator: "and",
           },
           {
             args: [
-              { selector: ["s", 1, "GT", "t"], operator: "==", args: "het" },
+              { selector: ["s", 1, "GT_type"], operator: "==", args: "HET" },
               { selector: "viab", operator: "==", args: "outside" },
             ],
             operator: "and",
@@ -146,14 +146,14 @@ describe("query composed filters", () => {
         args: [
           {
             args: [
-              { selector: ["s", 1, "GT", "t"], operator: "in", args: ["hom_a", "hom_r"] },
+              { selector: ["s", 1, "GT_type"], operator: "in", args: ["HOM_ALT", "HOM_REF"] },
               { selector: "viab", operator: "==", args: "outside" },
             ],
             operator: "and",
           },
           {
             args: [
-              { selector: ["s", 1, "GT", "t"], operator: "==", args: "het" },
+              { selector: ["s", 1, "GT_type"], operator: "==", args: "HET" },
               { selector: "viab", operator: "==", args: "inside" },
             ],
             operator: "and",
@@ -205,7 +205,7 @@ describe("query composed filters", () => {
       const config = {
         type: "composed",
         id: "composed/inheritanceMatch",
-        sample: { item: { data: { index: 1 } } } as SampleContainer,
+        sample: { item: { id: 1, data: { index: 1 } } } as SampleContainer,
         vimField: { id: "VIM" },
       } as ConfigFilterInheritanceMatch;
 
@@ -259,7 +259,7 @@ describe("query composed filters", () => {
       const config = {
         type: "composed",
         id: "composed/deNovo",
-        sample: { item: { data: { index: 1 } } } as SampleContainer,
+        sample: { item: { id: 1, data: { index: 1 } } } as SampleContainer,
         vidField: { id: "VID" },
       } as ConfigFilterDeNovo;
 
@@ -300,7 +300,7 @@ describe("query composed filters", () => {
     });
 
     test("vipCS", () => {
-      const sample = { item: { data: { index: 1 } } } as SampleContainer;
+      const sample = { item: { id: 1, 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;