@molgenis/vip-report-template 2.7.2 → 3.0.0-beta2

package/src/mocks/utils.ts

@@ -0,0 +1,16 @@
+export async function fetchAsBytes(url: string): Promise<Uint8Array> {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", url);
+    xhr.responseType = "arraybuffer";
+    xhr.onload = () => {
+      const status = xhr.status;
+      if (status === 200) {
+        resolve(new Uint8Array(xhr.response as ArrayBuffer));
+      } else {
+        reject(status);
+      }
+    };
+    xhr.send();
+  });
+}

package/src/store/index.tsx

@@ -0,0 +1,169 @@
+import { hashIntegration, Router } from "solid-app-router";
+import { Context, createContext, ParentComponent, useContext } from "solid-js";
+import { createStore } from "solid-js/store";
+import { Item, QueryClause, Sample, Selector, SortOrder } from "@molgenis/vip-report-api/src/Api";
+import { selectorKey } from "../utils/query";
+
+export type FilterQueries = { [key: string]: QueryClause | undefined };
+
+type AppStateVariants = {
+  page?: number;
+  pageSize?: number;
+  searchQuery?: string;
+  filterQueries?: FilterQueries;
+  sort?: SortOrder | null; // null: do not sort. undefined: sort undefined
+};
+
+export type AppState = {
+  variants?: AppStateVariants;
+  samples?: {
+    [key: number]: { variants: AppStateVariants };
+  };
+};
+
+export type AppActions = {
+  reset(): void;
+  setVariantsPage(page: number): void;
+  setVariantsPageSize(pageSize: number): void;
+  setVariantsSearchQuery(searchQuery: string): void;
+  clearVariantsSearchQuery(): void;
+  setVariantsFilterQuery(query: QueryClause): void;
+  clearVariantsFilterQuery(selector: Selector): void;
+  setVariantsSort(sort: SortOrder | null): void;
+  setSampleVariantsPage(sample: Item<Sample>, page: number): void;
+  setSampleVariantsPageSize(sample: Item<Sample>, pageSize: number): void;
+  setSampleVariantsSearchQuery(sample: Item<Sample>, searchQuery: string): void;
+  clearSampleVariantsSearchQuery(sample: Item<Sample>): void;
+  setSampleVariantsFilterQuery(sample: Item<Sample>, query: QueryClause): void;
+  clearSampleVariantsFilterQuery(sample: Item<Sample>, selector: Selector): void;
+  setSampleVariantsSort(sample: Item<Sample>, sort: SortOrder | null): void;
+};
+
+export type AppStore = [state: AppState, actions: AppActions];
+
+const defaultState: AppState = { variants: {}, samples: {} };
+
+const StoreContext = createContext<AppStore>() as Context<AppStore>;
+
+export const Provider: ParentComponent = (props) => {
+  const [state, setState] = createStore(defaultState);
+
+  function getVariants(sample: Item<Sample>) {
+    return state.samples ? state.samples[sample.id]?.variants || {} : {};
+  }
+
+  const actions: AppActions = {
+    reset() {
+      setState({ variants: undefined, samples: undefined });
+    },
+    setVariantsPage(page: number) {
+      setState({ variants: { ...(state.variants || {}), page } });
+    },
+    setVariantsPageSize(pageSize: number) {
+      setState({ variants: { ...(state.variants || {}), pageSize } });
+    },
+    setVariantsSearchQuery(searchQuery: string) {
+      setState({ variants: { ...(state.variants || {}), searchQuery } });
+    },
+    clearVariantsSearchQuery() {
+      setState({ variants: { ...(state.variants || {}), searchQuery: undefined } });
+    },
+    setVariantsFilterQuery(query: QueryClause) {
+      setState({
+        variants: {
+          ...(state.variants || {}),
+          filterQueries: { ...(state.variants?.filterQueries || {}), [selectorKey(query.selector)]: query },
+        },
+      });
+    },
+    clearVariantsFilterQuery(selector: Selector) {
+      setState({
+        variants: {
+          ...(state.variants || {}),
+          filterQueries: { ...(state.variants?.filterQueries || {}), [selectorKey(selector)]: undefined },
+        },
+      });
+    },
+    setVariantsSort(sort: SortOrder | null) {
+      setState({
+        variants: {
+          ...(state.variants || {}),
+          sort,
+        },
+      });
+    },
+    setSampleVariantsPage(sample: Item<Sample>, page: number) {
+      setState({ samples: { ...(state.samples || {}), [sample.id]: { variants: { ...getVariants(sample), page } } } });
+    },
+    setSampleVariantsPageSize(sample: Item<Sample>, pageSize: number) {
+      setState({
+        samples: {
+          ...(state.samples || {}),
+          [sample.id]: { variants: { ...getVariants(sample), pageSize, page: undefined } },
+        },
+      });
+    },
+    setSampleVariantsSearchQuery(sample: Item<Sample>, searchQuery: string) {
+      setState({
+        samples: {
+          ...(state.samples || {}),
+          [sample.id]: { variants: { ...getVariants(sample), searchQuery, page: undefined } },
+        },
+      });
+    },
+    clearSampleVariantsSearchQuery(sample: Item<Sample>) {
+      setState({
+        samples: {
+          ...(state.samples || {}),
+          [sample.id]: { variants: { ...getVariants(sample), searchQuery: undefined, page: undefined } },
+        },
+      });
+    },
+    setSampleVariantsFilterQuery(sample: Item<Sample>, query: QueryClause) {
+      const variants = getVariants(sample);
+      setState({
+        samples: {
+          ...(state.samples || {}),
+          [sample.id]: {
+            variants: {
+              ...variants,
+              filterQueries: { ...(variants.filterQueries || {}), [selectorKey(query.selector)]: query },
+              page: undefined,
+            },
+          },
+        },
+      });
+    },
+    clearSampleVariantsFilterQuery(sample: Item<Sample>, selector: Selector) {
+      const variants = getVariants(sample);
+      setState({
+        samples: {
+          ...(state.samples || {}),
+          [sample.id]: {
+            variants: {
+              ...getVariants(sample),
+              filterQueries: { ...(variants.filterQueries || {}), [selectorKey(selector)]: undefined },
+              page: undefined,
+            },
+          },
+        },
+      });
+    },
+    setSampleVariantsSort(sample: Item<Sample>, sort: SortOrder | null) {
+      setState({
+        samples: { ...(state.samples || {}), [sample.id]: { variants: { ...getVariants(sample), sort } } },
+      });
+    },
+  };
+  const store: AppStore = [state, actions];
+
+  return (
+    <Router source={hashIntegration()}>
+      <StoreContext.Provider value={store}>{props.children}</StoreContext.Provider>
+    </Router>
+  );
+};
+
+export function useStore() {
+  return useContext(StoreContext);
+}

