@molgenis/vip-report-template 6.1.1 → 7.0.0

package/src/types/configCells.d.ts

@@ -0,0 +1,129 @@
+import { FieldMetadata, InfoMetadata, RecordSampleType, VcfRecord } from "@molgenis/vip-report-vcf";
+import { Item } from "@molgenis/vip-report-api";
+import { CellValueCustom } from "./configCellComposed";
+import { FieldValue } from "../utils/vcf.ts";
+
+export type CellId = string;
+export type CellType =
+  | "chrom"
+  | "pos"
+  | "id"
+  | "ref"
+  | "alt"
+  | "qual"
+  | "filter"
+  | "info"
+  | "format"
+  | "genotype"
+  | "composed";
+
+interface ConfigCellBase<T extends CellValue> {
+  type: CellType;
+  label: () => string;
+  description: () => string | null;
+  value: (record: Item<VcfRecord>, valueIndex: number) => T;
+  valueCount: (record: Item<VcfRecord>) => number;
+}
+
+export type CellValueChrom = string;
+
+export interface ConfigCellChrom extends ConfigCellBase<CellValueChrom> {
+  type: "chrom";
+}
+
+export type CellValuePos = number;
+
+export interface ConfigCellPos extends ConfigCellBase<CellValuePos> {
+  type: "pos";
+}
+
+export type CellValueId = string[];
+
+export interface ConfigCellId extends ConfigCellBase<CellValueId> {
+  type: "id";
+}
+
+export type CellValueRef = string;
+
+export interface ConfigCellRef extends ConfigCellBase<CellValueRef> {
+  type: "ref";
+}
+
+export type CellValueAlt = (string | null)[];
+
+export interface ConfigCellAlt extends ConfigCellBase<CellValueAlt> {
+  type: "alt";
+}
+
+export type CellValueQual = number | null;
+
+export interface ConfigCellQual extends ConfigCellBase<CellValueQual> {
+  type: "qual";
+}
+
+export type CellValueFilter = string[];
+
+export interface ConfigCellFilter extends ConfigCellBase<string[]> {
+  type: "filter";
+}
+
+export type ConfigCellFixed =
+  | ConfigCellChrom
+  | ConfigCellPos
+  | ConfigCellId
+  | ConfigCellRef
+  | ConfigCellAlt
+  | ConfigCellQual
+  | ConfigCellFilter;
+
+export type CellValueInfo = FieldValue | undefined;
+
+export interface ConfigCellInfo extends ConfigCellBase<CellValueInfo> {
+  type: "info";
+  field: InfoMetadata;
+}
+
+export type CellValueFormat = string[];
+
+export interface ConfigCellFormat extends ConfigCellBase<CellValueFormat> {
+  type: "format";
+}
+
+export type CellValueGenotype = RecordSampleType | undefined;
+
+export interface ConfigCellGenotype extends ConfigCellBase<CellValueGenotype> {
+  type: "genotype";
+  field: FieldMetadata;
+}
+
+interface ConfigCellCustom<T extends CellValueCustom> extends ConfigCellBase<T> {
+  type: "composed";
+  id: CellId;
+}
+
+export type ConfigCellItem =
+  | ConfigCellFixed
+  | ConfigCellFormat
+  | ConfigCellInfo
+  | ConfigCellGenotype
+  | ConfigCellCustom<CellValueCustom>;
+
+export interface ConfigCellGroup {
+  type: "group";
+  fieldConfigs: ConfigCellItem[];
+}
+
+export type ConfigCell = ConfigCellItem | ConfigCellGroup;
+
+export type CellValueFixed =
+  | CellValueChrom
+  | CellValuePos
+  | CellValueId
+  | CellValueRef
+  | CellValueAlt
+  | CellValueQual
+  | CellValueFilter;
+
+export type CellValue = CellValueFixed | CellValueFormat | CellValueInfo | CellValueGenotype | CellValueCustom;
+
+// note: add composed field to configCellComposed.d.ts

package/src/types/configFilter.d.ts

