@genspectrum/dashboard-components 1.11.1 → 1.13.0

package/src/query/queryMutationsOverTime.ts

@@ -1,48 +1,20 @@
-import { mapDateToGranularityRange } from './queryAggregatedDataOverTime';
+import { queryDatesInDataset } from './queryDatesInDataset';
 import { fetchMutationsOverTime } from '../lapisApi/lapisApi';
-import { FetchAggregatedOperator } from '../operator/FetchAggregatedOperator';
 import { FetchSubstitutionsOrDeletionsOperator } from '../operator/FetchSubstitutionsOrDeletionsOperator';
-import { GroupByAndSumOperator } from '../operator/GroupByAndSumOperator';
-import { MapOperator } from '../operator/MapOperator';
-import { RenameFieldOperator } from '../operator/RenameFieldOperator';
-import { SortOperator } from '../operator/SortOperator';
 import { UserFacingError } from '../preact/components/error-display';
 import { BaseMutationOverTimeDataMap } from '../preact/mutationsOverTime/MutationOverTimeData';
 import { sortSubstitutionsAndDeletions } from '../preact/shared/sort/sortSubstitutionsAndDeletions';
 import {
-    type DeletionEntry,
     type LapisFilter,
     type SequenceType,
-    type SubstitutionEntry,
     type SubstitutionOrDeletionEntry,
     type TemporalGranularity,
 } from '../types';
 import { type Map2DContents } from '../utils/map2d';
-import {
-    type Deletion,
-    type Substitution,
-    toSubstitutionOrDeletion,
-    DeletionClass,
-    SubstitutionClass,
-} from '../utils/mutations';
-import {
-    compareTemporal,
-    dateRangeCompare,
-    generateAllInRange,
-    getMinMaxTemporal,
-    parseDateStringToTemporal,
-    type Temporal,
-    type TemporalClass,
-    toTemporal,
-} from '../utils/temporalClass';
-
-export type MutationOverTimeData = {
-    date: TemporalClass;
-    mutations: SubstitutionOrDeletionEntry[];
-    totalCount: number;
-};
+import { type Deletion, type Substitution, DeletionClass, SubstitutionClass } from '../utils/mutations';
+import { type Temporal } from '../utils/temporalClass';
 
-export type MutationOverTimeMutationValue =
+export type ProportionValue =
     | {
           type: 'value';
           proportion: number;
@@ -65,7 +37,7 @@ export type MutationOverTimeMutationValue =
       }
     | null;
 