package/src/utils/ApiUtils.ts

@@ -0,0 +1,253 @@
+import {
+  AppMetadata,
+  DecisionTree,
+  HtsFileMetadata,
+  Item,
+  LeafNode,
+  PagedItems,
+  Params,
+  Phenotype,
+  PhenotypicFeature,
+  Resource,
+  Sample,
+} from "@molgenis/vip-report-api/src/Api";
+import { Metadata, Record } from "@molgenis/vip-report-vcf/src/Vcf";
+import api from "../Api";
+import { Value } from "@molgenis/vip-report-vcf/src/ValueParser";
+import { FieldMetadata, NestedFieldMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
+import { isNumerical } from "./field";
+import { createRecordSort, Direction } from "./sortUtils";
+
+export const EMPTY_PARAMS: Params = {};
+
+function createEmptyPagedItems(): PagedItems<Resource> {
+  return {
+    page: { number: 0, size: 0, totalElements: 0 },
+    items: [],
+    total: 0,
+  };
+}
+
+export const EMPTY_RECORDS_PAGE = createEmptyPagedItems() as PagedItems<Record>;
+
+export const EMPTY_SAMPLES_PAGE = createEmptyPagedItems() as PagedItems<Sample>;
+
+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), acc), {});
+
+function getMostSevereConsequenceIndex(value: string[]) {
+  return value.map((consequence) => consequenceOrder[consequence]).reduce((max, value) => Math.max(max, value));
+}
+
+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;
+}
+
+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);
+}
+
+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;
+  }
+}
+
+export async function fetchRecords(params: Params) {
+  const [recordsMeta, records] = await Promise.all([api.getRecordsMeta(), api.getRecords(params)]);
+  if (recordsMeta.info.CSQ === undefined) {
+    return records;
+  }
+
+  const orders = createRecordSort(recordsMeta, params.sort).orders.filter(
+    (order) =>
+      order.field.parent?.id === "CSQ" &&
+      isNumerical(order.field) &&
+      order.field.number.type === "NUMBER" &&
+      order.field.number.count === 1
+  );
+
+  const fieldMetas = (recordsMeta.info.CSQ.nested as NestedFieldMetadata).items;
+  const consequenceIndex = fieldMetas.findIndex((item) => item.id === "Consequence");
+  const pickIndex = fieldMetas.findIndex((item) => item.id === "PICK");
+
+  for (const record of records.items) {
+    const csqArray = record.data.n.CSQ as Value[][];
+
+    csqArray.sort((aValue, bValue) => {
+      for (const order of orders) {
+        const compareValue = compareCsq(aValue, bValue, order.field, order.direction);
+        if (compareValue !== 0) return compareValue;
+      }
+      return compareCsqDefault(aValue, bValue, pickIndex, consequenceIndex);
+    });
+  }
+  return records;
+}
+
+export async function fetchRecordsMeta() {
+  return await api.getRecordsMeta();
+}
+
+export const EMPTY_RECORDS_METADATA: Metadata = {
+  lines: [],
+  info: {},
+  format: {},
+  samples: [],
+};
+
+export async function fetchDecisionTree() {
+  return await api.getDecisionTree();
+}
+
+export async function fetchSampleById(id: string) {
+  return await api.getSampleById(Number(id));
+}
+
+export async function fetchRecordById(id: string) {
+  return await api.getRecordById(Number(id));
+}
+
+export async function fetchSamples(params: Params) {
+  return await api.getSamples(params);
+}
+
+export async function fetchPhenotypes(params: Params) {
+  return await api.getPhenotypes(params);
+}
+
+export const EMPTY_PHENOTYPES = createEmptyPagedItems() as PagedItems<Phenotype>;
+
+export const EMPTY_DECISION_TREE: DecisionTree = {
+  rootNode: "root",
+  nodes: { root: { type: "LEAF", description: "x", class: "x" } as LeafNode },
+  labels: {},
+  files: {},
+};
+
+export async function fetchHtsFileMetadata() {
+  return await api.getHtsFileMetadata();
+}
+
+export async function fetchAppMetadata() {
+  return await api.getAppMetadata();
+}
+
+export const EMPTY_HTS_FILE_METADATA: HtsFileMetadata = {
+  htsFormat: "x",
+  uri: "x",
+  genomeAssembly: "x",
+};
+
+export const EMPTY_APP_METADATA: AppMetadata = {
+  name: "x",
+  version: "x",
+  args: "x",
+};
+
+export async function fetchPedigreeSamples(sample: Item<Sample>): Promise<PagedItems<Sample>> {
+  return await api.getSamples({
+    query: {
+      operator: "and",
+      args: [
+        { selector: ["person", "individualId"], operator: "!=", args: sample.data.person.individualId },
+        { selector: ["person", "familyId"], operator: "==", args: sample.data.person.familyId },
+      ],
+    },
+    size: Number.MAX_SAFE_INTEGER,
+  });
+}
+
+export async function fetchPhenotypicFeatures(sample: Item<Sample>): Promise<PhenotypicFeature[]> {
+  const phenotypes = await fetchPhenotypes({
+    query: { selector: ["subject", "id"], operator: "==", args: sample.data.person.individualId },
+    size: Number.MAX_SAFE_INTEGER,
+  });
+  return phenotypes.items.map((item) => item.data).flatMap((phenotype) => phenotype.phenotypicFeaturesList);
+}
+
+export function getRecordLabel(item: Item<Record>) {
+  const record = item.data;
+  return `${record.c}:${record.p} ${record.a.map((a) => `${record.r}>${a !== null ? a : "."}`).join(" / ")}`;
+}
+
+export const EMPTY_RECORD_ITEM: Item<Record> = {
+  id: -1,
+  data: { c: "", p: -1, i: [], r: "", a: [], q: null, f: [], n: {}, s: [] },
+};
+
+export const EMPTY_SAMPLE_ITEM: Item<Sample> = {
+  id: -1,
+  data: {
+    person: {
+      familyId: "",
+      individualId: "",
+      paternalId: "",
+      maternalId: "",
+      sex: "UNKNOWN_SEX",
+      affectedStatus: "MISSING",
+    },
+    index: -1,
+    proband: false,
+  },
+};

