@molgenis/vip-report-template 6.2.0 → 7.0.0

package/src/utils/config/configFilters.ts

@@ -0,0 +1,46 @@
+import { ConfigFilters, ConfigJsonFilter, ConfigVip } from "../../types/config";
+import { ConfigFilter } from "../../types/configFilter";
+import { initConfigFilterComposed } from "./configFiltersComposed.ts";
+import { MetadataContainer, SampleContainer } from "../api.ts";
+import { initConfigFilterFixed } from "./configFiltersFixed.ts";
+import { initConfigFiltersGenotype, initConfigFiltersInfo } from "./configFiltersField.ts";
+
+export function initConfigFilters(
+  config: ConfigJsonFilter[],
+  configVip: ConfigVip,
+  metadata: MetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilters {
+  return config.flatMap((config) => createConfigFilter(config, configVip, metadata, sample));
+}
+
+function createConfigFilter(
+  config: ConfigJsonFilter,
+  configVip: ConfigVip,
+  metadata: MetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilter[] {
+  let configFilters: (ConfigFilter | null)[];
+  switch (config.type) {
+    case "fixed":
+      configFilters = [initConfigFilterFixed(config)];
+      break;
+    case "info":
+      configFilters = initConfigFiltersInfo(config, metadata.records);
+      break;
+    case "format":
+      throw new Error(`unsupported config filter type '${config.type}'`); // not exposed by vip-report-api
+    case "genotype":
+      configFilters = sample ? initConfigFiltersGenotype(config, metadata.records, sample) : [];
+      break;
+    case "composed":
+      configFilters = [initConfigFilterComposed(config, configVip, metadata, sample)];
+      break;
+  }
+  return configFilters
+    .filter((configFilter) => configFilter !== null)
+    .map((config) => ({
+      ...config,
+      id: `${config.type}/${config.id}`, // prevent naming collisions for generic config filters
+    }));
+}

package/src/utils/config/configFiltersComposed.ts

@@ -0,0 +1,208 @@
+import {
+  ConfigFilterAllelicImbalance,
+  ConfigFilterComposed,
+  ConfigFilterDeNovo,
+  ConfigFilterHpo,
+  ConfigFilterInheritanceMatch,
+  ConfigFilterLocus,
+  ConfigFilterVipC,
+  ConfigFilterVipCS,
+} from "../../types/configFilterComposed";
+import { MetadataContainer, SampleContainer, VcfMetadataContainer } from "../api.ts";
+import { ConfigJsonFilterComposed, ConfigVip } from "../../types/config";
+import { getDescription, getLabel } from "./config.ts";
+import { getInfoNestedField, getSampleField, getSampleFields, parseContigIds } from "../vcf.ts";
+import { ConfigInvalidError } from "../error.ts";
+
+export function initConfigFilterComposed(
+  config: ConfigJsonFilterComposed,
+  configVip: ConfigVip,
+  metadata: MetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilterComposed | null {
+  const id = config.name;
+
+  let filter: ConfigFilterComposed | null;
+  switch (id) {
+    case "allelicImbalance":
+      filter = createConfigFilterAllelicImbalance(config, metadata.records, sample);
+      break;
+    case "deNovo":
+      filter = createConfigFilterDeNovo(config, metadata.records, sample);
+      break;
+    case "hpo":
+      filter = createConfigFilterHpo(config, metadata.records, sample);
+      break;
+    case "inheritanceMatch":
+      filter = createConfigFilterInheritanceMatch(config, metadata.records, sample);
+      break;
+    case "locus":
+      filter = createConfigFilterLocus(config, metadata);
+      break;
+    case "vipC":
+      filter = createConfigFilterVipC(config, configVip, metadata.records);
+      break;
+    case "vipCS":
+      filter = createConfigFilterVipCS(config, configVip, metadata.records, sample);
+      break;
+    default:
+      throw new ConfigInvalidError(`unknown composed filter name '${id}'`);
+  }
+  return filter;
+}
+
+function createConfigFilterHpo(
+  configStatic: ConfigJsonFilterComposed,
+  metadata: VcfMetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilterHpo | null {
+  if (sample === null || sample.phenotypes.length === 0) return null;
+  const fieldCsqHpo = getInfoNestedField(metadata, "CSQ", "HPO");
+  if (fieldCsqHpo === undefined) return null;
+
+  const filterField = {
+    // create field with categories based on the sample hpo terms
+    ...fieldCsqHpo,
+    categories: sample.phenotypes.reduce(
+      (acc, phenotype) => ({
+        ...acc,
+        [phenotype.type.id]: { label: phenotype.type.label },
+      }),
+      {},
+    ),
+  };
+
+  return {
+    type: "composed",
+    id: configStatic.name,
+    label: () => getLabel(configStatic, fieldCsqHpo.label || "HPO"),
+    description: () => getDescription(configStatic, filterField.description),
+    field: filterField,
+  };
+}
+
+function createConfigFilterLocus(
+  configStatic: ConfigJsonFilterComposed,
+  metadata: MetadataContainer,
+): ConfigFilterLocus {
+  return {
+    type: "composed",
+    id: configStatic.name,
+    label: () => getLabel(configStatic, "Locus"),
+    description: () => getDescription(configStatic),
+    chromosomes: parseContigIds(metadata.records),
+  };
+}
+
+function createConfigFilterAllelicImbalance(
+  configStatic: ConfigJsonFilterComposed,
+  metadata: VcfMetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilterAllelicImbalance | null {
+  if (sample === null) return null;
+  const [fieldViab, fieldGenotype] = getSampleFields(metadata, "VIAB", "GT");
+  if (fieldViab === undefined || fieldGenotype === undefined) return null;
+
+  return {
+    type: "composed",
+    id: configStatic.name,
+    label: () => getLabel(configStatic, fieldViab.label || "VIAB"),
+    description: () => getDescription(configStatic, fieldViab.description),
+    genotypeField: fieldGenotype,
+    viabField: fieldViab,
+    sample: sample,
+  };
+}
+
+function createConfigFilterInheritanceMatch(
+  configStatic: ConfigJsonFilterComposed,
+  metadata: VcfMetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilterInheritanceMatch | null {
+  if (sample === null) return null;
+  const vimField = getSampleField(metadata, "VIM");
+  if (vimField === undefined) return null;
+
+  return {
+    type: "composed",
+    id: configStatic.name,
+    label: () => getLabel(configStatic, vimField.label || "VIM"),
+    description: () => getDescription(configStatic, vimField.description),
+    vimField: { ...vimField, required: true },
+    sample: sample,
+  };
+}
+
+function createConfigFilterDeNovo(
+  configStatic: ConfigJsonFilterComposed,
+  metadata: VcfMetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilterDeNovo | null {
+  if (sample === null) return null;
+  const vidField = getSampleField(metadata, "VID");
+  if (vidField === undefined) return null;
+
+  return {
+    type: "composed",
+    id: configStatic.name,
+    label: () => configStatic.label || vidField.label || "VID",
+    description: () => configStatic.description || vidField.description || null,
+    vidField: { ...vidField, required: true },
+    sample: sample,
+  };
+}
+
+function createConfigFilterVipC(
+  configStatic: ConfigJsonFilterComposed,
+  configVip: ConfigVip,
+  metadata: VcfMetadataContainer,
+): ConfigFilterVipC | null {
+  if (!configVip.params.vcf.filter.consequences) return null;
+
+  const vipCField = getInfoNestedField(metadata, "CSQ", "VIPC");
+  if (vipCField === undefined) return null;
+
+  const categories = vipCField.categories;
+  if (categories === undefined) return null;
+
+  // exclude categories that were removed after filtering
+  const classSet = new Set(configVip.params.vcf.filter.classes.split(","));
+  const treeCategories = Object.fromEntries(Object.entries(categories).filter(([key]) => classSet.has(key)));
+  if (Object.keys(treeCategories).length <= 1) return null;
+
+  return {
+    type: "composed",
+    id: configStatic.name,
+    label: () => getLabel(configStatic, vipCField.label || "VIPC"),
+    description: () => getDescription(configStatic, vipCField.description),
+    field: { ...vipCField, categories: treeCategories },
+  };
+}
+
+function createConfigFilterVipCS(
+  configStatic: ConfigJsonFilterComposed,
+  configVip: ConfigVip,
+  metadata: VcfMetadataContainer,
+  sample: SampleContainer | null,
+): ConfigFilterVipCS | null {
+  if (sample === null || !sample.item.data.proband) return null;
+  const vipCSField = getSampleField(metadata, "VIPC_S");
+  if (vipCSField === undefined) return null;
+
+  const categories = vipCSField.categories;
+  if (categories === undefined) return null;
+
+  // exclude categories that were removed after filtering
+  const classSet = new Set(configVip.params.vcf.filter_samples.classes.split(","));
+  const treeCategories = Object.fromEntries(Object.entries(categories).filter(([key]) => classSet.has(key)));
+  if (Object.keys(treeCategories).length <= 1) return null;
+
+  return {
+    type: "composed",
+    id: configStatic.name,
+    label: () => getLabel(configStatic, vipCSField.label || "VIPC_S"),
+    description: () => getDescription(configStatic, vipCSField.description),
+    field: { ...vipCSField, categories: treeCategories, required: true },
+    sample,
+  };
+}

package/src/utils/config/configFiltersField.ts

@@ -0,0 +1,49 @@
+import { ConfigJsonFieldGenotype, ConfigJsonFieldInfo } from "../../types/config";
+import { ConfigFilterField, ConfigFilterFormat } from "../../types/configFilter";
+import { SampleContainer, VcfMetadataContainer } from "../api.ts";
+import { FieldMetadataWrapper, getInfoFieldsRegex, getSampleFieldsRegex } from "../vcf.ts";
+import { getDescription, getLabel } from "./config.ts";
+
+function createConfigFilterGenotype(
+  config: ConfigJsonFieldGenotype,
+  field: FieldMetadataWrapper,
+  sample: SampleContainer,
+): ConfigFilterFormat {
+  return {
+    type: "genotype",
+    id: config.name,
+    label: () => getLabel(config, field.label || field.id),
+    description: () => getDescription(config, field.description),
+    field,
+    sample,
+  };
+}
+
+export function initConfigFiltersGenotype(
+  config: ConfigJsonFieldGenotype,
+  metadata: VcfMetadataContainer,
+  sample: SampleContainer,
+): ConfigFilterFormat[] {
+  return getSampleFieldsRegex(metadata, new RegExp(`^${config.name}$`))
+    .filter((field) => !field.nested)
+    .map((field) => createConfigFilterGenotype(config, field, sample));
+}
+
+function createConfigFilterInfo(config: ConfigJsonFieldInfo, field: FieldMetadataWrapper): ConfigFilterField {
+  return {
+    type: "info",
+    id: field.id,
+    label: () => getLabel(config, field.label || field.id),
+    description: () => getDescription(config, field.description),
+    field,
+  };
+}
+
+export function initConfigFiltersInfo(
+  config: ConfigJsonFieldInfo,
+  metadata: VcfMetadataContainer,
+): ConfigFilterField[] {
+  return getInfoFieldsRegex(metadata, new RegExp(`^${config.name}$`))
+    .filter((field) => !field.nested)
+    .map((field) => createConfigFilterInfo(config, field));
+}

package/src/utils/config/configFiltersFixed.ts

@@ -0,0 +1,106 @@
+import { ConfigJsonFilterFixed } from "../../types/config";
+import {
+  ConfigFilterAlt,
+  ConfigFilterChrom,
+  ConfigFilterFilter,
+  ConfigFilterFixed,
+  ConfigFilterId,
+  ConfigFilterPos,
+  ConfigFilterQual,
+  ConfigFilterRef,
+} from "../../types/configFilter";
+import { UnexpectedEnumValueException } from "../error.ts";
+import { getDescription, getLabel } from "./config.ts";
+
+export function initConfigFilterFixed(config: ConfigJsonFilterFixed): ConfigFilterFixed {
+  let configFilter: ConfigFilterFixed;
+  switch (config.name) {
+    case "chrom":
+      configFilter = createConfigFilterChrom(config);
+      break;
+    case "pos":
+      configFilter = createConfigFilterPos(config);
+      break;
+    case "id":
+      configFilter = createConfigFilterId(config);
+      break;
+    case "ref":
+      configFilter = createConfigFilterRef(config);
+      break;
+    case "alt":
+      configFilter = createConfigFilterAlt(config);
+      break;
+    case "qual":
+      configFilter = createConfigFilterQual(config);
+      break;
+    case "filter":
+      configFilter = createConfigFilterFilter(config);
+      break;
+    default:
+      throw new UnexpectedEnumValueException(config["name"]);
+  }
+  return configFilter;
+}
+
+function createConfigFilterChrom(config: ConfigJsonFilterFixed): ConfigFilterChrom {
+  return {
+    type: "fixed",
+    id: "chrom",
+    label: () => getLabel(config, "Chromosome"),
+    description: () => getDescription(config),
+  };
+}
+
+function createConfigFilterPos(config: ConfigJsonFilterFixed): ConfigFilterPos {
+  return {
+    type: "fixed",
+    id: "pos",
+    label: () => getLabel(config, "Position"),
+    description: () => getDescription(config),
+  };
+}
+
+function createConfigFilterId(config: ConfigJsonFilterFixed): ConfigFilterId {
+  return {
+    type: "fixed",
+    id: "id",
+    label: () => getLabel(config, "Identifiers"),
+    description: () => getDescription(config),
+  };
+}
+
+function createConfigFilterRef(config: ConfigJsonFilterFixed): ConfigFilterRef {
+  return {
+    type: "fixed",
+    id: "ref",
+    label: () => getLabel(config, "Reference"),
+    description: () => getDescription(config),
+  };
+}
+
+function createConfigFilterAlt(config: ConfigJsonFilterFixed): ConfigFilterAlt {
+  return {
+    type: "fixed",
+    id: "alt",
+    label: () => getLabel(config, "Alt"),
+    description: () => getDescription(config),
+  };
+}
+
+function createConfigFilterQual(config: ConfigJsonFilterFixed): ConfigFilterQual {
+  return {
+    type: "fixed",
+    id: "qual",
+    label: () => getLabel(config, "Quality"),
+    description: () => getDescription(config),
+  };
+}
+
+function createConfigFilterFilter(config: ConfigJsonFilterFixed): ConfigFilterFilter {
+  return {
+    type: "fixed",
+    id: "filter",
+    label: () => getLabel(config, "Filter"),
+    description: () => getDescription(config),
+  };
+}

package/src/utils/config/configSorts.ts

@@ -0,0 +1,44 @@
+import { ConfigJsonFieldInfo, ConfigJsonSort, ConfigJsonSortOrder } from "../../types/config";
+import { ConfigSort, ConfigSortOrder, ConfigSorts } from "../../types/configSort";
+import { MetadataContainer, VcfMetadataContainer } from "../api.ts";
+import { getInfoField } from "../vcf.ts";
+
+export function initConfigSorts(configs: ConfigJsonSort[], metadata: MetadataContainer): ConfigSorts {
+  return configs
+    .flatMap((configStaticSort) => createConfigSort(configStaticSort, metadata.records))
+    .filter((configSort) => configSort !== null);
+}
+
+function createConfigSortOrders(config: ConfigJsonSort, metadata: VcfMetadataContainer): ConfigSortOrder[] {
+  const configSortOrders = config.orders.map((order) => createConfigSortOrder(order, metadata));
+  return configSortOrders.filter((configSortOrder) => configSortOrder !== null);
+}
+
+function createConfigSort(config: ConfigJsonSort, metadata: VcfMetadataContainer): ConfigSort | null {
+  const orders = createConfigSortOrders(config, metadata);
+  return orders.length !== 0 ? { selected: config.selected, orders } : null;
+}
+
+function createConfigSortOrder(order: ConfigJsonSortOrder, metadata: VcfMetadataContainer) {
+  let configSortOrder: ConfigSortOrder | null;
+  switch (order.field.type) {
+    case "info":
+      configSortOrder = createConfigSortOrderInfo(order, metadata);
+      break;
+    case "fixed":
+    case "genotype":
+    case "composed":
+    case "format":
+      throw new Error(`unsupported config filter type '${order.field.type}'`); // not exposed by vip-report-api
+  }
+  return configSortOrder;
+}
+
+function createConfigSortOrderInfo(
+  configStatic: ConfigJsonSortOrder,
+  metadata: VcfMetadataContainer,
+): ConfigSortOrder | null {
+  const configField: ConfigJsonFieldInfo = configStatic.field as ConfigJsonFieldInfo;
+  const field = getInfoField(metadata, configField.name);
+  return field !== undefined ? { direction: configStatic.direction, field: field } : null;
+}