@@ -0,0 +1,80 @@
+import { ConfigFilterComposed, FilterValueComposed } from "./configFilterComposed";
+import { SampleContainer } from "../utils/api.ts";
+import { FieldMetadataWrapper } from "../utils/vcf.ts";
+
+export type FilterId = string;
+export type FilterType = "fixed" | "info" | "genotype" | "composed";
+export type FilterCategoryId = string;
+export type FilterCategory = {
+  id: FilterCategoryId;
+  label: string;
+  count?: number;
+};
+
+export type FilterValueCategorical = FilterCategoryId[];
+export type FilterValueString = string[];
+export type ValueNumber = number | undefined;
+export type FilterValueFlag = FilterValueCategorical;
+export type FilterValueInterval = { left: ValueNumber; right: ValueNumber };
+
+export type FilterValueChrom = FilterValueString;
+export type FilterValuePos = FilterValueInterval;
+export type FilterValueId = FilterValueString;
+export type FilterValueRef = FilterValueString;
+export type FilterValueAlt = FilterValueString;
+export type FilterValueQual = FilterValueInterval;
+export type FilterValueFilter = FilterValueString;
+
+export type FilterValueFixed =
+  | FilterValueChrom
+  | FilterValuePos
+  | FilterValueId
+  | FilterValueRef
+  | FilterValueAlt
+  | FilterValueQual
+  | FilterValueFilter;
+
+export type FilterValueField = FilterValueCategorical | FilterValueString | FilterValueInterval;
+
+export type FilterValue = FilterValueFixed | FilterValueField | FilterValueComposed;
+export type FilterValueMap = { [key: FilterId]: FilterValue };
+
+export type ConfigFilterFixed =
+  | ConfigFilterChrom
+  | ConfigFilterPos
+  | ConfigFilterId
+  | ConfigFilterRef
+  | ConfigFilterAlt
+  | ConfigFilterQual
+  | ConfigFilterFilter;
+
+export type ConfigFilter =
+  | ConfigFilterFixed
+  | ConfigFilterComposed
+  | ConfigFilterField // TODO rename to ConfigFilterInfo?
+  | ConfigFilterFormat; // TODO rename to ConfigFilterGenotype
+
+export interface ConfigFilterBase {
+  type: FilterType;
+  id: FilterId;
+  label: () => string;
+  description: () => string | null;
+}
+
+export type ConfigFilterChrom = ConfigFilterBase;
+export type ConfigFilterPos = ConfigFilterBase;
+export type ConfigFilterId = ConfigFilterBase;
+export type ConfigFilterRef = ConfigFilterBase;
+export type ConfigFilterAlt = ConfigFilterBase;
+export type ConfigFilterQual = ConfigFilterBase;
+export type ConfigFilterFilter = ConfigFilterBase;
+
+export interface ConfigFilterField extends ConfigFilterBase {
+  field: FieldMetadataWrapper;
+}
+
+export interface ConfigFilterFormat extends ConfigFilterField {
+  sample: SampleContainer;
+}
+
+// note: add composed filters to configFilterComposed.d.ts

package/src/types/configFilterComposed.d.ts

@@ -0,0 +1,60 @@
+import {
+  ConfigFilterBase,
+  ConfigFilterField,
+  ConfigFilterFormat,
+  FilterValueCategorical,
+  FilterValueFlag,
+} from "./configFilter";
+import { SampleContainer } from "../utils/api.ts";
+import { FieldMetadataWrapper } from "../utils/vcf.ts";
+
+export type ChromosomeId = string;
+export type FilterValueHpo = FilterValueCategorical;
+export type FilterValueLocus = { chromosome: ChromosomeId; start?: number; end?: number };
+export type FilterValueVipC = FilterValueCategorical;
+export type FilterValueVipCS = FilterValueCategorical;
+export type FilterValueAllelicImbalance = FilterValueFlag;
+export type FilterValueInheritanceMatch = FilterValueFlag;
+export type FilterValueDeNovo = FilterValueFlag;
+
+export type ConfigFilterComposed =
+  | ConfigFilterHpo
+  | ConfigFilterLocus
+  | ConfigFilterAllelicImbalance
+  | ConfigFilterInheritanceMatch
+  | ConfigFilterDeNovo
+  | ConfigFilterVipC
+  | ConfigFilterVipCS;
+
+export type ConfigFilterHpo = ConfigFilterField;
+
+export interface ConfigFilterAllelicImbalance extends ConfigFilterBase {
+  sample: SampleContainer;
+  viabField: FieldMetadataWrapper;
+  genotypeField: FieldMetadataWrapper;
+}
+
+export interface ConfigFilterInheritanceMatch extends ConfigFilterBase {
+  sample: SampleContainer;
+  vimField: FieldMetadataWrapper;
+}
+
+export interface ConfigFilterDeNovo extends ConfigFilterBase {
+  sample: SampleContainer;
+  vidField: FieldMetadataWrapper;
+}
+
+export type ConfigFilterVipC = ConfigFilterField;
+export type ConfigFilterVipCS = ConfigFilterFormat;
+
+export interface ConfigFilterLocus extends ConfigFilterBase {
+  chromosomes: ChromosomeId[];
+}
+
+export type FilterValueComposed =
+  | FilterValueHpo
+  | FilterValueLocus
+  | FilterValueAllelicImbalance
+  | FilterValueInheritanceMatch
+  | FilterValueVipC
+  | FilterValueVipCS;