-export function getProportion(value: MutationOverTimeMutationValue) {
+export function getProportion(value: ProportionValue) {
     switch (value?.type) {
         case 'value':
         case 'wastewaterValue':
@@ -130,7 +102,7 @@ async function queryOverallMutationData({
     includeMutations?: string[];
     signal?: AbortSignal;
 }) {
-    const requestedDateRanges = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
+    const requestedDateRanges = await queryDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
 
     if (requestedDateRanges.length === 0) {
         if (includeMutations) {
@@ -170,22 +142,16 @@ async function queryOverallMutationData({
     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(query: MutationOverTimeQuery) {
-    const { lapisFilter, displayMutations, sequenceType, lapis, lapisDateField, granularity, useNewEndpoint, signal } =
-        query;
-
-    const requestedDateRanges = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
+export async function queryMutationsOverTimeData(
+    lapisFilter: LapisFilter,
+    sequenceType: SequenceType,
+    lapis: string,
+    lapisDateField: string,
+    granularity: TemporalGranularity,
+    displayMutations?: string[],
+    signal?: AbortSignal,
+) {
+    const requestedDateRanges = await queryDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
 
     if (requestedDateRanges.length > MAX_NUMBER_OF_GRID_COLUMNS) {
         throw new UserFacingError(
@@ -196,7 +162,7 @@ export async function queryMutationsOverTimeData(query: MutationOverTimeQuery) {
         );
     }
 
-    const overallMutationData = queryOverallMutationData({
+    const overallMutationData = await queryOverallMutationData({
         lapisFilter,
         sequenceType,
         lapis,
@@ -205,77 +171,14 @@ export async function queryMutationsOverTimeData(query: MutationOverTimeQuery) {
         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();
-
-        const filter = {
-            ...lapisFilter,
-            [`${lapisDateField}From`]: dateFrom,
-            [`${lapisDateField}To`]: dateTo,
-        };
-
-        const [data, totalCountQuery] = await Promise.all([
-            fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal),
-            getTotalNumberOfSequencesInDateRange(filter).evaluate(lapis, signal),
-        ]);
-
-        return {
-            date,
-            mutations: data.content,
-            totalCount: totalCountQuery.content[0].count,
-        };
-    });
-
-    const data = await Promise.all(subQueries);
-    const overallMutationData = await overallMutationDataPromise;
-
-    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) => ({
+            dateRanges: requestedDateRanges.map((date) => ({
                 dateFrom: date.firstDay.toString(),
                 dateTo: date.lastDay.toString(),
             })),
@@ -286,6 +189,7 @@ async function queryMutationsOverTimeDataDirectEndpoint(
         signal,
     );
 
+    const totalCounts = apiResult.data.totalCountsByDateRange;
     const responseMutations = apiResult.data.mutations.map(parseMutationCode);
     const mutationEntries: SubstitutionOrDeletionEntry[] = responseMutations.map((mutation, i) => {
         const numbers = {
@@ -307,14 +211,14 @@ async function queryMutationsOverTimeDataDirectEndpoint(
         }
     });
 
-    const mutationOverTimeData: Map2DContents<Substitution | Deletion, Temporal, MutationOverTimeMutationValue> = {
+    const mutationOverTimeData: Map2DContents<Substitution | Deletion, Temporal, ProportionValue> = {
         keysFirstAxis: new Map(responseMutations.map((mutation) => [mutation.code, mutation])),
-        keysSecondAxis: new Map(allDates.map((date) => [date.dateString, date])),
+        keysSecondAxis: new Map(requestedDateRanges.map((date) => [date.dateString, date])),
         data: new Map(
             responseMutations.map((mutation, i) => [
                 mutation.code,
                 new Map(
-                    allDates.map((date, j): [string, MutationOverTimeMutationValue] => {
+                    requestedDateRanges.map((date, j): [string, ProportionValue] => {
                         if (totalCounts[j] === 0) {
                             return [date.dateString, null];
                         }
@@ -365,75 +269,6 @@ function parseMutationCode(code: string): SubstitutionClass | DeletionClass {
     throw Error(`Given code is not valid: ${code}`);
 }
 
-/**
- * Returns a list of date ranges as TemporalClass.
- * Respects date range filters given in the lapisFilter as <lapisDateField>From and <lapisDateField>To.
- * If either side (or both sides) of the range are not given, the min and max are determined from
- * the available data.
- */
-async function getDatesInDataset(
-    lapisFilter: LapisFilter,
-    lapis: string,
-    granularity: TemporalGranularity,
-    lapisDateField: string,
-    signal: AbortSignal | undefined,
-) {
-    const { dateFrom, dateTo } = getDateRangeFromFilter(lapisFilter, lapisDateField, granularity);
-    if (dateFrom !== null && dateTo !== null) {
-        return generateAllInRange(dateFrom, dateTo);
-    }
-
-    const { content: availableDates } = await queryAvailableDates(
-        lapisFilter,
-        lapis,
-        granularity,
-        lapisDateField,
-        signal,
-    );
-
-    const { min, max } = getMinMaxTemporal(availableDates);
-
-    return generateAllInRange(dateFrom ?? min, dateTo ?? max);
-}
-
-function getDateRangeFromFilter(lapisFilter: LapisFilter, lapisDateField: string, granularity: TemporalGranularity) {
-    const valueFromFilter = lapisFilter[lapisDateField] as string | null;
-
-    if (valueFromFilter) {
-        return {
-            dateFrom: parseDateStringToTemporal(valueFromFilter, granularity),
-            dateTo: parseDateStringToTemporal(valueFromFilter, granularity),
-        };
-    }
-
-    const minFromFilter = lapisFilter[`${lapisDateField}From`] as string | null;
-    const maxFromFilter = lapisFilter[`${lapisDateField}To`] as string | null;
-
-    return {
-        dateFrom: minFromFilter ? parseDateStringToTemporal(minFromFilter, granularity) : null,
-        dateTo: maxFromFilter ? parseDateStringToTemporal(maxFromFilter, granularity) : null,
-    };
-}
-
-function queryAvailableDates(
-    lapisFilter: LapisFilter,
-    lapis: string,
-    granularity: TemporalGranularity,
-    lapisDateField: string,
-    signal?: AbortSignal,
-) {
-    return fetchAndPrepareDates(lapisFilter, granularity, lapisDateField).evaluate(lapis, signal);
-}
-
-function fetchAndPrepareDates(filter: LapisFilter, granularity: TemporalGranularity, lapisDateField: string) {
-    const fetchData = new FetchAggregatedOperator<Record<string, string | null>>(filter, [lapisDateField]);
-    const dataWithFixedDateKey = new RenameFieldOperator(fetchData, lapisDateField, 'date');
-    const mapData = new MapOperator(dataWithFixedDateKey, (data) => mapDateToGranularityRange(data, granularity));
-    const groupByData = new GroupByAndSumOperator(mapData, 'dateRange', 'count');
-    const sortData = new SortOperator(groupByData, dateRangeCompare);
-    return new MapOperator(sortData, (data) => data.dateRange);
-}
-
 function fetchAndPrepareSubstitutionsOrDeletions(filter: LapisFilter, sequenceType: SequenceType) {
     return new FetchSubstitutionsOrDeletionsOperator(filter, sequenceType, MUTATIONS_OVER_TIME_MIN_PROPORTION);
 }
@@ -445,61 +280,3 @@ export function serializeSubstitutionOrDeletion(mutation: Substitution | Deletio
 export function serializeTemporal(date: Temporal) {
     return date.dateString;
 }
-
-export function groupByMutation(
-    data: MutationOverTimeData[],
-    overallMutationData: (SubstitutionEntry | DeletionEntry)[],
-): BaseMutationOverTimeDataMap {
-    const dataArray = new BaseMutationOverTimeDataMap();
-
-    const allDates = data.map((mutationData) => mutationData.date);
-
-    const sortedOverallMutationData = overallMutationData
-        .sort((a, b) => sortSubstitutionsAndDeletions(a.mutation, b.mutation))
-        .map((entry) => {
-            return toSubstitutionOrDeletion(entry.mutation);
-        });
-    const sortedDates = allDates.sort((a, b) => compareTemporal(a, b)).map((date) => toTemporal(date));
-
-    sortedOverallMutationData.forEach((mutationData) => {
-        sortedDates.forEach((date) => {
-            dataArray.set(mutationData, date, null);
-        });
-    });
-
-    data.forEach((mutationData) => {
-        if (mutationData.totalCount == 0) {
-            return;
-        }
-
-        const date = toTemporal(mutationData.date);
-
-        mutationData.mutations.forEach((mutationEntry) => {
-            const mutation = toSubstitutionOrDeletion(mutationEntry.mutation);
-
-            if (dataArray.get(mutation, date) !== undefined) {
-                dataArray.set(mutation, date, {
-                    type: 'value',
-                    count: mutationEntry.count,
-                    proportion: mutationEntry.proportion,
-                    totalCount: mutationData.totalCount,
-                });
-            }
-        });
-
-        for (const firstAxisKey of dataArray.getFirstAxisKeys()) {
-            if (dataArray.get(firstAxisKey, date) === null) {
-                dataArray.set(firstAxisKey, date, {
-                    type: 'belowThreshold',
-                    totalCount: mutationData.totalCount,
-                });
-            }
-        }
-    });
-
-    return dataArray;
-}
-
-function getTotalNumberOfSequencesInDateRange(filter: LapisFilter) {
-    return new FetchAggregatedOperator<{ count: number }>(filter);
-}