@molgenis/vip-report-template 6.1.1 → 7.0.0

package/src/utils/config/configValidator.ts

@@ -0,0 +1,380 @@
+import Ajv, { JTDSchemaType } from "ajv/dist/jtd";
+import { Json } from "@molgenis/vip-report-api";
+import { ConfigValidationError } from "../error.ts";
+import {
+  ConfigJson,
+  ConfigJsonField,
+  ConfigJsonFilter,
+  ConfigJsonRecordsPerPageOption,
+  ConfigJsonSort,
+  ConfigJsonSortOrder,
+  ConfigJsonVariant,
+  ConfigJsonVariantConsequence,
+  ConfigJsonVariants,
+  ConfigJsonVip,
+  ConfigJsonVipParams,
+  ConfigJsonVipParamsCram,
+  ConfigJsonVipParamsVcf,
+} from "../../types/config";
+
+const ajv = new Ajv();
+
+// allow additional properties so we can extend config in vip without updating vip-report-template
+const schemaConfigJsonVipParamsVcf: JTDSchemaType<ConfigJsonVipParamsVcf> = {
+  properties: {
+    filter: {
+      properties: { classes: { type: "string" }, consequences: { type: "boolean" } },
+      additionalProperties: true,
+    },
+    filter_samples: {
+      properties: { classes: { type: "string" } },
+      additionalProperties: true,
+    },
+  },
+  additionalProperties: true,
+};
+
+// allow additional properties so we can extend config in vip without updating vip-report-template
+const schemaConfigJsonVipParamsCram: JTDSchemaType<ConfigJsonVipParamsCram> = {
+  properties: {
+    call_snv: { type: "boolean" },
+    call_str: { type: "boolean" },
+    call_sv: { type: "boolean" },
+    call_cnv: { type: "boolean" },
+  },
+  additionalProperties: true,
+};
+
+// allow additional properties so we can extend config in vip without updating vip-report-template
+const schemaConfigJsonVipParams: JTDSchemaType<ConfigJsonVipParams> = {
+  properties: {
+    vcf: schemaConfigJsonVipParamsVcf,
+  },
+  optionalProperties: {
+    cram: schemaConfigJsonVipParamsCram,
+  },
+  additionalProperties: true,
+};
+
+const schemaConfigJsonVip: JTDSchemaType<ConfigJsonVip> = {
+  properties: {
+    filter_field: {
+      properties: { type: { enum: ["genotype"] }, name: { type: "string" } },
+      optionalProperties: { label: { type: "string" }, description: { type: "string" } },
+    },
+    params: schemaConfigJsonVipParams,
+  },
+};
+
+const schemaConfigJsonField: JTDSchemaType<ConfigJsonField> = {
+  discriminator: "type",
+  mapping: {
+    fixed: {
+      properties: {
+        name: { enum: ["chrom", "pos", "id", "ref", "alt", "qual", "filter"] },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    info: {
+      properties: {
+        name: { type: "string" },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    format: {
+      properties: {
+        name: { type: "string" },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    genotype: {
+      properties: {
+        name: { type: "string" },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    composed: {
+      properties: {
+        name: {
+          enum: [
+            "clinVar",
+            "gene",
+            "genotype",
+            "genotype_maternal",
+            "genotype_paternal",
+            "gnomAdAf",
+            "hpo",
+            "inheritancePattern",
+            "locus",
+            "vipC",
+            "vipCS",
+            "vkgl",
+          ],
+        },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    group: {
+      // TODO deduplicate code, see mappings listed above
+      properties: {
+        fields: {
+          elements: {
+            discriminator: "type",
+            mapping: {
+              fixed: {
+                properties: {
+                  name: { enum: ["chrom", "pos", "id", "ref", "alt", "qual", "filter"] },
+                },
+                optionalProperties: {
+                  label: { type: "string" },
+                  description: { type: "string" },
+                },
+              },
+              info: {
+                properties: {
+                  name: { type: "string" },
+                },
+                optionalProperties: {
+                  label: { type: "string" },
+                  description: { type: "string" },
+                },
+              },
+              format: {
+                properties: {
+                  name: { type: "string" },
+                },
+                optionalProperties: {
+                  label: { type: "string" },
+                  description: { type: "string" },
+                },
+              },
+              genotype: {
+                properties: {
+                  name: { type: "string" },
+                },
+                optionalProperties: {
+                  label: { type: "string" },
+                  description: { type: "string" },
+                },
+              },
+              composed: {
+                properties: {
+                  name: {
+                    enum: [
+                      "clinVar",
+                      "gene",
+                      "genotype",
+                      "gnomAdAf",
+                      "hpo",
+                      "inheritancePattern",
+                      "locus",
+                      "ref",
+                      "vipC",
+                      "vipCS",
+                      "vkgl",
+                    ],
+                  },
+                },
+                optionalProperties: {
+                  label: { type: "string" },
+                  description: { type: "string" },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+const schemaConfigJsonFilter: JTDSchemaType<ConfigJsonFilter> = {
+  discriminator: "type",
+  mapping: {
+    fixed: {
+      properties: {
+        name: { enum: ["chrom", "pos", "id", "ref", "alt", "qual", "filter"] },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    info: {
+      properties: {
+        name: { type: "string" },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    format: {
+      properties: {
+        name: { type: "string" },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    genotype: {
+      properties: {
+        name: { type: "string" },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+    composed: {
+      properties: {
+        name: {
+          enum: ["allelicImbalance", "deNovo", "hpo", "inheritanceMatch", "locus", "vipC", "vipCS"],
+        },
+      },
+      optionalProperties: {
+        label: { type: "string" },
+        description: { type: "string" },
+      },
+    },
+  },
+};
+
+const schemaConfigJsonSortOrder: JTDSchemaType<ConfigJsonSortOrder> = {
+  properties: {
+    direction: { enum: ["asc", "desc"] },
+    field: schemaConfigJsonField,
+  },
+};
+
+const schemaConfigJsonSort: JTDSchemaType<ConfigJsonSort> = {
+  properties: {
+    selected: { type: "boolean" },
+    orders: {
+      elements: schemaConfigJsonSortOrder,
+    },
+  },
+};
+
+const schemaConfigJsonRecordsPerPageOption: JTDSchemaType<ConfigJsonRecordsPerPageOption> = {
+  properties: {
+    number: { type: "uint16" },
+  },
+  optionalProperties: {
+    selected: { type: "boolean" },
+  },
+};
+
+const schemaConfigJsonVariants: JTDSchemaType<ConfigJsonVariants> = {
+  properties: {
+    cells: {
+      optionalProperties: {
+        all: { elements: schemaConfigJsonField },
+        snv: { elements: schemaConfigJsonField },
+        str: { elements: schemaConfigJsonField },
+        sv: { elements: schemaConfigJsonField },
+      },
+    },
+  },
+  optionalProperties: {
+    filters: {
+      optionalProperties: {
+        all: { elements: schemaConfigJsonFilter },
+        snv: { elements: schemaConfigJsonFilter },
+        str: { elements: schemaConfigJsonFilter },
+        sv: { elements: schemaConfigJsonFilter },
+      },
+    },
+    sorts: {
+      optionalProperties: {
+        all: { elements: schemaConfigJsonSort },
+        snv: { elements: schemaConfigJsonSort },
+        str: { elements: schemaConfigJsonSort },
+        sv: { elements: schemaConfigJsonSort },
+      },
+    },
+    recordsPerPage: {
+      optionalProperties: {
+        all: { elements: schemaConfigJsonRecordsPerPageOption },
+        snv: { elements: schemaConfigJsonRecordsPerPageOption },
+        str: { elements: schemaConfigJsonRecordsPerPageOption },
+        sv: { elements: schemaConfigJsonRecordsPerPageOption },
+      },
+    },
+  },
+};
+
+const schemaConfigJsonVariant: JTDSchemaType<ConfigJsonVariant> = {
+  properties: {
+    cells: {
+      optionalProperties: {
+        all: { elements: schemaConfigJsonField },
+        snv: { elements: schemaConfigJsonField },
+        str: { elements: schemaConfigJsonField },
+        sv: { elements: schemaConfigJsonField },
+      },
+    },
+  },
+  optionalProperties: {
+    sample_cells: {
+      optionalProperties: {
+        all: { elements: schemaConfigJsonField },
+        snv: { elements: schemaConfigJsonField },
+        str: { elements: schemaConfigJsonField },
+        sv: { elements: schemaConfigJsonField },
+      },
+    },
+  },
+};
+
+const schemaConfigJsonVariantConsequence: JTDSchemaType<ConfigJsonVariantConsequence> = {
+  optionalProperties: {
+    sample_cells: {
+      optionalProperties: {
+        all: { elements: schemaConfigJsonField },
+        snv: { elements: schemaConfigJsonField },
+        str: { elements: schemaConfigJsonField },
+        sv: { elements: schemaConfigJsonField },
+      },
+    },
+  },
+};
+
+const schema: JTDSchemaType<ConfigJson> = {
+  properties: {
+    vip: schemaConfigJsonVip,
+    sample_variants: schemaConfigJsonVariants,
+    variants: schemaConfigJsonVariants,
+    sample_variant: schemaConfigJsonVariant,
+    variant: schemaConfigJsonVariant,
+    sample_variant_consequence: schemaConfigJsonVariantConsequence,
+    variant_consequence: schemaConfigJsonVariantConsequence,
+  },
+};
+
+const validate = ajv.compile(schema);
+
+export function validateConfig(json: Json): ConfigJson {
+  const valid = validate(json);
+  if (valid) {
+    return json; // json is 'ConfigStatic' here
+  } else {
+    throw new ConfigValidationError(validate);
+  }
+}

package/src/utils/config/configVip.ts

@@ -0,0 +1,25 @@
+import { ConfigJsonVip, ConfigVip } from "../../types/config";
+import { MetadataContainer } from "../api.ts";
+import { getSampleField } from "../vcf.ts";
+import { ConfigInvalidPropertyValueError } from "../error.ts";
+
+export function initConfigVip(config: ConfigJsonVip, metadata: MetadataContainer): ConfigVip {
+  const filterField = config.filter_field;
+  const fieldMetadata = getSampleField(metadata.records, filterField.name);
+
+  if (fieldMetadata === undefined) {
+    throw new ConfigInvalidPropertyValueError(
+      "vip.filter_field.name",
+      filterField.name,
+      "does not exist in vcf metadata",
+    );
+  } else if (fieldMetadata.type !== "CATEGORICAL") {
+    throw new ConfigInvalidPropertyValueError(
+      "vip.filter_field.name",
+      filterField.name,
+      `is of type ${fieldMetadata.type} instead of CATEGORICAL`,
+    );
+  }
+
+  return { filter_field: fieldMetadata, params: config.params };
+}

package/src/utils/csq.ts

@@ -0,0 +1,115 @@
+import { FieldMetadata, NestedFieldMetadata, Value } from "@molgenis/vip-report-vcf";
+import { Direction } from "./query/sort.ts";
+
+function is(infoMeta: FieldMetadata, id: string) {
+  return infoMeta.id === id;
+}
+
+function isCsq(infoMeta: FieldMetadata) {
+  return infoMeta.parent?.id === "CSQ";
+}
+
+export function isCsqInfo(infoMeta: FieldMetadata, id: string) {
+  return isCsq(infoMeta) && is(infoMeta, id);
+}
+
+export function isAnyCsqInfo(infoMeta: FieldMetadata, ids: string[]) {
+  return isCsq(infoMeta) && ids.some((id) => is(infoMeta, id));
+}
+
+const consequenceOrder = [
+  "transcript_ablation",
+  "splice_acceptor_variant",
+  "splice_donor_variant",
+  "splice_donor_5th_base_variant",
+  "splice_donor_region_variant",
+  "splice_polypyrimidine_tract_variant",
+  "stop_gained",
+  "frameshift_variant",
+  "stop_lost",
+  "start_lost",
+  "transcript_amplification",
+  "inframe_insertion",
+  "inframe_deletion",
+  "missense_variant",
+  "protein_altering_variant",
+  "splice_region_variant",
+  "incomplete_terminal_codon_variant",
+  "start_retained_variant",
+  "stop_retained_variant",
+  "synonymous_variant",
+  "coding_sequence_variant",
+  "mature_miRNA_variant",
+  "5_prime_UTR_variant",
+  "3_prime_UTR_variant",
+  "non_coding_transcript_exon_variant",
+  "intron_variant",
+  "NMD_transcript_variant",
+  "non_coding_transcript_variant",
+  "upstream_gene_variant",
+  "downstream_gene_variant",
+  "TFBS_ablation",
+  "TFBS_amplification",
+  "TF_binding_site_variant",
+  "regulatory_region_ablation",
+  "regulatory_region_amplification",
+  "feature_elongation",
+  "regulatory_region_variant",
+  "feature_truncation",
+  "intergenic_variant",
+].reduce((acc: { [key: string]: number }, curr, currIndex) => {
+  acc[curr] = currIndex;
+  return acc;
+}, {});
+
+function getMostSevereConsequenceIndex(value: string[]) {
+  const filteredMappedIndices = value
+    .map((consequence) => consequenceOrder[consequence])
+    .filter((value) => value !== undefined);
+  return filteredMappedIndices.length != 0 ? filteredMappedIndices.reduce((max, value) => Math.max(max, value)) : 0;
+}
+
+function compareCsqValue(aValue: number | null, bValue: number | null, direction: string): number {
+  if (aValue === null) return bValue === null ? 0 : 1;
+  if (bValue === null) return -1;
+  return direction === "desc" ? bValue - aValue : aValue - bValue;
+}
+
+export function compareCsq(
+  aValueArray: Value[],
+  bValueArray: Value[],
+  field: FieldMetadata,
+  direction: Direction,
+): number {
+  const parentField = field.parent as FieldMetadata;
+  const parentItems = (parentField.nested as NestedFieldMetadata).items;
+
+  const index = parentItems.findIndex((item) => item.id === field.id);
+  if (index === -1) {
+    throw new Error(`unknown field '${field.id}'`);
+  }
+
+  const aValue = aValueArray[index] as number | null;
+  const bValue = bValueArray[index] as number | null;
+  return compareCsqValue(aValue, bValue, direction);
+}
+
+export function compareCsqDefault(
+  aValue: Value[],
+  bValue: Value[],
+  pickIndex: number,
+  consequenceIndex: number,
+): number {
+  if (pickIndex !== -1) {
+    if (aValue[pickIndex] === "1") return bValue[pickIndex] === null ? -1 : 0;
+    if (bValue[pickIndex] === "1") return 1;
+  }
+
+  if (consequenceIndex !== -1) {
+    const aIndex = getMostSevereConsequenceIndex(aValue[consequenceIndex] as string[]);
+    const bIndex = getMostSevereConsequenceIndex(bValue[consequenceIndex] as string[]);
+    return aIndex - bIndex;
+  } else {
+    return 0;
+  }
+}

package/src/utils/decisionTree.ts

@@ -0,0 +1,45 @@
+import { VcfRecord } from "@molgenis/vip-report-vcf";
+import { Item } from "@molgenis/vip-report-api";
+import { DecisionTreePath } from "../components/tree/DecisionTreePath";
+
+import { getInfoNestedField, getInfoValue, getSampleField, getSampleValue } from "./vcf.ts";
+import { SampleContainer, VcfMetadataContainer } from "./api.ts";
+import { RuntimeError } from "./error.ts";
+
+export function getDecisionTreePath(
+  metadata: VcfMetadataContainer,
+  variant: Item<VcfRecord>,
+  csqId: number,
+): DecisionTreePath {
+  let decisionTreePath: DecisionTreePath;
+  const fieldMetadata = getInfoNestedField(metadata, "CSQ", "VIPP");
+  if (fieldMetadata) {
+    const value = getInfoValue(variant, csqId, fieldMetadata);
+    if (value === undefined) throw new RuntimeError("required value must not be undefined");
+    decisionTreePath = value as DecisionTreePath;
+  } else {
+    decisionTreePath = [];
+  }
+  return decisionTreePath;
+}
+
+export function getSampleTreePath(
+  metadata: VcfMetadataContainer,
+  sample: SampleContainer,
+  variant: Item<VcfRecord>,
+  csqId: number,
+): DecisionTreePath {
+  let decisionTreePath: DecisionTreePath;
+  const fieldMetadata = getSampleField(metadata, "VIPP_S");
+  if (fieldMetadata) {
+    const value = getSampleValue(sample, variant, -1, fieldMetadata); // TODO replace with getSampleNestedValue once VIPP_S metadata is nested
+    if (value === undefined) throw new RuntimeError("required value must not be undefined");
+    if (!Array.isArray(value)) throw new RuntimeError();
+    const valueArray = value as string[];
+    if (valueArray.length <= csqId) throw new RuntimeError();
+    decisionTreePath = valueArray[csqId]!.split("&") as DecisionTreePath;
+  } else {
+    decisionTreePath = [];
+  }
+  return decisionTreePath;
+}

package/src/utils/download.ts

@@ -0,0 +1,30 @@
+import { HtsFileMetadata } from "@molgenis/vip-report-api";
+
+export function createVcfDownloadFilename(htsFileMetadata: HtsFileMetadata) {
+  return (
+    (htsFileMetadata.uri.split("\\").pop()?.split("/").pop()?.split(".").shift() || "unknown") +
+    "_report_" +
+    getDateTimeString() +
+    ".vcf"
+  );
+}
+
+// derived from https://stackoverflow.com/a/19176102
+function getDateTimeString() {
+  const now = new Date();
+
+  const year = now.getFullYear().toString();
+  let month = (now.getMonth() + 1).toString();
+  let day = now.getDate().toString();
+  let hour = now.getHours().toString();
+  let minute = now.getMinutes().toString();
+  let second = now.getSeconds().toString();
+
+  if (month.length == 1) month = "0" + month;
+  if (day.length == 1) day = "0" + day;
+  if (hour.length == 1) hour = "0" + hour;
+  if (minute.length == 1) minute = "0" + minute;
+  if (second.length == 1) second = "0" + second;
+
+  return year + month + day + "_" + hour + minute + second;
+}

package/src/utils/error.ts

@@ -0,0 +1,69 @@
+import { ValidateFunction } from "ajv";
+import { SortPath } from "@molgenis/vip-report-api";
+
+export class ArrayIndexOutOfBoundsException extends Error {
+  constructor() {
+    super();
+    this.name = "ArrayIndexOutOfBoundsException";
+  }
+}
+
+export class UnexpectedEnumValueException extends Error {
+  constructor(enumValue: string) {
+    super(enumValue);
+    this.name = "UnexpectedEnumValueException";
+  }
+}
+
+export class InvalidIdException extends Error {
+  constructor(id: string | undefined) {
+    super(id);
+    this.name = "InvalidIdException";
+  }
+}
+
+export class InvalidVcfError extends Error {
+  constructor() {
+    super();
+    this.name = "InvalidVcfException";
+  }
+}
+
+/**
+ * programming error
+ */
+export class RuntimeError extends Error {
+  constructor(message?: string) {
+    super(message);
+    this.name = "RuntimeError";
+  }
+}
+
+export class ConfigValidationError extends Error {
+  constructor(validate: ValidateFunction) {
+    super("config invalid");
+    this.name = "ConfigValidationError";
+    console.error("validation errors", validate.errors);
+  }
+}
+
+export class ConfigInvalidError extends Error {
+  constructor(message?: string) {
+    super("config invalid" + (message ? `: ${message}` : ""));
+    this.name = "ConfigInvalidError";
+  }
+}
+
+export class ConfigInvalidPropertyValueError extends ConfigInvalidError {
+  constructor(property: string, value: string, message: string) {
+    super(`property '${property}' value '${value}' ${message}`);
+    this.name = "ConfigInvalidError";
+  }
+}
+
+export class InvalidSortPathError extends Error {
+  constructor(path: SortPath) {
+    super(`invalid record sort path '[${path.join(",")}]'`);
+    this.name = "InvalidSortPathError";
+  }
+}