@genspectrum/dashboard-components 1.3.0 → 1.4.0

package/src/query/queryMutationsOverTime.spec.ts

@@ -876,6 +876,104 @@ describe('queryMutationsOverTime', () => {
         expect(mutationOverTimeData.getAsArray()).to.deep.equal([[null]]);
     });
 
+    it('should respect the includeMutations parameter', 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',
+            displayMutations: ['otherSequenceName:G234C', 'A44T'],
+        });
+
+        expect(mutationOverTimeData.getAsArray()).to.deep.equal([
+            [
+                { type: 'belowThreshold', totalCount: 11 },
+                { type: 'belowThreshold', totalCount: 12 },
+            ],
+            [
+                { type: 'value', proportion: 0.4, count: 4, totalCount: 11 },
+                { type: 'belowThreshold', totalCount: 12 },
+            ],
+        ]);
+
+        const sequences = mutationOverTimeData.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('A44T');
+        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01');
+        expect(dates[1].dateString).toBe('2023-02');
+    });
+
     function getSomeTestMutation(proportion: number, count: number) {
         return {
             mutation: 'sequenceName:A123T',

package/src/query/queryMutationsOverTime.ts

@@ -18,7 +18,13 @@ import {
     type TemporalGranularity,
 } from '../types';
 import { type Map2DContents } from '../utils/map2d';
-import { type Deletion, type Substitution, toSubstitutionOrDeletion } from '../utils/mutations';
+import {
+    type Deletion,
+    type Substitution,
+    toSubstitutionOrDeletion,
+    DeletionClass,
+    SubstitutionClass,
+} from '../utils/mutations';
 import {
     compareTemporal,
     dateRangeCompare,
@@ -56,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;
@@ -69,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 = {
@@ -85,11 +133,27 @@ 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;
@@ -99,7 +163,8 @@ export type MutationOverTimeQuery = {
 };
 
 export async function queryMutationsOverTimeData(query: MutationOverTimeQuery) {
-    const { lapisFilter, sequenceType, lapis, lapisDateField, granularity, useNewEndpoint, signal } = query;
+    const { lapisFilter, displayMutations, sequenceType, lapis, lapisDateField, granularity, useNewEndpoint, signal } =
+        query;
 
     const requestedDateRanges = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
 
@@ -117,6 +182,7 @@ export async function queryMutationsOverTimeData(query: MutationOverTimeQuery) {
         sequenceType,
         lapis,
         lapisDateField,
+        includeMutations: displayMutations,
         granularity,
     }).then((r) => r.content);
 

package/src/query/queryMutationsOverTimeNewEndpoint.spec.ts

@@ -909,6 +909,128 @@ describe('queryMutationsOverTimeNewEndpoint', () => {
         expect(dates.length).toBe(0);
     });
 
+    it('should respect the includeMutations parameter', 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-02-28',
+                        minProportion: 0.001,
+                    },
+                    response: {
+                        data: [getSomeTestMutation(0.21, 6), getSomeOtherTestMutation(0.22, 4)],
+                    },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const dateRanges = [
+            {
+                dateFrom: '2023-01-01',
+                dateTo: '2023-01-31',
+            },
+            {
+                dateFrom: '2023-02-01',
+                dateTo: '2023-02-28',
+            },
+        ];
+
+        lapisRequestMocks.mutationsOverTime(
+            [
+                {
+                    body: {
+                        filters: lapisFilter,
+                        dateRanges,
+                        includeMutations: ['A122T', 'otherSequenceName:G234C'],
+                        dateField,
+                    },
+                    response: {
+                        data: {
+                            data: [
+                                [
+                                    { count: 0, coverage: 0 },
+                                    { count: 0, coverage: 0 },
+                                ],
+                                [
+                                    { count: 2, coverage: 10 },
+                                    { count: 3, coverage: 10 },
+                                ],
+                            ],
+                            dateRanges,
+                            mutations: ['A122T', 'otherSequenceName:G234C'],
+                        },
+                    },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const { mutationOverTimeData } = await queryMutationsOverTimeData({
+            lapisFilter,
+            sequenceType: 'nucleotide',
+            lapis: DUMMY_LAPIS_URL,
+            lapisDateField: dateField,
+            granularity: 'month',
+            useNewEndpoint: true,
+            displayMutations: ['otherSequenceName:G234C', 'A122T'],
+        });
+
+        expect(mutationOverTimeData.getAsArray()).to.deep.equal([
+            [
+                { type: 'value', proportion: NaN, count: 0, totalCount: 11 },
+                { type: 'value', proportion: NaN, count: 0, totalCount: 12 },
+            ],
+            [
+                { type: 'value', proportion: 0.2, count: 2, totalCount: 11 },
+                { type: 'value', proportion: 0.3, count: 3, totalCount: 12 },
+            ],
+        ]);
+
+        const sequences = mutationOverTimeData.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('A122T');
+        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+
+        const dates = mutationOverTimeData.getSecondAxisKeys();
+        expect(dates[0].dateString).toBe('2023-01');
+        expect(dates[1].dateString).toBe('2023-02');
+    });
+
     function getSomeTestMutation(proportion: number, count: number) {
         return {
             mutation: 'sequenceName:A123T',