@molgenis/vip-report-template 6.2.0 → 7.0.0

package/src/utils/query/query.ts

@@ -0,0 +1,55 @@
+import { ComposedQueryOperator, Query } from "@molgenis/vip-report-api";
+import { FilterValueMap } from "../../types/configFilter";
+import { VariantType } from "../variantType.ts";
+
+import { Config } from "../../types/config";
+import { SampleContainer } from "../api.ts";
+import { createQueryFilters } from "./queryFilter.ts";
+import { createQueryVariantType } from "./queryVariantType.ts";
+import { createQuerySample } from "./querySample.ts";
+
+export function createQuery(
+  config: Config,
+  variantType: VariantType,
+  sample: SampleContainer | null,
+  filterValues: FilterValueMap,
+): Query | null {
+  const queryParts: Query[] = [];
+
+  const queryVariantType = createQueryVariantType(variantType);
+  if (queryVariantType !== null) {
+    queryParts.push(queryVariantType);
+  }
+
+  if (sample !== null) {
+    const querySample = createQuerySample(config.vip, sample);
+    queryParts.push(querySample);
+  }
+
+  const queryFilters = createQueryFilters(config.variants.filters, filterValues);
+  if (queryFilters !== null) {
+    queryParts.push(queryFilters);
+  }
+
+  return queryParts.length > 0 ? createQueryComposed(queryParts, "and") : null;
+}
+
+export function createQueryComposed(queryParts: Query[], operator: ComposedQueryOperator): Query {
+  const query: Query | null = createQueryComposedNullable(queryParts, operator);
+  if (query === null) {
+    throw new Error("query cannot be null");
+  }
+  return query;
+}
+
+export function createQueryComposedNullable(queryParts: Query[], operator: ComposedQueryOperator): Query | null {
+  let query: Query | null;
+  if (queryParts.length === 0) {
+    query = null;
+  } else if (queryParts.length === 1) {
+    query = queryParts[0]!;
+  } else {
+    query = { operator, args: queryParts }; // TODO simplify query is all query parts are composed queries with the same operator as the given operator
+  }
+  return query;
+}

package/src/utils/query/queryFilter.ts

