@genspectrum/dashboard-components 0.6.2 → 0.6.4

package/src/preact/prevalenceOverTime/prevalence-over-time.stories.tsx

@@ -33,6 +33,7 @@ export default {
         height: { control: 'text' },
         pageSize: { control: 'object' },
         yAxisMaxConfig: { control: 'object' },
+        lapisDateField: { control: 'text' },
     },
 };
 

package/src/preact/shared/table/formatProportion.ts

@@ -1,3 +1,3 @@
-export const formatProportion = (proportion: number) => {
-    return `${(proportion * 100).toFixed(2)}%`;
+export const formatProportion = (proportion: number, digits: number = 2) => {
+    return `${(proportion * 100).toFixed(digits)}%`;
 };

package/src/query/queryAggregatedDataOverTime.ts

@@ -7,11 +7,11 @@ import { SlidingOperator } from '../operator/SlidingOperator';
 import { SortOperator } from '../operator/SortOperator';
 import type { LapisFilter, TemporalGranularity } from '../types';
 import {
-    compareTemporal,
+    dateRangeCompare,
     generateAllInRange,
     getMinMaxTemporal,
+    parseDateStringToTemporal,
     type Temporal,
-    TemporalCache,
 } from '../utils/temporal';
 
 export function queryAggregatedDataOverTime<LapisDateField extends string>(
@@ -36,41 +36,16 @@ export function queryAggregatedDataOverTime<LapisDateField extends string>(
     return smoothingWindow >= 1 ? new SlidingOperator(sortData, smoothingWindow, averageSmoothing) : sortData;
 }
 
-function mapDateToGranularityRange(d: { date: string | null; count: number }, granularity: TemporalGranularity) {
-    let dateRange: Temporal | null = null;
-    if (d.date !== null) {
-        const date = TemporalCache.getInstance().getYearMonthDay(d.date);
-        switch (granularity) {
-            case 'day':
-                dateRange = date;
-                break;
-            case 'week':
-                dateRange = date.week;
-                break;
-            case 'month':
-                dateRange = date.month;
-                break;
-            case 'year':
-                dateRange = date.year;
-                break;
-        }
-    }
+export function mapDateToGranularityRange(
+    data: { date: string | null; count: number },
+    granularity: TemporalGranularity,
+) {
     return {
-        dateRange,
-        count: d.count,
+        dateRange: data.date === null ? null : parseDateStringToTemporal(data.date, granularity),
+        count: data.count,
     };
 }
 
-function dateRangeCompare(a: { dateRange: Temporal | null }, b: { dateRange: Temporal | null }) {
-    if (a.dateRange === null) {
-        return 1;
-    }
-    if (b.dateRange === null) {
-        return -1;
-    }
-    return compareTemporal(a.dateRange, b.dateRange);
-}
-
 function averageSmoothing(slidingWindow: { dateRange: Temporal | null; count: number }[]) {
     const average = slidingWindow.reduce((acc, curr) => acc + curr.count, 0) / slidingWindow.length;
     const centerIndex = Math.floor(slidingWindow.length / 2);

package/src/query/queryMutationsOverTime.spec.ts

@@ -0,0 +1,378 @@
+import { describe, expect, it } from 'vitest';
+
+import { queryMutationsOverTimeData } from './queryMutationsOverTime';
+import { DUMMY_LAPIS_URL, lapisRequestMocks } from '../../vitest.setup';
+
+describe('queryMutationsOverTime', () => {
+    it('should fetch for a filter without date', async () => {
+        const lapisFilter = { field1: 'value1', field2: 'value2' };
+        const dateField = 'dateField';
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.1, 1), getSomeOtherTestMutation(0.4, 4)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2, 2)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.3, 3)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+            [
+                { proportion: 0.1, count: 1 },
+                { proportion: 0.2, count: 2 },
+                { proportion: 0.3, count: 3 },
+            ],
+            [
+                { proportion: 0.4, count: 4 },
+                { proportion: 0, count: 0 },
+                { proportion: 0, count: 0 },
+            ],
+        ]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-01');
+        expect(dates[1].toString()).toBe('2023-01-02');
+        expect(dates[2].toString()).toBe('2023-01-03');
+    });
+
+    it('should fetch for dates with no mutations', async () => {
+        const lapisFilter = { field1: 'value1', field2: 'value2' };
+        const dateField = 'dateField';
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.1, 1), getSomeOtherTestMutation(0.4, 4)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.3, 3)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+            [
+                { proportion: 0.1, count: 1 },
+                { proportion: 0.3, count: 3 },
+                { proportion: 0, count: 0 },
+            ],
+            [
+                { proportion: 0.4, count: 4 },
+                { proportion: 0, count: 0 },
+                { proportion: 0, count: 0 },
+            ],
+        ]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-01');
+        expect(dates[1].toString()).toBe('2023-01-03');
+        expect(dates[2].toString()).toBe('2023-01-02');
+    });
+
+    it('should return empty map when no mutations are found', async () => {
+        const lapisFilter = { field1: 'value1', field2: 'value2' };
+        const dateField = 'dateField';
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([]);
+        expect(result.getFirstAxisKeys()).to.deep.equal([]);
+        expect(result.getSecondAxisKeys()).to.deep.equal([]);
+    });
+
+    it('should use dateFrom from filter', async () => {
+        const dateField = 'dateField';
+        const lapisFilter = { field1: 'value1', field2: 'value2', [`${dateField}From`]: '2023-01-02' };
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2, 2)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.3, 3)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+            [
+                { proportion: 0.2, count: 2 },
+                { proportion: 0.3, count: 3 },
+            ],
+        ]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-02');
+        expect(dates[1].toString()).toBe('2023-01-03');
+    });
+
+    it('should use dateTo from filter', async () => {
+        const dateField = 'dateField';
+        const lapisFilter = { field1: 'value1', field2: 'value2', [`${dateField}To`]: '2023-01-02' };
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.1, 1)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2, 2)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([
+            [
+                { proportion: 0.1, count: 1 },
+                { proportion: 0.2, count: 2 },
+            ],
+        ]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-01');
+        expect(dates[1].toString()).toBe('2023-01-02');
+    });
+
+    it('should use date from filter', async () => {
+        const dateField = 'dateField';
+        const lapisFilter = { field1: 'value1', field2: 'value2', [dateField]: '2023-01-02' };
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2, 2)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray({ count: 0, proportion: 0 })).to.deep.equal([[{ proportion: 0.2, count: 2 }]]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-02');
+    });
+
+    function getSomeTestMutation(proportion: number, count: number) {
+        return {
+            mutation: 'sequenceName:A123T',
+            proportion,
+            count,
+            sequenceName: 'sequenceName',
+            mutationFrom: 'A',
+            mutationTo: 'T',
+            position: 123,
+        };
+    }
+
+    function getSomeOtherTestMutation(proportion: number, count: number) {
+        return {
+            mutation: 'otherSequenceName:A123T',
+            proportion,
+            count,
+            sequenceName: 'otherSequenceName',
+            mutationFrom: 'G',
+            mutationTo: 'C',
+            position: 234,
+        };
+    }
+});

