@genspectrum/dashboard-components 0.6.18 → 0.7.0

package/src/query/queryMutationsOverTime.spec.ts

@@ -4,7 +4,7 @@ import { queryMutationsOverTimeData } from './queryMutationsOverTime';
 import { DUMMY_LAPIS_URL, lapisRequestMocks } from '../../vitest.setup';
 
 describe('queryMutationsOverTime', () => {
-    it('should fetch for a filter without date', async () => {
+    it('should fetch for a filter without date and sort by mutation and date', async () => {
         const lapisFilter = { field1: 'value1', field2: 'value2' };
         const dateField = 'dateField';
 
@@ -76,33 +76,79 @@ describe('queryMutationsOverTime', () => {
                     },
                     response: { data: [getSomeTestMutation(0.3, 3)] },
                 },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: {
+                        data: [getSomeTestMutation(0.21, 6), getSomeOtherTestMutation(0.22, 4)],
+                    },
+                },
             ],
             'nucleotide',
         );
 
-        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+        const { mutationOverTimeData, overallMutationData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'day',
+        });
 
-        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
-            [
-                { proportion: 0.1, count: 1, totalCount: 11 },
-                { proportion: 0.2, count: 2, totalCount: 12 },
-                { proportion: 0.3, count: 3, totalCount: 13 },
-            ],
+        expect(mutationOverTimeData.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
                 { proportion: 0.4, count: 4, totalCount: 11 },
                 { proportion: 0, count: 0, totalCount: 0 },
                 { proportion: 0, count: 0, totalCount: 0 },
             ],
+            [
+                { proportion: 0.1, count: 1, totalCount: 11 },
+                { proportion: 0.2, count: 2, totalCount: 12 },
+                { proportion: 0.3, count: 3, totalCount: 13 },
+            ],
         ]);
 
-        const sequences = result.getFirstAxisKeys();
-        expect(sequences[0].code).toBe('sequenceName:A123T');
-        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+        const sequences = mutationOverTimeData.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('otherSequenceName:G234C');
+        expect(sequences[1].code).toBe('sequenceName:A123T');
+
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01-01');
+        expect(dates[1].dateString).toBe('2023-01-02');
+        expect(dates[2].dateString).toBe('2023-01-03');
 
-        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');
+        expect(overallMutationData).to.deep.equal([
+            {
+                type: 'substitution',
+                mutation: {
+                    valueAtReference: 'G',
+                    substitutionValue: 'C',
+                    position: 234,
+                    segment: 'otherSequenceName',
+                    code: 'otherSequenceName:G234C',
+                    type: 'substitution',
+                },
+                count: 4,
+                proportion: 0.22,
+            },
+            {
+                type: 'substitution',
+                mutation: {
+                    valueAtReference: 'A',
+                    substitutionValue: 'T',
+                    position: 123,
+                    segment: 'sequenceName',
+                    code: 'sequenceName:A123T',
+                    type: 'substitution',
+                },
+                count: 6,
+                proportion: 0.21,
+            },
+        ]);
     });
 
     it('should fetch for dates with no mutations', async () => {
@@ -177,33 +223,54 @@ describe('queryMutationsOverTime', () => {
                     },
                     response: { data: [getSomeTestMutation(0.3, 3)] },
                 },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: {
+                        data: [
+                            getSomeTestMutation(0.1, 1),
+                            getSomeTestMutation(0.3, 3),
+                            getSomeOtherTestMutation(0.4, 4),
+                        ],
+                    },
+                },
             ],
             'nucleotide',
         );
 
-        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+        const { mutationOverTimeData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'day',
+        });
 
-        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
+        expect(mutationOverTimeData.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
-                { proportion: 0.1, count: 1, totalCount: 11 },
-                { proportion: 0.3, count: 3, totalCount: 13 },
+                { proportion: 0.4, count: 4, totalCount: 11 },
+                { proportion: 0, count: 0, totalCount: 0 },
                 { proportion: 0, count: 0, totalCount: 0 },
             ],
             [
-                { proportion: 0.4, count: 4, totalCount: 11 },
-                { proportion: 0, count: 0, totalCount: 0 },
+                { proportion: 0.1, count: 1, totalCount: 11 },
                 { proportion: 0, count: 0, totalCount: 0 },
+                { proportion: 0.3, count: 3, totalCount: 13 },
             ],
         ]);
 