@@ -0,0 +1,132 @@
+import {
+  ConfigFilter,
+  ConfigFilterField,
+  FilterValue,
+  FilterValueFixed,
+  FilterValueInterval,
+  FilterValueMap,
+  FilterValueString,
+} from "../../types/configFilter";
+import { Query, Selector } from "@molgenis/vip-report-api";
+import { createQueryFilterComposed } from "./queryFilterComposed.ts";
+import { ConfigFilterComposed } from "../../types/configFilterComposed";
+import { createQueryFilterFixed } from "./queryFilterFixed.ts";
+import { RuntimeError, UnexpectedEnumValueException } from "../error.ts";
+import { ConfigFilters } from "../../types/config";
+import { createQueryComposed, createQueryComposedNullable } from "./query.ts";
+import { createQueryFilterField } from "./queryFilterField.ts";
+
+/**
+ * Create API query for state of list of filters
+ *
+ * @param filterConfigs filter configurations
+ * @param filterValues filter values
+ */
+export function createQueryFilters(filterConfigs: ConfigFilters, filterValues: FilterValueMap): Query | null {
+  // TODO discuss: can we have id collisions between different types?
+  const queryParts = filterConfigs
+    .map((filter) => createQueryFilter(filter, filterValues[filter.id]!))
+    .filter((query) => query !== null);
+  return createQueryComposedNullable(queryParts, "and");
+}
+
+/**
+ * Create API query for state of one filter
+ *
+ * @param filterConfig filter configuration
+ * @param filterValue filter value
+ */
+function createQueryFilter(filterConfig: ConfigFilter, filterValue: FilterValue): Query | null {
+  let query: Query | null;
+  if (filterValue !== undefined) {
+    switch (filterConfig.type) {
+      case "composed":
+        query = createQueryFilterComposed(filterConfig as ConfigFilterComposed, filterValue);
+        break;
+      case "fixed":
+        query = createQueryFilterFixed(filterConfig, filterValue as FilterValueFixed);
+        break;
+      case "genotype":
+      case "info":
+        query = createQueryFilterField(filterConfig as ConfigFilterField, filterValue);
+        break;
+      default:
+        throw new UnexpectedEnumValueException(filterConfig.type);
+    }
+  } else {
+    query = null;
+  }
+  return query;
+}
+
+export function createQueryFilterString(
+  selector: Selector,
+  filterValue: FilterValueString,
+  multiValue: boolean,
+  nestedValue: boolean,
+): Query {
+  // null values
+  // multi=false --> value=null
+  // multi=true  --> value=[] or value=[..., null, ...]
+  const filterValues = filterValue.map((value) => (value !== "__null" ? value : null));
+
+  const queryParts: Query[] = [];
+  if (filterValues.length > 0) {
+    queryParts.push({
+      selector,
+      operator: nestedValue ? (multiValue ? "any_has_any" : "has_any") : multiValue ? "has_any" : "in",
+      args: filterValues,
+    });
+  }
+
+  if (multiValue && filterValues.findIndex((value) => value === null) !== -1) {
+    queryParts.push({
+      selector,
+      operator: nestedValue ? (multiValue ? "any_has_any" : "has_any") : "==",
+      args: multiValue ? [] : null,
+    });
+  }
+  return createQueryComposed(queryParts, "or");
+}
+
+export function createQueryFilterClosedInterval(selector: Selector, filterValue: FilterValueInterval): Query {
+  if (filterValue.left === undefined && filterValue.right === undefined) throw new RuntimeError();
+
+  const queryParts: Query[] = [];
+  if (filterValue.left !== undefined) {
+    queryParts.push({
+      selector,
+      operator: ">=",
+      args: filterValue.left,
+    });
+  }
+  if (filterValue.right !== undefined) {
+    queryParts.push({
+      selector,
+      operator: "<=",
+      args: filterValue.right,
+    });
+  }
+  return createQueryComposed(queryParts, "and");
+}
+
+export function createQueryFilterClosedIntervalOutside(selector: Selector, filterValue: FilterValueInterval): Query {
+  if (filterValue.left === undefined && filterValue.right === undefined) throw new RuntimeError();
+
+  const queryParts: Query[] = [];
+  if (filterValue.left !== undefined) {
+    queryParts.push({
+      selector,
+      operator: "<",
+      args: filterValue.left,
+    });
+  }
+  if (filterValue.right !== undefined) {
+    queryParts.push({
+      selector,
+      operator: ">",
+      args: filterValue.right,
+    });
+  }
+  return createQueryComposed(queryParts, "or");
+}

package/src/utils/query/queryFilterComposed.ts