package/src/query/queryMutationsOverTime.ts

@@ -0,0 +1,179 @@
+import { mapDateToGranularityRange } from './queryAggregatedDataOverTime';
+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 {
+    type LapisFilter,
+    type SequenceType,
+    type SubstitutionOrDeletionEntry,
+    type TemporalGranularity,
+} from '../types';
+import { Map2d } from '../utils/Map2d';
+import { type Deletion, type Substitution } from '../utils/mutations';
+import {
+    dateRangeCompare,
+    generateAllInRange,
+    getMinMaxTemporal,
+    parseDateStringToTemporal,
+    type Temporal,
+} from '../utils/temporal';
+
+export type MutationOverTimeData = {
+    date: Temporal;
+    mutations: SubstitutionOrDeletionEntry[];
+};
+
+export type MutationOverTimeMutationValue = { proportion: number; count: number };
+export type MutationOverTimeDataGroupedByMutation = Map2d<
+    Substitution | Deletion,
+    Temporal,
+    MutationOverTimeMutationValue
+>;
+
+const MAX_NUMBER_OF_GRID_COLUMNS = 200;
+
+export async function queryMutationsOverTimeData(
+    lapisFilter: LapisFilter,
+    sequenceType: 'nucleotide' | 'amino acid',
+    lapis: string,
+    lapisDateField: string,
+    granularity: TemporalGranularity,
+    signal?: AbortSignal,
+) {
+    const allDates = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
+
+    if (allDates.length > MAX_NUMBER_OF_GRID_COLUMNS) {
+        throw new UserFacingError(
+            'Too many dates',
+            `The dataset would contain ${allDates.length} date intervals. ` +
+                `Please reduce the number to below ${MAX_NUMBER_OF_GRID_COLUMNS} to display the data. ` +
+                'You can achieve this by either narrowing the date range in the provided LAPIS filter or by selecting a larger granularity.',
+        );
+    }
+
+    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 = await fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal);
+        return {
+            date,
+            mutations: data.content,
+        };
+    });
+
+    const data = await Promise.all(subQueries);
+
+    return groupByMutation(data);
+}
+
+async function getDatesInDataset(
+    lapisFilter: LapisFilter,
+    lapis: string,
+    granularity: TemporalGranularity,
+    lapisDateField: string,
+    signal: AbortSignal | undefined,
+) {
+    const { content: availableDates } = await queryAvailableDates(
+        lapisFilter,
+        lapis,
+        granularity,
+        lapisDateField,
+        signal,
+    );
+
+    const { dateFrom, dateTo } = getDateRangeFromFilter(lapisFilter, lapisDateField, granularity);
+    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<LapisDateField extends string>(
+    filter: LapisFilter,
+    granularity: TemporalGranularity,
+    lapisDateField: LapisDateField,
+) {
+    const fetchData = new FetchAggregatedOperator<{ [key in LapisDateField]: 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, 0.001);
+}
+
+export function groupByMutation(data: MutationOverTimeData[]) {
+    const dataArray = new Map2d<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>(
+        (mutation) => mutation.code,
+        (date) => date.toString(),
+    );
+
+    data.forEach((mutationData) => {
+        mutationData.mutations.forEach((mutationEntry) => {
+            dataArray.set(mutationEntry.mutation, mutationData.date, {
+                count: mutationEntry.count,
+                proportion: mutationEntry.proportion,
+            });
+        });
+    });
+
+    addZeroValuesForDatesWithNoMutationData(dataArray, data);
+
+    return dataArray;
+}
+
+function addZeroValuesForDatesWithNoMutationData(
+    dataArray: Map2d<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>,
+    data: MutationOverTimeData[],
+) {
+    if (dataArray.getFirstAxisKeys().length !== 0) {
+        const someMutation = dataArray.getFirstAxisKeys()[0];
+        data.forEach((mutationData) => {
+            if (mutationData.mutations.length === 0) {
+                dataArray.set(someMutation, mutationData.date, { count: 0, proportion: 0 });
+            }
+        });
+    }
+}

package/src/query/queryNumberOfSequencesOverTime.ts

@@ -4,7 +4,6 @@ import { sortNullToBeginningThenByDate } from '../utils/sort';
 import { makeArray } from '../utils/utils';
 
 export type NumberOfSequencesDatasets = Awaited<ReturnType<typeof queryNumberOfSequencesOverTime>>;
-export type NumberOfSequencesDataset = NumberOfSequencesDatasets[number];
 
 export async function queryNumberOfSequencesOverTime(
     lapis: string,

package/src/query/queryRelativeGrowthAdvantage.ts

@@ -28,11 +28,11 @@ export async function queryRelativeGrowthAdvantage<LapisDateField extends string
         mapNumerator.evaluate(lapis, signal),
         mapDenominator.evaluate(lapis, signal),
     ]);
-    const minMaxDate = getMinMaxTemporal(denominatorData.content.map((d) => d.date));
-    if (!minMaxDate) {
+    const { min: minDate, max: maxDate } = getMinMaxTemporal(denominatorData.content.map((d) => d.date));
+    if (!minDate && !maxDate) {
         return null;
     }
-    const [minDate, maxDate] = minMaxDate as [YearMonthDay, YearMonthDay];
+
     const numeratorCounts = new Map<YearMonthDay, number>();
     numeratorData.content.forEach((d) => {
         if (d.date) {