-        const sequences = result.getFirstAxisKeys();
-        expect(sequences[0].code).toBe('sequenceName:A123T');
-        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+        const sequences = mutationOverTimeData.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('otherSequenceName:G234C');
+        expect(sequences[1].code).toBe('sequenceName:A123T');
 
-        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');
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01-01');
+        expect(dates[1].dateString).toBe('2023-01-02');
+        expect(dates[2].dateString).toBe('2023-01-03');
     });
 
     it('should return empty map when no mutations are found', async () => {
@@ -278,15 +345,32 @@ describe('queryMutationsOverTime', () => {
                     },
                     response: { data: [] },
                 },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        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, totalCount: 0 })).to.deep.equal([]);
-        expect(result.getFirstAxisKeys()).to.deep.equal([]);
-        expect(result.getSecondAxisKeys()).to.deep.equal([]);
+        const { mutationOverTimeData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'day',
+        });
+
+        expect(mutationOverTimeData.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([]);
+        expect(mutationOverTimeData.getFirstAxisKeys()).to.deep.equal([]);
+        expect(mutationOverTimeData.getSecondAxisKeys()).to.deep.equal([]);
     });
 
     it('should use dateFrom from filter', async () => {
@@ -343,25 +427,42 @@ describe('queryMutationsOverTime', () => {
                     },
                     response: { data: [getSomeTestMutation(0.3, 3)] },
                 },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: {
+                        data: [getSomeTestMutation(0.2, 2), getSomeTestMutation(0.3, 3)],
+                    },
+                },
             ],
             'nucleotide',
         );
 
-        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+        const { mutationOverTimeData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'day',
+        });
 
-        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
+        expect(mutationOverTimeData.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
                 { proportion: 0.2, count: 2, totalCount: 11 },
                 { proportion: 0.3, count: 3, totalCount: 12 },
             ],
         ]);
 
-        const sequences = result.getFirstAxisKeys();
+        const sequences = mutationOverTimeData.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');
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01-02');
+        expect(dates[1].dateString).toBe('2023-01-03');
     });
 
     it('should use dateTo from filter', async () => {
@@ -418,25 +519,42 @@ describe('queryMutationsOverTime', () => {
                     },
                     response: { data: [getSomeTestMutation(0.2, 2)] },
                 },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: {
+                        data: [getSomeTestMutation(0.1, 1), getSomeTestMutation(0.2, 2)],
+                    },
+                },
             ],
             'nucleotide',
         );
 
-        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+        const { mutationOverTimeData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'day',
+        });
 
-        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
+        expect(mutationOverTimeData.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
                 { proportion: 0.1, count: 1, totalCount: 11 },
                 { proportion: 0.2, count: 2, totalCount: 12 },
             ],
         ]);
 