package/src/types/configSort.d.ts

@@ -0,0 +1,13 @@
+import { FieldMetadata } from "@molgenis/vip-report-vcf";
+
+export interface ConfigSort {
+  selected: boolean | undefined;
+  orders: ConfigSortOrder[];
+}
+
+export interface ConfigSortOrder {
+  direction: "desc" | "asc";
+  field: FieldMetadata;
+}
+
+export type ConfigSorts = ConfigSort[];

package/src/types/filter.d.ts

@@ -0,0 +1,17 @@
+import { FilterId, FilterValue } from "./configFilter";
+
+export type FilterValueMap = { [key: FilterId]: FilterValue };
+
+export interface FilterValueChangeEvent<FilterValueType> {
+  value: FilterValueType;
+}
+
+export interface FilterChangeEvent extends FilterValueChangeEvent<FilterValue> {
+  id: FilterId;
+}
+
+export type FilterChangeCallback = (event: FilterChangeEvent) => void;
+export type FilterClearEvent = {
+  id: FilterId;
+};
+export type FilterClearCallback = (event: FilterClearEvent) => void;

package/src/types/store.d.ts

@@ -0,0 +1,34 @@
+import { SetStoreFunction } from "solid-js/store";
+import { VariantTypeId } from "../utils/variantType.ts";
+import { SortOrder } from "@molgenis/vip-report-api";
+import { FilterValueMap } from "./filter";
+
+export type Page = { number: number; size?: number };
+export type Sort = SortOrder | SortOrder[];
+export type AppStateVariantType = {
+  filterValues?: FilterValueMap;
+  page?: Page;
+  /**
+   * null:      do not sort,                the caller of this function should not fall back to a default sort
+   * undefined: sort behavior is undefined, the caller of this function could fall back to a default sort
+   */
+  sort?: Sort | null;
+};
+export type AppStateVariantTypes = Partial<Record<VariantTypeId, AppStateVariantType>>;
+type AppStateSamples = {
+  page?: number;
+  searchQuery?: string;
+  probandFilterValue?: boolean;
+};
+export type AppState = {
+  variants: AppStateVariantTypes;
+  sampleVariants: Record<string, AppStateVariantTypes>;
+  samples: AppStateSamples;
+};
+export type AppActions = {
+  reset(): void;
+  setSamplePage(page: number): void;
+  setSampleSearchQuery(searchQuery: string): void;
+  setSampleProbandFilterValue(probandFilterValue: boolean): void;
+};
+export type AppStore = [state: AppState, actions: AppActions, setState: SetStoreFunction<AppState>];

package/src/utils/api.ts