package/src/utils/decisionTreeUtils.ts

@@ -0,0 +1,14 @@
+import { Metadata, Record } from "@molgenis/vip-report-vcf/src/Vcf";
+import { Item } from "@molgenis/vip-report-api/src/Api";
+import { DecisionTreePath } from "../components/tree/DecisionTreePath";
+import { getSpecificConsequence } from "./viewUtils";
+import { ValueArray } from "@molgenis/vip-report-vcf/src/ValueParser";
+
+export function getDecisionTreePath(recordsMetadata: Metadata, variant: Item<Record>, csqId: number): DecisionTreePath {
+  if (recordsMetadata.info.CSQ.nested === undefined) {
+    throw new Error("Required nested VEP metadata is undefined.");
+  }
+  return getSpecificConsequence(variant.data.n.CSQ as ValueArray, csqId)[
+    recordsMetadata.info.CSQ.nested.items.findIndex((csq) => csq.id === "VIPP")
+  ] as DecisionTreePath;
+}

package/src/utils/field.ts

@@ -0,0 +1,49 @@
+import { FieldMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
+import { FieldMetadataContainer, InfoContainer } from "@molgenis/vip-report-vcf/src/VcfParser";
+import { Metadata } from "@molgenis/vip-report-vcf/src/Vcf";
+import { SortPath } from "@molgenis/vip-report-api/src/Api";
+
+const flattenFieldMetadataRec = (fieldMetadata: FieldMetadata): FieldMetadata[] => {
+  return fieldMetadata.nested ? fieldMetadata.nested.items.flatMap(flattenFieldMetadataRec) : [fieldMetadata];
+};
+
+export const flattenFieldMetadata = (fieldMetadataContainer: FieldMetadataContainer): FieldMetadata[] => {
+  return Object.values(fieldMetadataContainer).flatMap(flattenFieldMetadataRec);
+};
+
+export const isNumerical = (fieldMetadata: FieldMetadata): boolean => {
+  return fieldMetadata.type === "FLOAT" || fieldMetadata.type === "INTEGER";
+};
+
+export function getNestedInfoFieldsWithValues(infoFields: FieldMetadataContainer, infoValues: InfoContainer) {
+  return Object.values(infoFields).filter((infoField) => infoField.nested && infoValues[infoField.id] !== undefined);
+}
+
+export function abbreviateHeader(header: string) {
+  return header.length > 13 ? header.slice(0, 11) + "\u2026" : header;
+}
+
+class InvalidFieldPathError extends Error {
+  constructor(path: SortPath) {
+    super(`invalid path '[${path.join(", ")}]'`);
+    this.name = "InvalidFieldPathError";
+  }
+}
+
+export function findInfoField(recordsMetadata: Metadata, path: SortPath): FieldMetadata | undefined {
+  if (path.length < 2 || path[0] !== "n") throw new InvalidFieldPathError(path);
+
+  let field = recordsMetadata.info[path[1]];
+  if (field === undefined) throw new InvalidFieldPathError(path);
+
+  for (let i = 2; i < path.length; ++i) {
+    const fieldIndex = Number(path[i]);
+    if (!Number.isInteger(fieldIndex) || fieldIndex < 0) throw new InvalidFieldPathError(path);
+
+    const fieldItems = field.nested?.items;
+    if (fieldItems === undefined || fieldIndex >= fieldItems.length) throw new InvalidFieldPathError(path);
+
+    field = fieldItems[fieldIndex];
+  }
+  return field;
+}

package/src/utils/query.ts

@@ -0,0 +1,130 @@
+import {
+  Item,
+  Query,
+  QueryClause,
+  QueryOperator,
+  Sample,
+  Selector,
+  SelectorPart,
+  SortPath,
+} from "@molgenis/vip-report-api/src/Api";
+import { Metadata } from "@molgenis/vip-report-vcf/src/Vcf";
+import { FieldMetadata, InfoMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
+import { FilterQueries } from "../store";
+
+export function createQuery(
+  search: string | undefined,
+  filters: FilterQueries | undefined,
+  metadata: Metadata
+): Query | null {
+  let query: Query | null;
+
+  const searchQuery = search !== undefined ? createSearchQuery(search, metadata) : null;
+  const filterQuery = filters !== undefined ? createFilterQuery(filters) : null;
+  if (searchQuery !== null) {
+    query = filterQuery !== null ? { operator: "and", args: [searchQuery, filterQuery] } : searchQuery;
+  } else {
+    query = filterQuery !== null ? filterQuery : null;
+  }
+  return query;
+}
+
+export function createSearchQuery(search: string, metadata: Metadata): Query | null {
+  const parts: Query[] = [];
+  for (const infoKey in metadata.info) {
+    const infoMeta = metadata.info[infoKey];
+    parts.push(...createSearchQueryClausesInfo(search, infoMeta, ["n", infoMeta.id]));
+  }
+  return parts.length == 0 ? null : parts.length === 1 ? parts[0] : { operator: "or", args: parts };
+}
+
+function createSearchQueryClausesInfo(search: string, infoMetadata: InfoMetadata, selector: string[]): Query[] {
+  const clauses: Query[] = [];
+  if (infoMetadata.nested) {
+    for (let i = 0; i < infoMetadata.nested.items.length; ++i) {
+      clauses.push(
+        ...createSearchQueryClausesInfo(search, infoMetadata.nested.items[i], [...selector, "*", i.toString()])
+      );
+    }
+  } else {
+    switch (infoMetadata.type) {
+      case "CATEGORICAL":
+      case "CHARACTER":
+      case "STRING": {
+        const nested = selector.find((item) => item === "*") !== undefined;
+        let operator: QueryOperator, args;
+        if (infoMetadata.number.count && infoMetadata.number.count === 1) {
+          operator = nested ? "~=_any" : "~=";
+          args = nested ? [search] : search;
+        } else {
+          operator = nested ? "any_~=_any" : "~=_any";
+          args = [search];
+        }
+        clauses.push({ selector, operator, args });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return clauses;
+}
+
+function createFilterQuery(queries: FilterQueries): Query | null {
+  const queryClauses = Object.values(queries).filter((query) => query !== undefined) as QueryClause[];
+  if (queryClauses.length === 0) return null;
+  return queryClauses.length === 1 ? queryClauses[0] : { operator: "and", args: queryClauses };
+}
+
+export 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;
+}
+
+export function infoSelector(field: FieldMetadata) {
+  return ["n", ...selector(field)];
+}
+
+export function sampleSelector(sample: Item<Sample>, field: FieldMetadata) {
+  return ["s", sample.data.index, ...selector(field)];
+}
+
+export function selectorKey(selector: Selector): string {
+  return Array.isArray(selector) ? selector.join("/") : selector.toString();
+}
+
+export function infoFieldKey(field: FieldMetadata): string {
+  return selectorKey(infoSelector(field));
+}
+
+export function sampleFieldKey(sample: Item<Sample>, field: FieldMetadata): string {
+  return selectorKey(sampleSelector(sample, field));
+}
+
+function sortPath(field: FieldMetadata): SortPath {
+  return selector(field).filter((part) => part !== "*");
+}
+
+export function infoSortPath(field: FieldMetadata): SortPath {
+  return ["n", ...sortPath(field)];
+}

package/src/utils/sample.ts

@@ -0,0 +1,5 @@
+import { Item, Sample } from "@molgenis/vip-report-api/src/Api";
+
+export function getSampleLabel(sample: Item<Sample>) {
+  return sample.data.person.individualId;
+}