@@ -0,0 +1,247 @@
+import {
+  ConfigFilterAllelicImbalance,
+  ConfigFilterComposed,
+  ConfigFilterDeNovo,
+  ConfigFilterHpo,
+  ConfigFilterInheritanceMatch,
+  ConfigFilterVipC,
+  ConfigFilterVipCS,
+  FilterValueAllelicImbalance,
+  FilterValueDeNovo,
+  FilterValueHpo,
+  FilterValueInheritanceMatch,
+  FilterValueLocus,
+  FilterValueVipC,
+  FilterValueVipCS,
+} from "../../types/configFilterComposed";
+import { FilterValue } from "../../types/configFilter";
+import { Query } from "@molgenis/vip-report-api";
+import { createQueryComposed } from "./query.ts";
+import { createSelectorInfo, createSelectorSample } from "./selector.ts";
+import {
+  createQueryFilterClosedInterval,
+  createQueryFilterClosedIntervalOutside,
+  createQueryFilterString,
+} from "./queryFilter.ts";
+import { createQueryFilterFieldCategorical } from "./queryFilterField.ts";
+
+export function createQueryFilterComposed(filter: ConfigFilterComposed, filterValue: FilterValue): Query {
+  let query: Query;
+  switch (filter.id) {
+    case "composed/hpo":
+      query = createQueryFilterHpo(filter as ConfigFilterHpo, filterValue as FilterValueHpo);
+      break;
+    case "composed/locus":
+      query = createQueryFilterLocus(filterValue as FilterValueLocus);
+      break;
+    case "composed/allelicImbalance":
+      query = createQueryFilterAllelicImbalance(
+        filter as ConfigFilterAllelicImbalance,
+        filterValue as FilterValueAllelicImbalance,
+      );
+      break;
+    case "composed/inheritanceMatch":
+      query = createQueryFilterInheritanceMatch(
+        filter as ConfigFilterInheritanceMatch,
+        filterValue as FilterValueInheritanceMatch,
+      );
+      break;
+    case "composed/deNovo":
+      query = createQueryFilterDeNovo(filter as ConfigFilterDeNovo, filterValue as FilterValueDeNovo);
+      break;
+    case "composed/vipC":
+      query = createQueryFilterVipC(filter as ConfigFilterVipC, filterValue as FilterValueVipC);
+      break;
+    case "composed/vipCS":
+      query = createQueryFilterVipCS(filter as ConfigFilterVipCS, filterValue as FilterValueVipCS);
+      break;
+    default:
+      throw new Error(`unexpected filter id '${filter.id}'`);
+  }
+  return query;
+}
+
+function createQueryFilterHpo(filter: ConfigFilterHpo, filterValue: FilterValueHpo): Query {
+  const field = filter.field;
+  const selector = createSelectorInfo(field);
+  return createQueryFilterFieldCategorical(selector, field, filterValue);
+}
+
+function createQueryFilterLocus(filterValue: FilterValueLocus): Query {
+  const queryParts: Query[] = [createQueryFilterString(["c"], [filterValue.chromosome], false, false)];
+
+  if (filterValue.start !== undefined || filterValue.end !== undefined) {
+    const posQuery = createQueryFilterClosedInterval(["p"], { left: filterValue.start, right: filterValue.end });
+    queryParts.push(posQuery);
+  }
+
+  return createQueryComposed(queryParts, "and");
+}
+
+function createQueryFilterAllelicImbalance(
+  filter: ConfigFilterAllelicImbalance,
+  filterValue: FilterValueAllelicImbalance,
+): Query {
+  const viabSelector = createSelectorSample(filter.sample, filter.viabField);
+  const gtSelector = [...createSelectorSample(filter.sample, filter.genotypeField), "t"];
+
+  const queryParts: Query[] = [];
+  if (filterValue.includes("true")) {
+    const queryPartsTrue: Query[] = [];
+    queryPartsTrue.push(
+      createQueryComposed(
+        [
+          {
+            operator: "in",
+            selector: gtSelector,
+            args: ["hom_a", "hom_r"],
+          },
+          createQueryFilterClosedInterval(viabSelector, { left: 0.02, right: 0.98 }),
+        ],
+        "and",
+      ),
+    );
+    queryPartsTrue.push(
+      createQueryComposed(
+        [
+          {
+            operator: "==",
+            selector: gtSelector,
+            args: "het",
+          },
+          createQueryFilterClosedIntervalOutside(viabSelector, { left: 0.2, right: 0.8 }),
+        ],
+        "and",
+      ),
+    );
+    queryParts.push(createQueryComposed(queryPartsTrue, "or"));
+  }
+  if (filterValue.includes("false")) {
+    const queryPartsFalse: Query[] = [];
+    queryPartsFalse.push(
+      createQueryComposed(
+        [
+          {
+            operator: "in",
+            selector: gtSelector,
+            args: ["hom_a", "hom_r"],
+          },
+          createQueryFilterClosedIntervalOutside(viabSelector, { left: 0.02, right: 0.98 }),
+        ],
+        "and",
+      ),
+    );
+    queryPartsFalse.push(
+      createQueryComposed(
+        [
+          {
+            operator: "==",
+            selector: gtSelector,
+            args: "het",
+          },
+          createQueryFilterClosedInterval(viabSelector, { left: 0.2, right: 0.8 }),
+        ],
+        "and",
+      ),
+    );
+    queryParts.push(createQueryComposed(queryPartsFalse, "or"));
+  }
+  if (filterValue.includes("__null")) {
+    const queryPartsUndefined: Query[] = [];
+    queryPartsUndefined.push({
+      selector: viabSelector,
+      operator: "==",
+      args: null,
+    });
+    queryPartsUndefined.push({
+      selector: viabSelector,
+      operator: "==",
+      args: undefined,
+    });
+    queryParts.push(createQueryComposed(queryPartsUndefined, "or"));
+  }
+  return createQueryComposed(queryParts, "or");
+}
+
+function createQueryFilterInheritanceMatch(
+  filter: ConfigFilterInheritanceMatch,
+  filterValue: FilterValueInheritanceMatch,
+): Query {
+  const vimSelector = createSelectorSample(filter.sample, filter.vimField);
+  const queryParts: Query[] = [];
+  if (filterValue.includes("true")) {
+    queryParts.push({
+      operator: "==",
+      selector: vimSelector,
+      args: 1,
+    });
+  }
+  if (filterValue.includes("false")) {
+    queryParts.push({
+      operator: "==",
+      selector: vimSelector,
+      args: 0,
+    });
+  }
+  if (filterValue.includes("potential")) {
+    const queryPartsUndefined: Query[] = [];
+    queryPartsUndefined.push({
+      selector: vimSelector,
+      operator: "==",
+      args: null,
+    });
+    queryPartsUndefined.push({
+      selector: vimSelector,
+      operator: "==",
+      args: undefined,
+    });
+    queryParts.push(createQueryComposed(queryPartsUndefined, "or"));
+  }
+  return createQueryComposed(queryParts, "and");
+}
+
+function createQueryFilterDeNovo(filter: ConfigFilterDeNovo, filterValue: FilterValueDeNovo): Query {
+  const vidSelector = createSelectorSample(filter.sample, filter.vidField);
+  const queryParts: Query[] = [];
+  if (filterValue.includes("true")) {
+    queryParts.push({
+      operator: "==",
+      selector: vidSelector,
+      args: 1,
+    });
+  }
+  if (filterValue.includes("false")) {
+    queryParts.push({
+      operator: "==",
+      selector: vidSelector,
+      args: 0,
+    });
+  }
+  if (filterValue.includes("potential")) {
+    const queryPartsUndefined: Query[] = [];
+    queryPartsUndefined.push({
+      selector: vidSelector,
+      operator: "==",
+      args: null,
+    });
+    queryPartsUndefined.push({
+      selector: vidSelector,
+      operator: "==",
+      args: undefined,
+    });
+    queryParts.push(createQueryComposed(queryPartsUndefined, "or"));
+  }
+  return createQueryComposed(queryParts, "and");
+}
+
+function createQueryFilterVipC(filter: ConfigFilterVipC, filterValue: FilterValueVipC): Query {
+  const field = filter.field;
+  const selector = createSelectorInfo(field);
+  return createQueryFilterFieldCategorical(selector, field, filterValue);
+}
+
+function createQueryFilterVipCS(filter: ConfigFilterVipCS, filterValue: FilterValueVipCS): Query {
+  const field = filter.field;
+  const selector = createSelectorSample(filter.sample, field);
+  return createQueryFilterFieldCategorical(selector, field, filterValue);
+}

