@genspectrum/dashboard-components 1.2.0 → 1.3.1

package/src/query/queryMutationsOverTime.ts

@@ -1,4 +1,5 @@
 import { mapDateToGranularityRange } from './queryAggregatedDataOverTime';
+import { fetchMutationsOverTime } from '../lapisApi/lapisApi';
 import { FetchAggregatedOperator } from '../operator/FetchAggregatedOperator';
 import { FetchSubstitutionsOrDeletionsOperator } from '../operator/FetchSubstitutionsOrDeletionsOperator';
 import { GroupByAndSumOperator } from '../operator/GroupByAndSumOperator';
@@ -16,7 +17,14 @@ import {
     type SubstitutionOrDeletionEntry,
     type TemporalGranularity,
 } from '../types';
-import { type Deletion, type Substitution, toSubstitutionOrDeletion } from '../utils/mutations';
+import { type Map2DContents } from '../utils/map2d';
+import {
+    type Deletion,
+    type Substitution,
+    toSubstitutionOrDeletion,
+    DeletionClass,
+    SubstitutionClass,
+} from '../utils/mutations';
 import {
     compareTemporal,
     dateRangeCompare,
@@ -54,12 +62,45 @@ export type MutationOverTimeMutationValue =
 const MAX_NUMBER_OF_GRID_COLUMNS = 200;
 export const MUTATIONS_OVER_TIME_MIN_PROPORTION = 0.001;
 
+/**
+ * Create SubstitutionOrDeletionEntry for given code with count and proportion 0.
+ * @param code a mutation code like G44T or A23-
+ */
+function codeToEmptyEntry(code: string): SubstitutionOrDeletionEntry | null {
+    const maybeDeletion = DeletionClass.parse(code);
+    if (maybeDeletion) {
+        return {
+            type: 'deletion',
+            mutation: maybeDeletion,
+            count: 0,
+            proportion: 0,
+        };
+    }
+    const maybeSubstitution = SubstitutionClass.parse(code);
+    if (maybeSubstitution) {
+        return {
+            type: 'substitution',
+            mutation: maybeSubstitution,
+            count: 0,
+            proportion: 0,
+        };
+    }
+    return null;
+}
+
+/**
+ * Return counts and proportions for all mutations that match the lapisFilter.
+ * If `includeMutations` are given, the result will also be filtered for those.
+ * Any mutation that isn't in the result, but is in the `includeMutations` will
+ * be in the result with count and proportion as 0.
+ */
 async function queryOverallMutationData({
     lapisFilter,
     sequenceType,
     lapis,
     granularity,
     lapisDateField,
+    includeMutations,
     signal,
 }: {
     lapisFilter: LapisFilter;
@@ -67,14 +108,23 @@ async function queryOverallMutationData({
     lapis: string;
     granularity: TemporalGranularity;
     lapisDateField: string;
+    includeMutations?: string[];
     signal?: AbortSignal;
 }) {
     const requestedDateRanges = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
 
     if (requestedDateRanges.length === 0) {
-        return {
-            content: [],
-        };
+        if (includeMutations) {
+            return {
+                content: includeMutations
+                    .map(codeToEmptyEntry)
+                    .filter((e): e is SubstitutionOrDeletionEntry => e !== null),
+            };
+        } else {
+            return {
+                content: [],
+            };
+        }
     }
 
     const filter = {
@@ -83,26 +133,39 @@ async function queryOverallMutationData({
         [`${lapisDateField}To`]: requestedDateRanges[requestedDateRanges.length - 1].lastDay.toString(),
     };
 
-    return fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal);
+    let dataPromise = fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal);
+
+    if (includeMutations) {
+        dataPromise = dataPromise.then((data) => {
+            return {
+                content: includeMutations
+                    .map((code) => {
+                        const found = data.content.find((m) => m.mutation.code === code);
+                        return found ?? codeToEmptyEntry(code);
+                    })
+                    .filter((e): e is SubstitutionOrDeletionEntry => e !== null),
+            };
+        });
+    }
+
+    return dataPromise;
 }
 
 export type MutationOverTimeQuery = {
     lapisFilter: LapisFilter;
+    displayMutations?: string[];
     sequenceType: SequenceType;
     lapis: string;
     lapisDateField: string;
     granularity: TemporalGranularity;
+    useNewEndpoint?: boolean;
     signal?: AbortSignal;
 };
 
-export async function queryMutationsOverTimeData({
-    lapisFilter,
-    sequenceType,
-    lapis,
-    lapisDateField,
-    granularity,
-    signal,
-}: MutationOverTimeQuery) {
+export async function queryMutationsOverTimeData(query: MutationOverTimeQuery) {
+    const { lapisFilter, displayMutations, sequenceType, lapis, lapisDateField, granularity, useNewEndpoint, signal } =
+        query;
+
     const requestedDateRanges = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
 
     if (requestedDateRanges.length > MAX_NUMBER_OF_GRID_COLUMNS) {
@@ -114,7 +177,26 @@ export async function queryMutationsOverTimeData({
         );
     }
 
-    const subQueries = requestedDateRanges.map(async (date) => {
+    const overallMutationData = queryOverallMutationData({
+        lapisFilter,
+        sequenceType,
+        lapis,
+        lapisDateField,
+        includeMutations: displayMutations,
+        granularity,
+    }).then((r) => r.content);
+
+    return useNewEndpoint === true
+        ? queryMutationsOverTimeDataDirectEndpoint(requestedDateRanges, overallMutationData, query)
+        : queryMutationsOverTimeDataMultiQuery(requestedDateRanges, overallMutationData, query);
+}
+
+async function queryMutationsOverTimeDataMultiQuery(
+    allDates: TemporalClass[],
+    overallMutationDataPromise: Promise<SubstitutionOrDeletionEntry[]>,
+    { lapisFilter, sequenceType, lapis, lapisDateField, signal }: MutationOverTimeQuery,
+) {
+    const subQueries = allDates.map(async (date) => {
         const dateFrom = date.firstDay.toString();
         const dateTo = date.lastDay.toString();
 
@@ -124,8 +206,10 @@ export async function queryMutationsOverTimeData({
             [`${lapisDateField}To`]: dateTo,
         };
 
-        const data = await fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal);
-        const totalCountQuery = await getTotalNumberOfSequencesInDateRange(filter).evaluate(lapis, signal);
+        const [data, totalCountQuery] = await Promise.all([
+            fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal),
+            getTotalNumberOfSequencesInDateRange(filter).evaluate(lapis, signal),
+        ]);
 
         return {
             date,
@@ -135,20 +219,80 @@ export async function queryMutationsOverTimeData({
     });
 
     const data = await Promise.all(subQueries);
+    const overallMutationData = await overallMutationDataPromise;
 
-    const overallMutationsData = (
-        await queryOverallMutationData({
-            lapisFilter,
-            sequenceType,
-            lapis,
-            lapisDateField,
-            granularity,
-        })
-    ).content;
+    return {
+        mutationOverTimeData: groupByMutation(data, overallMutationData),
+        overallMutationData,
+    };
+}
+
+async function queryMutationsOverTimeDataDirectEndpoint(
+    allDates: TemporalClass[],
+    overallMutationDataPromise: Promise<SubstitutionOrDeletionEntry[]>,
+    { lapisFilter, sequenceType, lapis, lapisDateField, signal }: MutationOverTimeQuery,
+): Promise<{
+    mutationOverTimeData: BaseMutationOverTimeDataMap;
+    overallMutationData: SubstitutionOrDeletionEntry[];
+}> {
+    const overallMutationData = await overallMutationDataPromise;
+    overallMutationData.sort((a, b) => sortSubstitutionsAndDeletions(a.mutation, b.mutation));
+    const totalCounts = await Promise.all(
+        allDates.map(async (date) => {
+            const filter = {
+                ...lapisFilter,
+                [`${lapisDateField}From`]: date.firstDay.toString(),
+                [`${lapisDateField}To`]: date.lastDay.toString(),
+            };
+
+            const totalCountQuery = await getTotalNumberOfSequencesInDateRange(filter).evaluate(lapis, signal);
+
+            return totalCountQuery.content[0].count;
+        }),
+    );
+
+    const includeMutations = overallMutationData.map((value) => value.mutation.code);
+    const apiResult = await fetchMutationsOverTime(
+        lapis,
+        {
+            filters: lapisFilter,
+            dateRanges: allDates.map((date) => ({
+                dateFrom: date.firstDay.toString(),
+                dateTo: date.lastDay.toString(),
+            })),
+            includeMutations,
+            dateField: lapisDateField,
+        },
+        sequenceType,
+        signal,
+    );
+
+    const mutationOverTimeData: Map2DContents<Substitution | Deletion, Temporal, MutationOverTimeMutationValue> = {
+        keysFirstAxis: new Map(overallMutationData.map((value) => [value.mutation.code, value.mutation])),
+        keysSecondAxis: new Map(allDates.map((date) => [date.dateString, date])),
+        data: new Map(
+            overallMutationData.map((mutation, i) => [
+                mutation.mutation.code,
+                new Map(
+                    allDates.map((date, j): [string, MutationOverTimeMutationValue] => [
+                        date.dateString,
+                        {
+                            type: 'value',
+                            // 'coverage' in the API resp. is the number of seqs. that have a non-ambiguous symbol at position
+                            // 'count' in the API resp. is the number of seqs with the mutation
+                            proportion: apiResult.data.data[i][j].count / apiResult.data.data[i][j].coverage,
+                            count: apiResult.data.data[i][j].count,
+                            totalCount: totalCounts[j],
+                        },
+                    ]),
+                ),
+            ]),
+        ),
+    };
 
     return {
-        mutationOverTimeData: groupByMutation(data, overallMutationsData),
-        overallMutationData: overallMutationsData,
+        mutationOverTimeData: new BaseMutationOverTimeDataMap(mutationOverTimeData),
+        overallMutationData,
     };
 }
 
@@ -236,7 +380,7 @@ export function serializeTemporal(date: Temporal) {
 export function groupByMutation(
     data: MutationOverTimeData[],
     overallMutationData: (SubstitutionEntry | DeletionEntry)[],
-) {
+): BaseMutationOverTimeDataMap {
     const dataArray = new BaseMutationOverTimeDataMap();
 
     const allDates = data.map((mutationData) => mutationData.date);