-        const sequences = result.getFirstAxisKeys();
+        const sequences = mutationOverTimeData.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');
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01-01');
+        expect(dates[1].dateString).toBe('2023-01-02');
     });
 
     it('should use date from filter', async () => {
@@ -479,9 +597,15 @@ describe('queryMutationsOverTime', () => {
             'nucleotide',
         );
 
-        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+        const { mutationOverTimeData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'day',
+        });
 
-        expect(result.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
+        expect(mutationOverTimeData.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
             [
                 {
                     proportion: 0.2,
@@ -491,11 +615,108 @@ describe('queryMutationsOverTime', () => {
             ],
         ]);
 
-        const sequences = result.getFirstAxisKeys();
+        const sequences = mutationOverTimeData.getFirstAxisKeys();
         expect(sequences[0].code).toBe('sequenceName:A123T');
 
-        const dates = result.getSecondAxisKeys();
-        expect(dates[0].toString()).toBe('2023-01-02');
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01-02');
+    });
+
+    it('should fetch data including the first and last day of the granularity', async () => {
+        const lapisFilter = { field1: 'value1', field2: 'value2' };
+        const dateField = 'dateField';
+
+        lapisRequestMocks.multipleAggregated([
+            {
+                body: { ...lapisFilter, fields: [dateField] },
+                response: {
+                    data: [
+                        { count: 1, [dateField]: '2023-01-05' },
+                        { count: 2, [dateField]: '2023-02-15' },
+                    ],
+                },
+            },
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-01-01',
+                    dateFieldTo: '2023-01-31',
+                    fields: [],
+                },
+                response: { data: [{ count: 11 }] },
+            },
+            {
+                body: {
+                    ...lapisFilter,
+                    dateFieldFrom: '2023-02-01',
+                    dateFieldTo: '2023-02-28',
+                    fields: [],
+                },
+                response: { data: [{ count: 12 }] },
+            },
+        ]);
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-31',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.1, 1), getSomeOtherTestMutation(0.4, 4)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-02-01',
+                        dateFieldTo: '2023-02-28',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2, 2)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-02-28',
+                        minProportion: 0.001,
+                    },
+                    response: {
+                        data: [getSomeTestMutation(0.21, 6), getSomeOtherTestMutation(0.22, 4)],
+                    },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const { mutationOverTimeData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'month',
+        });
+
+        expect(mutationOverTimeData.getAsArray({ count: 0, proportion: 0, totalCount: 0 })).to.deep.equal([
+            [
+                { proportion: 0.4, count: 4, totalCount: 11 },
+                { proportion: 0, count: 0, totalCount: 0 },
+            ],
+            [
+                { proportion: 0.1, count: 1, totalCount: 11 },
+                { proportion: 0.2, count: 2, totalCount: 12 },
+            ],
+        ]);
+
+        const sequences = mutationOverTimeData.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('otherSequenceName:G234C');
+        expect(sequences[1].code).toBe('sequenceName:A123T');
+
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01');
+        expect(dates[1].dateString).toBe('2023-02');
     });
 
     function getSomeTestMutation(proportion: number, count: number) {
@@ -512,7 +733,7 @@ describe('queryMutationsOverTime', () => {
 
     function getSomeOtherTestMutation(proportion: number, count: number) {
         return {
-            mutation: 'otherSequenceName:A123T',
+            mutation: 'otherSequenceName:G234C',
             proportion,
             count,
             sequenceName: 'otherSequenceName',

package/src/query/queryMutationsOverTime.ts

@@ -6,54 +6,92 @@ 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 { Map2dBase, type Map2d } from '../utils/map2d';
-import { type Deletion, type Substitution } from '../utils/mutations';
+import { type Map2d } from '../utils/map2d';
 import {
+    type Deletion,
+    type DeletionClass,
+    type Substitution,
+    type SubstitutionClass,
+    toSubstitutionOrDeletion,
+} from '../utils/mutations';
+import {
+    compareTemporal,
     dateRangeCompare,
     generateAllInRange,
     getMinMaxTemporal,
     parseDateStringToTemporal,
     type Temporal,
-} from '../utils/temporal';
+    type TemporalClass,
+    toTemporal,
+} from '../utils/temporalClass';
 
 export type MutationOverTimeData = {
-    date: Temporal;
+    date: TemporalClass;
     mutations: SubstitutionOrDeletionEntry[];
     totalCount: number;
 };
 
 export type MutationOverTimeMutationValue = { proportion: number; count: number; totalCount: number };
 export type MutationOverTimeDataGroupedByMutation = Map2d<
-    Substitution | Deletion,
-    Temporal,
+    SubstitutionClass | DeletionClass,
+    TemporalClass,
     MutationOverTimeMutationValue
 >;
 
 const MAX_NUMBER_OF_GRID_COLUMNS = 200;
 
-export async function queryOverallMutationData(
-    lapisFilter: LapisFilter,
-    sequenceType: SequenceType,
-    lapis: string,
-    signal?: AbortSignal,
-) {
-    return fetchAndPrepareSubstitutionsOrDeletions(lapisFilter, sequenceType).evaluate(lapis, signal);
+export async function queryOverallMutationData({
+    lapisFilter,
+    sequenceType,
+    lapis,
+    granularity,
+    lapisDateField,
+    signal,
+}: {
+    lapisFilter: LapisFilter;
+    sequenceType: SequenceType;
+    lapis: string;
+    granularity: TemporalGranularity;
+    lapisDateField: string;
+    signal?: AbortSignal;
+}) {
+    const allDates = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
+    const filter = {
+        ...lapisFilter,
+        [`${lapisDateField}From`]: allDates[0].firstDay.toString(),
+        [`${lapisDateField}To`]: allDates[allDates.length - 1].lastDay.toString(),
+    };
+
+    return fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal);
 }
 
-export async function queryMutationsOverTimeData(
-    lapisFilter: LapisFilter,
-    sequenceType: SequenceType,
-    lapis: string,
-    lapisDateField: string,
-    granularity: TemporalGranularity,
-    signal?: AbortSignal,
-) {
+export type MutationOverTimeQuery = {
+    lapisFilter: LapisFilter;
+    sequenceType: SequenceType;
+    lapis: string;
+    lapisDateField: string;
+    granularity: TemporalGranularity;
+    signal?: AbortSignal;
+};
+
+export async function queryMutationsOverTimeData({
+    lapisFilter,
+    sequenceType,
+    lapis,
+    lapisDateField,
+    granularity,
+    signal,
+}: MutationOverTimeQuery) {
     const allDates = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
 
     if (allDates.length > MAX_NUMBER_OF_GRID_COLUMNS) {
@@ -86,7 +124,20 @@ export async function queryMutationsOverTimeData(
 
     const data = await Promise.all(subQueries);
 
-    return groupByMutation(data);
+    const overallMutationsData = (
+        await queryOverallMutationData({
+            lapisFilter,
+            sequenceType,
+            lapis,
+            lapisDateField,
+            granularity,
+        })
+    ).content;
+
+    return {
+        mutationOverTimeData: groupByMutation(data, overallMutationsData),
+        overallMutationData: overallMutationsData,
+    };
 }
 
 async function getDatesInDataset(
@@ -156,39 +207,55 @@ function fetchAndPrepareSubstitutionsOrDeletions(filter: LapisFilter, sequenceTy
     return new FetchSubstitutionsOrDeletionsOperator(filter, sequenceType, 0.001);
 }
 
-export function groupByMutation(data: MutationOverTimeData[]) {
-    const dataArray = new Map2dBase<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>(
-        (mutation) => mutation.code,
-        (date) => date.toString(),
-    );
+export function serializeSubstitutionOrDeletion(mutation: Substitution | Deletion) {
+    return mutation.code;
+}
 
-    data.forEach((mutationData) => {
-        mutationData.mutations.forEach((mutationEntry) => {
-            dataArray.set(mutationEntry.mutation, mutationData.date, {
-                count: mutationEntry.count,
-                proportion: mutationEntry.proportion,
-                totalCount: mutationData.totalCount,
+export function serializeTemporal(date: Temporal) {
+    return date.dateString;
+}
+
+export function groupByMutation(
+    data: MutationOverTimeData[],
+    overallMutationData: (SubstitutionEntry | DeletionEntry)[],
+) {
+    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, {
+                count: 0,
+                proportion: 0,
+                totalCount: 0,
             });
         });
     });
 
-    addZeroValuesForDatesWithNoMutationData(dataArray, data);
-
-    return dataArray;
-}
+    data.forEach((mutationData) => {
+        mutationData.mutations.forEach((mutationEntry) => {
+            const mutation = toSubstitutionOrDeletion(mutationEntry.mutation);
+            const date = toTemporal(mutationData.date);
 
-function addZeroValuesForDatesWithNoMutationData(
-    dataArray: Map2dBase<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, totalCount: 0 });
+            if (dataArray.get(mutation, date) !== undefined) {
+                dataArray.set(mutation, date, {
+                    count: mutationEntry.count,
+                    proportion: mutationEntry.proportion,
+                    totalCount: mutationData.totalCount,
+                });
             }
         });
-    }
+    });
+
+    return dataArray;
 }
 
 function getTotalNumberOfSequencesInDateRange(filter: LapisFilter) {

package/src/query/queryPrevalenceOverTime.ts

@@ -1,7 +1,7 @@
 import { queryAggregatedDataOverTime } from './queryAggregatedDataOverTime';
 import { DivisionOperator } from '../operator/DivisionOperator';
 import { type LapisFilter, type NamedLapisFilter, type TemporalGranularity } from '../types';
-import { type Temporal } from '../utils/temporal';
+import { type TemporalClass } from '../utils/temporalClass';
 import { makeArray } from '../utils/utils';
 
 export type PrevalenceOverTimeData = PrevalenceOverTimeVariantData[];
@@ -15,7 +15,7 @@ export type PrevalenceOverTimeVariantDataPoint = {
     count: number;
     prevalence: number;
     total: number;
-    dateRange: Temporal | null;
+    dateRange: TemporalClass | null;
 };
 
 export function queryPrevalenceOverTime(