package/src/utils/query/queryFilterField.ts

@@ -0,0 +1,75 @@
+import { Query, Selector, SelectorPart } from "@molgenis/vip-report-api";
+import { FieldMetadata } from "@molgenis/vip-report-vcf";
+import {
+  ConfigFilterField,
+  ConfigFilterFormat,
+  FilterValue,
+  FilterValueCategorical,
+  FilterValueInterval,
+  FilterValueString,
+} from "../../types/configFilter";
+import { UnexpectedEnumValueException } from "../error.ts";
+import { createSelectorInfo, createSelectorSample } from "./selector.ts";
+import { createQueryFilterClosedInterval, createQueryFilterString } from "./queryFilter.ts";
+
+export function createQueryFilterField(filter: ConfigFilterField, filterValue: FilterValue): Query {
+  const selector = createSelectorFilter(filter);
+  const field = filter.field;
+
+  let query: Query;
+  switch (filter.field.type) {
+    case "CATEGORICAL":
+      query = createQueryFilterFieldCategorical(selector, field, filterValue as FilterValueCategorical);
+      break;
+    case "CHARACTER":
+    case "STRING":
+      query = createQueryFilterFieldString(selector, field, filterValue as FilterValueString);
+      break;
+    case "FLOAT":
+    case "INTEGER":
+      query = createQueryFilterClosedInterval(selector, filterValue as FilterValueInterval);
+      break;
+    case "FLAG":
+      query = createQueryFilterFlag();
+      break;
+    default:
+      throw new UnexpectedEnumValueException(field.type);
+  }
+  return query;
+}
+
+function createSelectorFilter(filter: ConfigFilterField) {
+  let selector: SelectorPart[];
+  switch (filter.type) {
+    case "genotype":
+      selector = createSelectorSample((filter as ConfigFilterFormat).sample, filter.field);
+      break;
+    case "info":
+      selector = createSelectorInfo(filter.field);
+      break;
+    case "composed":
+    default:
+      throw new UnexpectedEnumValueException(filter.type);
+  }
+  return selector;
+}
+
+export function createQueryFilterFieldCategorical(
+  selector: Selector,
+  field: FieldMetadata,
+  filterValue: FilterValueCategorical,
+): Query {
+  const multiValue = field.number.count !== 1;
+  const nestedValue = field.parent !== undefined;
+  return createQueryFilterString(selector, filterValue, multiValue, nestedValue);
+}
+
+function createQueryFilterFlag(): Query {
+  throw new Error("not implemented"); // FIXME support flag filter queries
+}
+
+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);
+}

