jbrowse-plugin-msaview 2.8.1 → 2.9.0

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -1,6 +1,6 @@
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { launchMSA } from '../utils/msa';
-import { fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
+import { COMMON_SPECIES, fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
 /**
  * The no-search-job alternative to doLaunchBlast.
  *
@@ -18,7 +18,6 @@ import { fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils
  */
 export async function doLaunchOrthologs({ self, }) {
     const { taxId, taxa, geneCandidates, msaAlgorithm, proteinSequence } = self.orthologParams;
-    const cleanedSeq = cleanProteinSequence(proteinSequence);
     const onProgress = (arg) => {
         self.setProgress(arg);
     };
@@ -27,15 +26,33 @@ export async function doLaunchOrthologs({ self, }) {
     if (!resolved) {
         throw new Error(`Could not resolve any of ${geneCandidates.join(', ')} to an NCBI gene in taxon ${taxId}. Try the NCBI BLAST tab, which needs no gene identifier.`);
     }
-    // the query species is represented by the user's own transcript below
-    const wanted = new Set(taxa.filter(t => t !== taxId));
+    // The query row. The dialog always supplies it — it is the user's OWN
+    // selected transcript, which is what makes `connectedFeature` map genome
+    // coordinates through this row. A launch that has no transcript to translate
+    // (a session spec naming only a gene) falls back to NCBI's representative
+    // protein for the resolved gene, which is the same choice made for every
+    // other row, so the alignment is the one NCBI would build for that gene.
+    const representative = await fetchRepresentativeQueryProtein(resolved.geneId);
+    const cleanedSeq = proteinSequence
+        ? cleanProteinSequence(proteinSequence)
+        : representative?.sequence;
+    if (!cleanedSeq) {
+        throw new Error(`No query protein: none was supplied and NCBI returned no representative protein for gene ${resolved.geneId}.`);
+    }
+    // Every species the panel offers, when a launch names none. A spec that wants
+    // a narrower comparison says so; one that just wants "this gene across
+    // species" should not have to enumerate the list the dialog would have
+    // checked for it.
+    const wantedTaxa = taxa ?? COMMON_SPECIES.map(s => s.taxId);
+    // the query species is represented by the query row above
+    const wanted = new Set(wantedTaxa.filter(t => t !== taxId));
     const rows = await fetchOrthologRows({
         geneId: resolved.geneId,
         taxa: wanted,
         onProgress,
     });
     const treeMetadata = {
-        QUERY: await buildQueryMetadata(self, resolved.geneId, cleanedSeq),
+        QUERY: buildQueryMetadata(self, resolved.geneId, cleanedSeq, representative),
     };
     for (const row of rows) {
         treeMetadata[row.label] = buildRowMetadata(row);
@@ -54,31 +71,37 @@ export async function doLaunchOrthologs({ self, }) {
     };
 }
 /**
- * The query row is the user's own translated transcript, so it carries an
- * Accession — which is what drives the automatic CDD overlay
- * (afterCreateAutoruns.autoLoadProteinDomains -> loadProteinDomains) — ONLY
- * when its sequence is byte-identical to the RefSeq protein that accession
+ * A failed lookup only costs the query row its domain overlay and, for a launch
+ * that supplied no sequence of its own, the alignment — so it is reported by
+ * returning nothing rather than by throwing here.
+ */
+async function fetchRepresentativeQueryProtein(geneId) {
+    try {
+        return await fetchProteinForGene(geneId);
+    }
+    catch (e) {
+        console.warn('[msaview-orthologs] query protein lookup failed:', e);
+        return undefined;
+    }
+}
+/**
+ * The query row carries an Accession — which is what drives the automatic CDD
+ * overlay (afterCreateAutoruns.autoLoadProteinDomains -> loadProteinDomains) —
+ * ONLY when its sequence is byte-identical to the RefSeq protein that accession
  * names. Attaching it unconditionally would put every domain box at an offset
  * whenever the user picked a non-representative isoform, which is a silently
- * wrong figure rather than a missing one.
+ * wrong figure rather than a missing one. A launch that took the representative
+ * protein as its query row passes that test by construction.
  */
-async function buildQueryMetadata(self, geneId, proteinSequence) {
+function buildQueryMetadata(self, geneId, proteinSequence, representative) {
     const transcript = self.orthologParams?.selectedTranscript;
     const metadata = { 'Gene ID': geneId };
     const name = transcript?.get('name') ?? transcript?.get('id');
     if (name) {
         metadata.Transcript = name;
     }
-    try {
-        const representative = await fetchProteinForGene(geneId);
-        if (representative?.sequence === proteinSequence) {
-            metadata.Accession = representative.accession;
-        }
-    }
-    catch (e) {
-        // a failed lookup only costs the query row its domain overlay, so it must
-        // not take down an alignment that is otherwise complete
-        console.warn('[msaview-orthologs] query protein lookup failed:', e);
+    if (representative?.sequence === proteinSequence) {
+        metadata.Accession = representative.accession;
     }
     return metadata;
 }

package/dist/MsaViewPanel/doLaunchOrthologs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/MsaViewPanel/doLaunchOrthologs.test.js

@@ -0,0 +1,127 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { doLaunchOrthologs } from './doLaunchOrthologs';
+import { launchMSA } from '../utils/msa';
+import { COMMON_SPECIES, fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
+// Every network call is mocked and nothing else is. What is under test is the
+// argument shaping either side of those calls -- which taxa get asked for, what
+// becomes the QUERY row, and whether the row earns the Accession that drives the
+// CDD overlay -- so the real COMMON_SPECIES list and the real
+// cleanProteinSequence stay in the picture.
+vi.mock('../utils/ncbiOrthologs', async (importOriginal) => ({
+    ...(await importOriginal()),
+    resolveGeneId: vi.fn(),
+    fetchProteinForGene: vi.fn(),
+    fetchOrthologRows: vi.fn(),
+}));
+vi.mock('../utils/msa', () => ({ launchMSA: vi.fn() }));
+const mockResolveGeneId = vi.mocked(resolveGeneId);
+const mockFetchProtein = vi.mocked(fetchProteinForGene);
+const mockFetchRows = vi.mocked(fetchOrthologRows);
+const mockLaunchMSA = vi.mocked(launchMSA);
+const HUMAN = 9606;
+const GENE_ID = '22861';
+const REPRESENTATIVE = { accession: 'NP_127497.1', sequence: 'MAGGAWGRLACY' };
+function makeModel(orthologParams) {
+    return {
+        orthologParams,
+        setProgress: () => { },
+    };
+}
+function params(extra = {}) {
+    return {
+        taxId: HUMAN,
+        geneCandidates: ['NLRP1'],
+        msaAlgorithm: 'clustalo',
+        ...extra,
+    };
+}
+// What fetchOrthologRows was asked for, which is the only place the taxa
+// default is observable.
+function taxaAskedFor() {
+    return [...mockFetchRows.mock.calls[0][0].taxa].sort((a, b) => a - b);
+}
+// The QUERY row as it went to the aligner, read back out of the FASTA rather
+// than out of an intermediate, since the FASTA is what the alignment is of.
+function queryRowSent() {
+    return mockLaunchMSA.mock.calls[0][0].sequence.split('\n')[1];
+}
+function queryMetadata(result) {
+    return JSON.parse(result.treeMetadata).QUERY;
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockResolveGeneId.mockResolvedValue({ geneId: GENE_ID, matched: 'NLRP1' });
+    mockFetchProtein.mockResolvedValue(REPRESENTATIVE);
+    mockFetchRows.mockResolvedValue([]);
+    mockLaunchMSA.mockResolvedValue({ msa: '', tree: '' });
+});
+describe('taxa', () => {
+    test('omitted asks for every species the dialog offers, less the query', async () => {
+        await doLaunchOrthologs({ self: makeModel(params()) });
+        expect(taxaAskedFor()).toEqual(COMMON_SPECIES.map(s => s.taxId)
+            .filter(t => t !== HUMAN)
+            .sort((a, b) => a - b));
+    });
+    test('given is taken as written, less the query', async () => {
+        await doLaunchOrthologs({
+            self: makeModel(params({ taxa: [HUMAN, 10090, 9615] })),
+        });
+        expect(taxaAskedFor()).toEqual([9615, 10090]);
+    });
+    test('an empty list is a request for no rows, not a request for all of them', async () => {
+        await doLaunchOrthologs({ self: makeModel(params({ taxa: [] })) });
+        expect(taxaAskedFor()).toEqual([]);
+    });
+});
+describe('the QUERY row', () => {
+    test('omitted proteinSequence falls back to the representative protein', async () => {
+        await doLaunchOrthologs({ self: makeModel(params()) });
+        expect(queryRowSent()).toBe(REPRESENTATIVE.sequence);
+    });
+    test('a supplied sequence is used, and is cleaned first', async () => {
+        await doLaunchOrthologs({
+            self: makeModel(params({ proteinSequence: 'MAGG*AWGR&' })),
+        });
+        expect(queryRowSent()).toBe('MAGGAWGR');
+    });
+    test('throws when neither a sequence nor a representative is available', async () => {
+        mockFetchProtein.mockResolvedValue(undefined);
+        await expect(doLaunchOrthologs({ self: makeModel(params()) })).rejects.toThrow(/No query protein/);
+        expect(mockLaunchMSA).not.toHaveBeenCalled();
+    });
+    test('a failed representative lookup does not take down a launch that brought its own sequence', async () => {
+        vi.spyOn(console, 'warn').mockImplementation(() => { });
+        mockFetchProtein.mockRejectedValue(new Error('429'));
+        await doLaunchOrthologs({
+            self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
+        });
+        expect(queryRowSent()).toBe(REPRESENTATIVE.sequence);
+    });
+});
+// The Accession is what afterCreateAutoruns.autoLoadProteinDomains keys the CDD
+// overlay off, and attaching it to a row that is NOT the protein it names draws
+// every domain box at an offset. So the byte-identity guard is the assertion
+// here, in both directions.
+describe('the Accession that drives the domain overlay', () => {
+    test('is attached when the query row IS the representative protein', async () => {
+        const result = await doLaunchOrthologs({ self: makeModel(params()) });
+        expect(queryMetadata(result)).toMatchObject({
+            'Gene ID': GENE_ID,
+            Accession: REPRESENTATIVE.accession,
+        });
+    });
+    test('is withheld from a non-representative isoform', async () => {
+        const result = await doLaunchOrthologs({
+            self: makeModel(params({ proteinSequence: 'MDIFFERENTISOFORM' })),
+        });
+        expect(queryMetadata(result).Accession).toBeUndefined();
+    });
+    test('is withheld when the representative lookup failed', async () => {
+        vi.spyOn(console, 'warn').mockImplementation(() => { });
+        mockFetchProtein.mockRejectedValue(new Error('429'));
+        const result = await doLaunchOrthologs({
+            self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
+        });
+        expect(queryMetadata(result).Accession).toBeUndefined();
+    });
+});

package/dist/MsaViewPanel/model.d.ts

@@ -1,6 +1,6 @@
 export type { MSAFormat } from 'msa-parsers';
 import type { MafRegion, MsaViewInitState } from './types';
-import type { BlastDatabase, BlastProgram, MsaAlgorithm } from '../LaunchMsaView/components/NCBIBlastQuery/consts';
+import type { BlastDatabase, MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
 import type { Feature } from '@jbrowse/core/util';
 import type { Instance } from '@jbrowse/mobx-state-tree';
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
@@ -12,24 +12,32 @@ export interface IRegion {
     end: number;
 }
 export interface BlastParams {
-    baseUrl: string;
     blastDatabase: BlastDatabase;
     msaAlgorithm: MsaAlgorithm;
-    blastProgram: BlastProgram;
     selectedTranscript?: Feature;
     proteinSequence: string;
-    rid?: string;
 }
 export interface OrthologParams {
     /** NCBI taxon id of the assembly the query gene came from */
     taxId: number;
-    /** taxon ids to include as rows (the query taxon is represented by QUERY) */
-    taxa: number[];
+    /**
+     * taxon ids to include as rows (the query taxon is represented by QUERY).
+     * Omitted means every species the launch dialog offers, which is what a
+     * launch that just wants "this gene across species" wants.
+     */
+    taxa?: number[];
     /** candidate gene identifiers off the feature, tried in order */
     geneCandidates: string[];
     msaAlgorithm: MsaAlgorithm;
     selectedTranscript?: Feature;
-    proteinSequence: string;
+    /**
+     * The QUERY row. The launch dialog always supplies it, translated from the
+     * transcript the user picked, which is what `connectedFeature` maps genome
+     * coordinates through. Omitted — a session spec naming a gene and nothing
+     * else — the query row becomes NCBI's representative protein for the resolved
+     * gene, the same choice every other row makes.
+     */
+    proteinSequence?: string;
 }
 /**
  * #stateModel MsaViewPlugin