jbrowse-plugin-msaview 3.4.0 → 3.4.1

package/src/MsaViewPanel/doLaunchBlast.ts

@@ -13,28 +13,23 @@ import type {
   PhmmerDatabase,
 } from '../LaunchMsaView/components/BlastQuery/consts'
 import type { JBrowsePluginMsaViewModel } from './model'
+import type { LaunchScope } from './runLaunch'
 
 type TreeMetadata = Record<string, Record<string, string>>
 
 export async function doLaunchBlast({
   self,
+  scope,
 }: {
   self: JBrowsePluginMsaViewModel
+  scope: LaunchScope
 }) {
   // kept whole rather than destructured: the database's type depends on
   // searchProgram, and pulling the two apart loses the link between them
   const params = self.blastParams!
   const { selectedTranscript } = params
   const cleanedSeq = cleanProteinSequence(params.proteinSequence)
-
-  const onProgress = (arg: string) => {
-    self.setProgress(arg)
-  }
-  // publish the job id before the first poll so the view can link out while the
-  // job is still running
-  const onRid = (r: string) => {
-    self.setRid(r)
-  }
+  const { onProgress, onRid, signal } = scope
 
   const { msa, tree, treeMetadata, rid } =
     params.searchProgram === 'phmmer'
@@ -43,6 +38,7 @@ export async function doLaunchBlast({
           database: params.blastDatabase,
           onProgress,
           onRid,
+          signal,
         })
       : await runBlast({
           query: cleanedSeq,
@@ -50,6 +46,7 @@ export async function doLaunchBlast({
           msaAlgorithm: params.msaAlgorithm,
           onProgress,
           onRid,
+          signal,
         })
 
   const treeMetadataJson = JSON.stringify(treeMetadata)
@@ -86,18 +83,21 @@ async function runBlast({
   msaAlgorithm,
   onProgress,
   onRid,
+  signal,
 }: {
   query: string
   blastDatabase: BlastDatabase
   msaAlgorithm: MsaAlgorithm
   onProgress: (arg: string) => void
   onRid: (arg: string) => void
+  signal?: AbortSignal
 }) {
   const { hits, rid } = await queryEbiBlast({
     query,
     blastDatabase,
     onProgress,
     onRid,
+    signal,
   })
 
   onProgress('Fetching species taxonomy info...')
@@ -123,6 +123,7 @@ async function runBlast({
     algorithm: msaAlgorithm,
     sequence: [`>QUERY\n${query}`, ...sequences].join('\n'),
     onProgress,
+    signal,
   })
   return { ...result, treeMetadata, rid }
 }
@@ -139,17 +140,20 @@ async function runPhmmer({
   database,
   onProgress,
   onRid,
+  signal,
 }: {
   query: string
   database: PhmmerDatabase
   onProgress: (arg: string) => void
   onRid: (arg: string) => void
+  signal?: AbortSignal
 }) {
   const { rows, queryRow, rid } = await queryPhmmer({
     query,
     database,
     onProgress,
     onRid,
+    signal,
   })
 
   onProgress('Fetching species taxonomy info...')
@@ -164,7 +168,7 @@ async function runPhmmer({
   })
   return {
     msa,
-    tree: await launchTree({ alignment: msa, onProgress }),
+    tree: await launchTree({ alignment: msa, onProgress, signal }),
     treeMetadata,
     rid,
   }

package/src/MsaViewPanel/doLaunchOrthologs.test.ts

@@ -47,11 +47,26 @@ const setQuerySeqName = vi.fn()
 function makeModel(orthologParams: Record<string, unknown>) {
   return {
     orthologParams,
-    setProgress: () => {},
     setQuerySeqName,
   } as unknown as JBrowsePluginMsaViewModel
 }
 
+// a scope that never cancels, so these tests see the launch's own behaviour --
+// what the scope does when it IS cancelled is runLaunch.test.ts's subject
+function launch({ self }: { self: JBrowsePluginMsaViewModel }) {
+  return doLaunchOrthologs({
+    self,
+    scope: {
+      signal: new AbortController().signal,
+      act: fn => {
+        fn()
+      },
+      onProgress: () => {},
+      onRid: () => {},
+    },
+  })
+}
+
 function params(extra: Record<string, unknown> = {}) {
   return {
     taxId: HUMAN,
@@ -105,12 +120,12 @@ beforeEach(() => {
 
 describe('which species become rows', () => {
   test('omitted taxa asks for no restriction at all, which is every ortholog NCBI has', async () => {
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(rowRequest().taxa).toBeUndefined()
   })
 
   test('given taxa is taken as written', async () => {
-    await doLaunchOrthologs({
+    await launch({
       self: makeModel(params({ taxa: [HUMAN, 10090, 9615] })),
     })
     expect(rowRequest().taxa).toEqual([9606, 9615, 10090])
@@ -120,21 +135,21 @@ describe('which species become rows', () => {
   // and "the query row already covers this one" stay separable -- an unrestricted
   // launch still has to drop the query species.
   test('the query species is excluded whether or not taxa was given', async () => {
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(rowRequest().exclude).toBe(HUMAN)
     vi.clearAllMocks()
     mockResolveGeneId.mockResolvedValue({ geneId: GENE_ID, matched: 'NLRP1' })
     mockFetchProtein.mockResolvedValue(REPRESENTATIVE)
     mockFetchRows.mockResolvedValue([] as OrthologRow[])
     mockLaunchMSA.mockResolvedValue({ msa: '', tree: '' })
-    await doLaunchOrthologs({
+    await launch({
       self: makeModel(params({ taxa: [HUMAN, 10090] })),
     })
     expect(rowRequest().exclude).toBe(HUMAN)
   })
 
   test('an empty list is a request for no rows, not a request for all of them', async () => {
-    await doLaunchOrthologs({ self: makeModel(params({ taxa: [] })) })
+    await launch({ self: makeModel(params({ taxa: [] })) })
     expect(rowRequest().taxa).toEqual([])
   })
 })
@@ -144,12 +159,12 @@ describe('which species become rows', () => {
 // second a row.
 describe('the row cap', () => {
   test('is passed through when given', async () => {
-    await doLaunchOrthologs({ self: makeModel(params({ maxSpecies: 12 })) })
+    await launch({ self: makeModel(params({ maxSpecies: 12 })) })
     expect(rowRequest().limit).toBe(12)
   })
 
   test('omitted leaves the default to fetchOrthologGenes rather than sending Infinity', async () => {
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(rowRequest().limit).toBeUndefined()
     expect(defaultMaxSpecies).toBeGreaterThan(2)
   })
@@ -161,7 +176,7 @@ describe('the row cap', () => {
 // model's querySeqName and the header have to be the same string.
 describe('the query row name', () => {
   test('is the species, marked, rather than a bare QUERY among named rows', async () => {
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(queryRowName()).toBe('human_query')
     expect(setQuerySeqName).toHaveBeenCalledWith('human_query')
   })
@@ -170,7 +185,7 @@ describe('the query row name', () => {
     mockFetchRows.mockResolvedValue([
       { label: 'human_query', sequence: 'MM' },
     ] as OrthologRow[])
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(queryRowName()).toBe('human_query_2')
     expect(setQuerySeqName).toHaveBeenCalledWith('human_query_2')
   })
@@ -178,12 +193,12 @@ describe('the query row name', () => {
   test('falls back rather than throwing when NCBI cannot name the taxon', async () => {
     vi.spyOn(console, 'warn').mockImplementation(() => {})
     mockFetchTaxonomy.mockRejectedValue(new Error('429'))
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(queryRowName()).toBe('query_query')
   })
 
   test('the metadata that drives the domain overlay is keyed to that same name', async () => {
-    const result = await doLaunchOrthologs({ self: makeModel(params()) })
+    const result = await launch({ self: makeModel(params()) })
     expect(Object.keys(JSON.parse(result.treeMetadata))).toContain(
       'human_query',
     )
@@ -192,12 +207,12 @@ describe('the query row name', () => {
 
 describe('the query row sequence', () => {
   test('omitted proteinSequence falls back to the representative protein', async () => {
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(queryRowSent()).toBe(REPRESENTATIVE.sequence)
   })
 
   test('a supplied sequence is used, and is cleaned first', async () => {
-    await doLaunchOrthologs({
+    await launch({
       self: makeModel(params({ proteinSequence: 'MAGG*AWGR&' })),
     })
     expect(queryRowSent()).toBe('MAGGAWGR')
@@ -205,16 +220,16 @@ describe('the query row sequence', () => {
 
   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/)
+    await expect(launch({ 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({
+    await launch({
       self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
     })
     expect(queryRowSent()).toBe(REPRESENTATIVE.sequence)
@@ -227,7 +242,7 @@ describe('the query row sequence', () => {
 // 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()) })
+    const result = await launch({ self: makeModel(params()) })
     expect(queryMetadata(result)).toMatchObject({
       'Gene ID': GENE_ID,
       Accession: REPRESENTATIVE.accession,
@@ -235,7 +250,7 @@ describe('the Accession that drives the domain overlay', () => {
   })
 
   test('is withheld from a non-representative isoform', async () => {
-    const result = await doLaunchOrthologs({
+    const result = await launch({
       self: makeModel(params({ proteinSequence: 'MDIFFERENTISOFORM' })),
     })
     expect(queryMetadata(result).Accession).toBeUndefined()
@@ -244,7 +259,7 @@ describe('the Accession that drives the domain overlay', () => {
   test('is withheld when the representative lookup failed', async () => {
     vi.spyOn(console, 'warn').mockImplementation(() => {})
     mockFetchProtein.mockRejectedValue(new Error('429'))
-    const result = await doLaunchOrthologs({
+    const result = await launch({
       self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
     })
     expect(queryMetadata(result).Accession).toBeUndefined()
@@ -286,13 +301,13 @@ describe('the PANTHER source', () => {
   })
 
   test('source omitted is NCBI, so an old launch never reaches PANTHER', async () => {
-    await doLaunchOrthologs({ self: makeModel(params()) })
+    await launch({ self: makeModel(params()) })
     expect(mockFetchPanther).not.toHaveBeenCalled()
     expect(mockResolveGeneId).toHaveBeenCalled()
   })
 
   test('source panther asks PANTHER with the same species semantics, and skips NCBI', async () => {
-    await doLaunchOrthologs({
+    await launch({
       self: makeModel({
         taxId: YEAST,
         source: 'panther',
@@ -314,7 +329,7 @@ describe('the PANTHER source', () => {
   })
 
   test("the query row is PANTHER's own entry for the gene when no sequence was supplied, and carries its UniProt accession for the domain overlay", async () => {
-    const result = await doLaunchOrthologs({
+    const result = await launch({
       self: makeModel({
         taxId: YEAST,
         source: 'panther',
@@ -335,7 +350,7 @@ describe('the PANTHER source', () => {
   })
 
   test('a supplied sequence still wins, and a different isoform earns no Accession', async () => {
-    const result = await doLaunchOrthologs({
+    const result = await launch({
       self: makeModel({
         taxId: YEAST,
         source: 'panther',
@@ -351,7 +366,7 @@ describe('the PANTHER source', () => {
   test('names PANTHER when it has no protein for the query row', async () => {
     mockFetchPanther.mockResolvedValue({ ...found, query: undefined })
     await expect(
-      doLaunchOrthologs({
+      launch({
         self: makeModel({
           taxId: YEAST,
           source: 'panther',

package/src/MsaViewPanel/doLaunchOrthologs.ts

@@ -11,6 +11,7 @@ import { fetchTaxonomyInfo } from '../utils/taxonomyNames'
 
 import type { OrthologRow } from '../utils/ncbiOrthologs'
 import type { JBrowsePluginMsaViewModel } from './model'
+import type { LaunchScope } from './runLaunch'
 
 interface Representative {
   accession: string
@@ -44,8 +45,10 @@ interface FoundOrthologs {
  */
 export async function doLaunchOrthologs({
   self,
+  scope,
 }: {
   self: JBrowsePluginMsaViewModel
+  scope: LaunchScope
 }) {
   const {
     taxId,
@@ -57,9 +60,7 @@ export async function doLaunchOrthologs({
     source = 'ncbi',
   } = self.orthologParams!
 
-  const onProgress = (arg: string) => {
-    self.setProgress(arg)
-  }
+  const { onProgress, act, signal } = scope
 
   const request = {
     taxId,
@@ -103,7 +104,9 @@ export async function doLaunchOrthologs({
   // token, and a collision would silently point the coordinate mapping at
   // another animal's row.
   const queryLabel = await queryRowLabel(taxId, rows)
-  self.setQuerySeqName(queryLabel)
+  act(() => {
+    self.setQuerySeqName(queryLabel)
+  })
 
   const treeMetadata: Record<string, Record<string, string>> = {
     [queryLabel]: buildQueryMetadata(self, geneId, cleanedSeq, representative),
@@ -119,6 +122,7 @@ export async function doLaunchOrthologs({
       ...rows.map(r => `>${r.label}\n${r.sequence}`),
     ].join('\n'),
     onProgress,
+    signal,
   })
 
   return {

package/src/MsaViewPanel/model.ts

@@ -30,6 +30,7 @@ import type {
   MsaAlgorithm,
   PhmmerDatabase,
 } from '../LaunchMsaView/components/BlastQuery/consts'
+import type { MsaDataPayload } from './msaDataStore'
 import type { MafRegion, MsaViewInitState } from './types'
 import type { Feature } from '@jbrowse/core/util'
 import type { Instance } from '@jbrowse/mobx-state-tree'
@@ -188,6 +189,8 @@ export default function stateModelFactory() {
         error: unknown
         loadingStoredData: boolean
         isStoringData: boolean
+        lastStoredData: MsaDataPayload | undefined
+        launchController: AbortController | undefined
         domainsRequested: boolean
       } => ({
         /**
@@ -210,6 +213,21 @@ export default function stateModelFactory() {
          * #volatile
          */
         isStoringData: false,
+        /**
+         * #volatile
+         * what IndexedDB was last known to hold for this view, so an edit made
+         * after the first write (react-msaview replacing data.tree with a
+         * neighbor-joining tree, say) is recognized as needing a new one
+         */
+        lastStoredData: undefined,
+        /**
+         * #volatile
+         * aborts the launch currently in flight -- from the Cancel button, and
+         * from the disposer afterCreate registers, so a closed view stops
+         * polling EBI instead of running to completion and writing to a node
+         * that is gone
+         */
+        launchController: undefined,
         /**
          * #volatile
          * guards the one-shot auto-fetch of protein domains so it doesn't refire
@@ -231,7 +249,7 @@ export default function stateModelFactory() {
        * #method
        */
       getSequenceByRowName(rowName: string) {
-        return self.rows.find(r => r[0] === rowName)?.[1]
+        return this.getRowByName(rowName)?.[1]
       },
     }))
 
@@ -370,6 +388,35 @@ export default function stateModelFactory() {
       setIsStoringData(arg: boolean) {
         self.isStoringData = arg
       },
+      /**
+       * #action
+       */
+      setLastStoredData(arg?: MsaDataPayload) {
+        self.lastStoredData = arg
+      },
+      /**
+       * #action
+       */
+      setLaunchController(arg?: AbortController) {
+        self.launchController = arg
+      },
+      /**
+       * #action
+       * Abandon the launch in flight. The EBI job keeps running on their side —
+       * nothing here can recall it, and its JobLink stays valid — so this only
+       * stops the polling and the writes it would make. Dropping the params is
+       * what keeps the request from refiring; the view falls back to the import
+       * form, which is where react-msaview's own cancel leaves it too.
+       */
+      cancelLaunch() {
+        self.launchController?.abort()
+        self.launchController = undefined
+        self.blastParams = undefined
+        self.orthologParams = undefined
+        self.progress = ''
+        self.rid = undefined
+        self.error = undefined
+      },
       /**
        * #action
        */
@@ -434,6 +481,12 @@ export default function stateModelFactory() {
     .actions(self => ({
       afterCreate() {
         runCleanup()
+        // ties the launch to the view: closing one mid-BLAST used to leave the
+        // poller running for the job's lifetime and then call actions on a
+        // destroyed node, which surfaced as an unhandled rejection
+        addDisposer(self, () => {
+          self.launchController?.abort()
+        })
         for (const fn of [
           loadStoredData,
           storeDataToIndexedDB,

package/src/MsaViewPanel/msaDataStore.test.ts

@@ -0,0 +1,54 @@
+import { beforeEach, expect, test, vi } from 'vitest'
+
+import { retrieveMsaData } from './msaDataStore'
+
+// An in-memory stand-in for the one object store this module opens, with a
+// switch for the write half so a browser that refuses writes can be played back.
+const { rows, state } = vi.hoisted(() => ({
+  rows: new Map<string, { id: string; msa?: string; timestamp: number }>(),
+  state: { putFails: false },
+}))
+
+vi.mock('../utils/idb', () => ({
+  createDbOpener: () => () =>
+    Promise.resolve({
+      get: (_store: string, id: string) => Promise.resolve(rows.get(id)),
+      put: (_store: string, value: { id: string; timestamp: number }) => {
+        if (state.putFails) {
+          return Promise.reject(new Error('QuotaExceededError'))
+        }
+        rows.set(value.id, value)
+        return Promise.resolve(value.id)
+      },
+    }),
+}))
+
+beforeEach(() => {
+  rows.clear()
+  state.putFails = false
+})
+
+// cleanupOldData deletes by timestamp, so without this a session opened every
+// single day still lost its alignment on the eighth
+test('reading a row refreshes its timestamp, making the expiry "unused for 7 days"', async () => {
+  rows.set('msa-1', { id: 'msa-1', msa: '>a\nMK', timestamp: 1000 })
+  const before = Date.now()
+
+  expect((await retrieveMsaData('msa-1'))?.msa).toBe('>a\nMK')
+  expect(rows.get('msa-1')!.timestamp).toBeGreaterThanOrEqual(before)
+})
+
+test('a row that is no longer there reads as undefined and writes nothing', async () => {
+  expect(await retrieveMsaData('msa-gone')).toBeUndefined()
+  expect(rows.size).toBe(0)
+})
+
+// the refresh is housekeeping; failing it must not turn a readable alignment
+// into a missing one, which is what the caller reports as expired
+test('a refresh that fails still hands back the data it read', async () => {
+  vi.spyOn(console, 'warn').mockImplementation(() => {})
+  rows.set('msa-1', { id: 'msa-1', msa: '>a\nMK', timestamp: 1000 })
+  state.putFails = true
+
+  expect((await retrieveMsaData('msa-1'))?.msa).toBe('>a\nMK')
+})

package/src/MsaViewPanel/msaDataStore.ts

@@ -6,11 +6,15 @@ const DB_NAME = 'jbrowse-msaview-data'
 const DB_VERSION = 1
 const STORE_NAME = 'msa-data'
 
-interface StoredMsaData {
-  id: string
+/** the documents a view keeps in IndexedDB rather than in its session snapshot */
+export interface MsaDataPayload {
   msa?: string
   tree?: string
   treeMetadata?: string
+}
+
+interface StoredMsaData extends MsaDataPayload {
+  id: string
   timestamp: number
 }
 
@@ -33,10 +37,7 @@ export function generateDataStoreId() {
   return `msa-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`
 }
 
-export async function storeMsaData(
-  id: string,
-  data: { msa?: string; tree?: string; treeMetadata?: string },
-) {
+export async function storeMsaData(id: string, data: MsaDataPayload) {
   try {
     const db = await getDB()
     const storedData: StoredMsaData = {
@@ -58,14 +59,22 @@ export async function retrieveMsaData(id: string) {
   try {
     const db = await getDB()
     const result = await db.get(STORE_NAME, id)
-    if (result) {
-      return {
-        msa: result.msa,
-        tree: result.tree,
-        treeMetadata: result.treeMetadata,
-      }
+    if (!result) {
+      return undefined
+    }
+    // reading counts as use, which is what makes cleanupOldData's policy
+    // "unused for 7 days" rather than "written 7 days ago" -- a session opened
+    // every day used to lose its alignment on the eighth
+    try {
+      await db.put(STORE_NAME, { ...result, timestamp: Date.now() })
+    } catch (e) {
+      console.warn('Failed to refresh MSA data timestamp:', e)
+    }
+    return {
+      msa: result.msa,
+      tree: result.tree,
+      treeMetadata: result.treeMetadata,
     }
-    return undefined
   } catch (e) {
     console.warn('Failed to retrieve MSA data:', e)
     return undefined