package/src/utils/query/queryFilterFixed.ts

@@ -0,0 +1,44 @@
+import {
+  ConfigFilterFixed,
+  FilterValueAlt,
+  FilterValueChrom,
+  FilterValueFilter,
+  FilterValueFixed,
+  FilterValueId,
+  FilterValuePos,
+  FilterValueQual,
+  FilterValueRef,
+} from "../../types/configFilter";
+import { Query } from "@molgenis/vip-report-api";
+import { UnexpectedEnumValueException } from "../error.ts";
+import { createQueryFilterClosedInterval, createQueryFilterString } from "./queryFilter.ts";
+
+export function createQueryFilterFixed(filter: ConfigFilterFixed, filterValue: FilterValueFixed): Query {
+  let query: Query;
+  switch (filter.id) {
+    case "fixed/chrom":
+      query = createQueryFilterString(["c"], filterValue as FilterValueChrom, false, false);
+      break;
+    case "fixed/pos":
+      query = createQueryFilterClosedInterval(["p"], filterValue as FilterValuePos);
+      break;
+    case "fixed/id":
+      query = createQueryFilterString(["i"], filterValue as FilterValueId, true, false);
+      break;
+    case "fixed/ref":
+      query = createQueryFilterString(["r"], filterValue as FilterValueRef, false, false);
+      break;
+    case "fixed/alt":
+      query = createQueryFilterString(["a"], filterValue as FilterValueAlt, true, false);
+      break;
+    case "fixed/qual":
+      query = createQueryFilterClosedInterval(["q"], filterValue as FilterValueQual);
+      break;
+    case "fixed/filter":
+      query = createQueryFilterString(["f"], filterValue as FilterValueFilter, true, false);
+      break;
+    default:
+      throw new UnexpectedEnumValueException(filter.id);
+  }
+  return query;
+}