@@ -0,0 +1,281 @@
+import {
+  AppMetadata,
+  Cram,
+  DecisionTree,
+  HtsFileMetadata,
+  Item,
+  Json,
+  PagedItems,
+  Params,
+  PhenotypicFeature,
+  Query,
+  Sample,
+  WindowApiClient,
+} from "@molgenis/vip-report-api";
+import { isSampleFather, isSampleMother } from "./sample.ts";
+import { NestedFieldMetadata, Value, VcfMetadata, VcfRecord } from "@molgenis/vip-report-vcf";
+import { createRecordSort } from "./query/sort.ts";
+import { createFieldMap, FieldMap, isNumerical } from "./vcf.ts";
+import { compareCsq, compareCsqDefault } from "./csq.ts";
+import { VariantTypeId } from "./variantType.ts";
+import { MockApiClient } from "../mocks/MockApiClient.ts";
+import { ConfigJson } from "../types/config";
+import { RuntimeError } from "./error.ts";
+import { validateConfig } from "./config/configValidator.ts";
+
+export type VcfMetadataContainer = VcfMetadata & {
+  fieldMap: FieldMap;
+};
+/**
+ * Expose aggregate metadata container for convenience
+ */
+export type MetadataContainer = {
+  app: AppMetadata;
+  htsFile: HtsFileMetadata;
+  records: VcfMetadataContainer;
+  variantTypeIds: Set<VariantTypeId>;
+};
+
+/**
+ * Expose aggregate sample container for convenience
+ */
+export type SampleContainer = {
+  item: Item<Sample>;
+  paternalSample: Item<Sample> | null;
+  maternalSample: Item<Sample> | null;
+  phenotypes: PhenotypicFeature[];
+  otherPedigreeSamples: Item<Sample>[];
+  variantTypeIds: Set<VariantTypeId>;
+};
+
+// lazy import MockApiClient to ensure that it is excluded from the build artifact
+const api = import.meta.env.PROD
+  ? new WindowApiClient()
+  : await (async () => {
+      const module = await import("../mocks/MockApiClient.ts");
+      return new module.MockApiClient();
+    })();
+
+export async function fetchConfig(): Promise<ConfigJson> {
+  console.log("Api.fetchConfig");
+  const config: Json = await api.getConfig();
+  if (config === null) throw new RuntimeError("no config provided");
+  return validateConfig(config);
+}
+
+export async function fetchDecisionTree(): Promise<DecisionTree | null> {
+  console.log("Api.fetchDecisionTree");
+  return await api.getDecisionTree();
+}
+
+export async function fetchSampleTree(): Promise<DecisionTree | null> {
+  console.log("Api.fetchSampleTree");
+  return await api.getSampleTree();
+}
+
+export async function fetchSamples(params: Params): Promise<PagedItems<SampleContainer>> {
+  console.log("Api.fetchSamples", JSON.stringify(params));
+  const samplePagedItems = await api.getSamples(params);
+  const samples = await Promise.all(samplePagedItems.items.map((sample) => fetchSampleContainer(sample)));
+  return {
+    page: samplePagedItems.page,
+    total: samplePagedItems.total,
+    items: samples.map((sample) => ({ id: sample.item.id, data: sample })),
+  };
+}
+
+/**
+ * Fetch metadata composed of app metadata, high throughput sequencing file metadata and records metadata
+ */
+export async function fetchMetadata(): Promise<MetadataContainer> {
+  console.log("Api.fetchMetadata");
+  const [appMetadata, htsFileMetadata, recordsMetadata, variantTypeIds] = await Promise.all([
+    api.getAppMetadata(),
+    api.getHtsFileMetadata(),
+    api.getRecordsMeta(),
+    fetchVariantTypeIdsQuery(),
+  ]);
+
+  // precompute field map
+  const fieldMap = createFieldMap(recordsMetadata);
+
+  return { app: appMetadata, htsFile: htsFileMetadata, records: { ...recordsMetadata, fieldMap }, variantTypeIds };
+}
+
+/**
+ * Fetch sample composed of sample, pedigree samples and phenotypic features
+ */
+export async function fetchSampleById(sampleId: number): Promise<SampleContainer> {
+  console.log("Api.fetchSampleById", sampleId);
+  const sample = await api.getSampleById(sampleId);
+
+  const [pedigreeSamples, phenotypicFeatures, variantTypeIds] = await Promise.all([
+    fetchPedigreeSamples(sample),
+    fetchPhenotypicFeatures(sample),
+    fetchVariantTypeIdsQuery(),
+  ]);
+
+  return composeSample(sample, phenotypicFeatures, pedigreeSamples, variantTypeIds);
+}
+
+export async function fetchRecordById(id: number): Promise<Item<VcfRecord>> {
+  console.log("Api.fetchRecordById", id);
+  return api.getRecordById(id);
+}
+
+export async function fetchRecords(params: Params): Promise<PagedItems<VcfRecord>> {
+  console.log("Api.fetchRecords", JSON.stringify(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[][] | undefined;
+    if (csqArray) {
+      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 fetchSampleProbandIds(): Promise<number[]> {
+  console.log("Api.fetchSampleProbandIds");
+  const query: Query = { selector: ["proband"], operator: "==", args: true };
+  const samplePagedItems = await api.getSamples({ query, page: 0, size: Number.MAX_SAFE_INTEGER });
+  return samplePagedItems.items.map((sampleItem) => sampleItem.id);
+}
+
+export async function fetchFastaGz(contig: string, pos: number): Promise<Uint8Array | null> {
+  console.log("Api.fetchFastaGz", contig, pos);
+  return api.getFastaGz(contig, pos);
+}
+
+export async function fetchGenesGz(): Promise<Uint8Array | null> {
+  console.log("Api.fetchGenesGz");
+  return api.getGenesGz();
+}
+
+export async function fetchCram(sampleId: string): Promise<Cram | null> {
+  console.log("Api.fetchCram", sampleId);
+  return api.getCram(sampleId);
+}
+
+async function fetchSampleContainer(sample: Item<Sample>): Promise<SampleContainer> {
+  const [pedigreeSamples, phenotypicFeatures, variantTypeIds] = await Promise.all([
+    fetchPedigreeSamples(sample),
+    fetchPhenotypicFeatures(sample),
+    fetchVariantTypeIdsQuery(),
+  ]);
+
+  return composeSample(sample, phenotypicFeatures, pedigreeSamples, variantTypeIds);
+}
+
+/**
+ * Compose sample from API sample, API sample phenotypes and API pedigree samples data
+ *
+ * @param sample API sample
+ * @param samplePhenotypes API sample phenotypes
+ * @param pedigreeSamples API samples from same pedigree
+ * @param variantTypeIds variant types available for this sample
+ */
+export function composeSample(
+  sample: Item<Sample>,
+  samplePhenotypes?: PhenotypicFeature[],
+  pedigreeSamples?: PagedItems<Sample>,
+  variantTypeIds?: Set<VariantTypeId>,
+): SampleContainer {
+  let paternalSample: Item<Sample> | null = null;
+  let maternalSample: Item<Sample> | null = null;
+  const otherPedigreeSamples: Item<Sample>[] = [];
+
+  pedigreeSamples?.items.forEach((pedigreeSample) => {
+    if (isSampleFather(sample.data, pedigreeSample.data)) {
+      paternalSample = pedigreeSample;
+    } else if (isSampleMother(sample.data, pedigreeSample.data)) {
+      maternalSample = pedigreeSample;
+    } else {
+      otherPedigreeSamples.push(pedigreeSample);
+    }
+  });
+
+  return {
+    item: sample,
+    paternalSample,
+    maternalSample,
+    phenotypes: samplePhenotypes || [],
+    otherPedigreeSamples,
+    variantTypeIds: variantTypeIds || new Set<VariantTypeId>(),
+  };
+}
+
+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,
+  });
+}
+
+async function fetchPhenotypicFeatures(sample: Item<Sample>): Promise<PhenotypicFeature[]> {
+  const phenotypes = await api.getPhenotypes({
+    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);
+}
+
+async function fetchVariantTypeIdsQuery(): Promise<Set<VariantTypeId>> {
+  const config: ConfigJson = await fetchConfig();
+
+  const variantTypeIds = new Set<VariantTypeId>();
+  const params = config.vip.params.cram;
+  if (params) {
+    if (params.call_snv) variantTypeIds.add("snv");
+    if (params.call_str) variantTypeIds.add("str");
+    if (params.call_sv || params.call_cnv) variantTypeIds.add("sv");
+  } else {
+    variantTypeIds.add("snv");
+    variantTypeIds.add("str");
+    variantTypeIds.add("sv");
+  }
+  return variantTypeIds;
+}
+
+// development
+export function isDatasetSupport(): boolean {
+  return !import.meta.env.PROD;
+}
+
+export function getDatasetIds(): string[] {
+  if (import.meta.env.PROD) throw new Error("unsupported");
+  return (api as MockApiClient).getDatasetIds();
+}
+
+export function selectDataset(id: string): void {
+  if (import.meta.env.PROD) throw new Error(`unknown id ${id}`);
+  (api as MockApiClient).selectDataset(id);
+}