Gene-specific chart finalized

Optimization to how groupsamples are created; by using the sample unique id we can create sampleidentifier

Author: i-am-leslie

src/pages/studyView/StudyViewPageStore.ts

@@ -186,6 +186,8 @@ import {
     transformSampleDataToSelectedSampleClinicalData,
     updateCustomIntervalFilter,
     invokeGenomicDataCount,
+    invokeGenomicDataCountIncludeSampleid,
+    groupSamplesByMutationStatus,
     invokeMutationDataCount,
     invokeNamespaceDataCount,
     invokeGenericAssayDataCount,
@@ -1635,6 +1637,81 @@ export class StudyViewPageStore
         });
     }
 
+    private createGeneSpecificComparisonSession(
+        chartMeta: ChartMeta,
+        clinicalAttributeValues: ClinicalDataCountSummary[],
+        statusCallback: (phase: LoadingPhase) => void
+    ): Promise<string> {
+        statusCallback(LoadingPhase.DOWNLOADING_GROUPS);
+
+        return new Promise<string>(resolve => {
+            onMobxPromise([this.selectedSamples], async () => {
+                const chartInfo = this._geneSpecificChartMap.get(
+                    chartMeta.uniqueKey
+                );
+                if (!chartInfo || !this.hasFilteredSamples) return;
+                const includeSampleIds = true;
+
+                const data: any[] = await invokeGenomicDataCountIncludeSampleid(
+                    chartInfo,
+                    this.filters,
+                    includeSampleIds
+                );
+
+                const lcValueToColor = _.keyBy(clinicalAttributeValues, d =>
+                    d.value.toLowerCase()
+                );
+
+                /**
+                 * Step 1:
+                 * Normalize counts into { group, SampleIdentifier } pairs
+                 */
+                const groupedSamples = groupSamplesByMutationStatus(
+                    data,
+                    this.studyIds
+                );
+
+                /**
+                 * Step 2:
+                 * Build SessionGroupData objects for each group, using the sample identifiers from step 1
+                 */
+                const groups: SessionGroupData[] = _.chain(
+                    clinicalAttributeValues
+                )
+                    .map(attrVal => {
+                        const sampleIdentifiers: SampleIdentifier[] =
+                            groupedSamples[attrVal.value];
+                        if (!sampleIdentifiers?.length) return null;
+
+                        return getGroupParameters(
+                            attrVal.value,
+                            sampleIdentifiers,
+                            this.studyIds,
+                            lcValueToColor[attrVal.value.toLowerCase()]?.color
+                        );
+                    })
+                    .compact()
+                    .slice(
+                        0,
+                        doesChartHaveComparisonGroupsLimit(chartMeta)
+                            ? MAX_GROUPS_IN_SESSION
+                            : undefined
+                    )
+                    .value();
+                statusCallback(LoadingPhase.CREATING_SESSION);
+
+                // create session and get id
+                const { id } = await comparisonClient.addComparisonSession({
+                    groups,
+                    clinicalAttributeName: chartMeta.displayName,
+                    origin: this.studyIds,
+                });
+
+                resolve(id);
+            });
+        });
+    }
+
     private createCnaGeneComparisonSession(
         chartMeta: ChartMeta,
         hugoGeneSymbols: string[],
@@ -2069,13 +2146,9 @@ export class StudyViewPageStore
                     chartMeta.uniqueKey
                 );
                 if (isGeneSpecificChart) {
-                    const chartInfo = this._geneSpecificChartMap.get(
-                        chartMeta.uniqueKey
-                    )!;
-
-                    comparisonId = await this.createCnaGeneComparisonSession(
+                    comparisonId = await this.createGeneSpecificComparisonSession(
                         chartMeta,
-                        [chartInfo.hugoGeneSymbol],
+                        params.clinicalAttributeValues!,
                         statusCallback
                     );
                 } else {

src/pages/studyView/StudyViewUtils.spec.tsx

@@ -66,6 +66,7 @@ import {
     updateCustomIntervalFilter,
     updateGeneQuery,
     updateSavedUserPreferenceChartIds,
+    groupSamplesByMutationStatus,
 } from 'pages/studyView/StudyViewUtils';
 import {
     CancerStudy,
@@ -3656,6 +3657,64 @@ describe('StudyViewUtils', () => {
         });
     });
 
+    describe.only('groupSamplesByMutationStatus', () => {
+        const data = [
+            {
+                counts: [
+                    {
+                        value: 'NOT_PROFILED',
+                        sampleIds: ['ignore_me_001'],
+                    },
+                ],
+            },
+            {
+                counts: [
+                    {
+                        value: 'Missense_Mutation',
+                        sampleIds: ['study_ABC_123', 'study_DEF_456'],
+                    },
+                ],
+            },
+            {
+                counts: [
+                    {
+                        value: 'NOT_MUTATED',
+                        sampleIds: ['study_GHI_789'],
+                    },
+                ],
+            },
+        ] as any;
+
+        const studyId: string[] = ['study_ABC', 'study_DEF', 'study_GHI'];
+
+        it('groups and creates SampleIdeifier  by mutation status correctly', () => {
+            const result = groupSamplesByMutationStatus(data, studyId);
+            assert.deepEqual(result, {
+                MUTATED: [
+                    {
+                        studyId: 'study_ABC',
+                        sampleId: '123',
+                    },
+                    {
+                        studyId: 'study_DEF',
+                        sampleId: '456',
+                    },
+                ],
+                NOT_MUTATED: [
+                    {
+                        studyId: 'study_GHI',
+                        sampleId: '789',
+                    },
+                ],
+            });
+        });
+
+        it('handles missing or empty counts safely', () => {
+            const emptyData = [{}, { counts: [] }];
+            expect(groupSamplesByMutationStatus(emptyData, [])).toEqual({});
+        });
+    });
+
     describe('getFilteredStudiesWithSamples', () => {
         const samples: Sample[] = [
             {

src/pages/studyView/StudyViewUtils.tsx

@@ -125,6 +125,7 @@ import { MultiSelectionTableRow } from './table/MultiSelectionTable';
 import Survival from 'pages/groupComparison/Survival';
 import { StructVarMultiSelectionTableRow } from './table/StructuralVariantMultiSelectionTable';
 import { ObservableMap } from 'mobx';
+import { boolean } from 'yargs';
 
 // Cannot use ClinicalDataTypeEnum here for the strong type. The model in the type is not strongly typed
 export enum ClinicalDataTypeEnum {
@@ -4252,6 +4253,78 @@ export async function invokeGenericAssayDataCount(
     return undefined;
 }
 
+export async function invokeGenomicDataCountIncludeSampleid(
+    chartInfo: GenomicChart,
+    filters: StudyViewFilter,
+    includeSampleIds: boolean
+) {
+    let result = [];
+    let params = {
+        genomicDataCountFilter: {
+            genomicDataFilters: [
+                {
+                    hugoGeneSymbol: chartInfo.hugoGeneSymbol,
+                    profileType: chartInfo.profileType,
+                } as GenomicDataFilter,
+            ],
+            studyViewFilter: filters,
+        },
+        $queryParameters: {
+            projection: 'DETAILED',
+            includeSampleIds,
+        },
+    } as any;
+
+    result = await getInternalClient().fetchMutationDataCountsUsingPOST(params);
+
+    return result;
+}
+
+export function groupSamplesByMutationStatus(data: any[], studyIds: string[]) {
+    const SKIP_VALUES = new Set(['NOT_PROFILED']);
+    const NON_MUTATION_VALUES = new Set(['NOT_MUTATED']);
+
+    return _.chain(data)
+        .flatMap(d => d.counts ?? [])
+        .filter(c => !SKIP_VALUES.has(c.value) && c.sampleIds?.length > 0) // avoid NOT_PROFILED samples and any bins without samples
+        .flatMap(c => {
+            const group = NON_MUTATION_VALUES.has(c.value)
+                ? c.value
+                : 'MUTATED';
+
+            return c.sampleIds
+                .map((rawId: string) => {
+                    // sampleIds are in the format of {studyId}_{sampleId}, need to be split before grouping
+                    const matchedStudyId = studyIds.find(studyId =>
+                        rawId.startsWith(studyId + '_')
+                    );
+
+                    if (!matchedStudyId) return null;
+                    // create an object with group, studyId and sampleId for each sampleId, where group is MUTATED or NOT_MUTATED based on the value of the bin it belongs to
+                    return {
+                        group,
+                        studyId: matchedStudyId,
+                        sampleId: rawId.substring(matchedStudyId.length + 1),
+                    };
+                })
+                .filter(Boolean);
+        })
+        .groupBy('group')
+        .mapValues(items =>
+            _.uniqBy(
+                // cretaes a sampleidentifier{sampleId, studyId} using the matched studyId and the rest of the rawId as sampleId
+                items.map(
+                    ({ studyId, sampleId }): SampleIdentifier => ({
+                        studyId,
+                        sampleId,
+                    })
+                ),
+                i => i.sampleId // if sample IDs aren't globally unique across studies, we may want to use both studyId and sampleId to determine uniqueness
+            )
+        )
+        .value();
+}
+
 export async function invokeGenomicDataCount(
     chartInfo: GenomicChart,
     filters: StudyViewFilter

src/pages/studyView/charts/ChartContainer.tsx

@@ -406,8 +406,7 @@ export class ChartContainer extends React.Component<IChartContainerProps, {}> {
             (this.props.promise.result.treatments ??
                 this.props.promise.result.patientTreatments ??
                 this.props.promise.result)!.length > 1 &&
-            COMPARISON_CHART_TYPES.indexOf(this.props.chartType) > -1 &&
-            !this.props.chartMeta.mutationOptionType
+            COMPARISON_CHART_TYPES.indexOf(this.props.chartType) > -1
         );
     }