package/src/utils/query/querySample.ts

@@ -0,0 +1,18 @@
+import { Query } from "@molgenis/vip-report-api";
+import { SampleContainer } from "../api.ts";
+import { createSelectorSample } from "./selector.ts";
+import { ConfigVip } from "../../types/config";
+import { FilterValueCategorical } from "../../types/configFilter";
+import { createQueryFilterFieldCategorical } from "./queryFilterField.ts";
+
+export function createQuerySample(config: ConfigVip, sample: SampleContainer): Query {
+  const filterValues = getFilterValues(config);
+  const selector = createSelectorSample(sample, config.filter_field);
+  return createQueryFilterFieldCategorical(selector, config.filter_field, filterValues);
+}
+
+function getFilterValues(config: ConfigVip): FilterValueCategorical {
+  const filterSamplesClasses = config.params.vcf.filter_samples.classes.split(",");
+  // add null values to make query match with records that do not have a value for the field
+  return [...filterSamplesClasses, "__null"];
+}

package/src/utils/query/queryVariantType.ts

@@ -0,0 +1,76 @@
+import { Query, SelectorPart } from "@molgenis/vip-report-api";
+import { VariantType } from "../variantType.ts";
+import { UnexpectedEnumValueException } from "../error.ts";
+import { createQueryComposed } from "./query.ts";
+
+export function createQueryVariantType(variantType: VariantType): Query | null {
+  let query: Query | null;
+  switch (variantType.id) {
+    case "all":
+      query = null;
+      break;
+    case "snv":
+      query = createQueryVariantTypeSnv();
+      break;
+    case "str":
+      query = createQueryVariantTypeStr();
+      break;
+    case "sv":
+      query = createQueryVariantTypeSv();
+      break;
+    default:
+      throw new UnexpectedEnumValueException(variantType.id);
+  }
+  return query;
+}
+
+function createQueryVariantTypeSnv(): Query {
+  const queryParts: Query[] = [
+    {
+      selector: createSelectorVariantType(),
+      operator: "==",
+      args: null,
+    },
+    {
+      selector: createSelectorVariantType(),
+      operator: "==",
+      args: undefined,
+    },
+  ];
+  return createQueryComposed(queryParts, "or");
+}
+
+function createQueryVariantTypeStr(): Query {
+  return {
+    selector: createSelectorVariantType(),
+    operator: "==",
+    args: "STR",
+  };
+}
+
+function createQueryVariantTypeSv(): Query {
+  return {
+    operator: "and",
+    args: [
+      {
+        selector: createSelectorVariantType(),
+        operator: "!=",
+        args: "STR",
+      },
+      {
+        selector: createSelectorVariantType(),
+        operator: "!=",
+        args: null,
+      },
+      {
+        selector: createSelectorVariantType(),
+        operator: "!=",
+        args: undefined,
+      },
+    ],
+  };
+}
+
+function createSelectorVariantType(): SelectorPart[] {
+  return ["n", "SVTYPE"];
+}

package/src/utils/query/selector.ts

@@ -0,0 +1,41 @@
+import { FieldMetadata } from "@molgenis/vip-report-vcf";
+import { Selector, SelectorPart, SortPath } from "@molgenis/vip-report-api";
+import { FieldMetadataWrapper } from "../vcf.ts";
+import { SampleContainer } from "../api.ts";
+
+export function createSelectorInfo(field: FieldMetadataWrapper): SelectorPart[] {
+  return ["n", ...selector(field)];
+}
+
+export function createSelectorSample(sample: SampleContainer, field: FieldMetadataWrapper): SelectorPart[] {
+  return ["s", sample.item.data.index, ...selector(field)];
+}
+
+export function createInfoSortPath(field: FieldMetadata): SortPath {
+  return ["n", ...selector(field).filter((part) => part !== "*")];
+}
+
+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();
+  return selector;
+}