jbrowse-plugin-msaview 3.4.0 → 3.4.1

package/dist/MsaViewPanel/msaDataStore.test.js

@@ -0,0 +1,44 @@
+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(),
+    state: { putFails: false },
+}));
+vi.mock('../utils/idb', () => ({
+    createDbOpener: () => () => Promise.resolve({
+        get: (_store, id) => Promise.resolve(rows.get(id)),
+        put: (_store, value) => {
+            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/dist/MsaViewPanel/runLaunch.d.ts

@@ -0,0 +1,38 @@
+import type { JBrowsePluginMsaViewModel } from './model';
+/**
+ * What a launch is allowed to do to the model and to the network while it runs.
+ *
+ * Every write a launch makes goes through `act`, so "nothing touches the model
+ * once the launch has been abandoned" is one rule in one place. Spreading that
+ * guard across the call sites only takes one omission to undo: an abandoned
+ * launch keeps running until its next network hop rejects, and an action on a
+ * destroyed mobx-state-tree node throws where nothing is catching.
+ */
+export interface LaunchScope {
+    /** aborts when the user cancels, and when the view is destroyed */
+    signal: AbortSignal;
+    act: (fn: () => void) => void;
+    onProgress: (arg: string) => void;
+    /** the EBI job id, published before the first poll so the view can link out */
+    onRid: (arg: string) => void;
+}
+interface LaunchedData {
+    msa: string;
+    tree: string;
+    treeMetadata: string;
+}
+/**
+ * Run one launch attempt, owning the AbortController that ties it to the view.
+ *
+ * The controller lives on the model because two things end a launch and neither
+ * is here: the Cancel button, and the disposer `afterCreate` registers. Before
+ * it existed, closing a view mid-BLAST left the poller checking EBI for the
+ * job's lifetime and then writing to a node that was gone.
+ */
+export declare function runLaunch({ self, message, launch, onLaunched, }: {
+    self: JBrowsePluginMsaViewModel;
+    message: string;
+    launch: (scope: LaunchScope) => Promise<LaunchedData>;
+    onLaunched: () => void;
+}): void;
+export {};

package/dist/MsaViewPanel/runLaunch.js

@@ -0,0 +1,65 @@
+import { isAbortError } from '../utils/fetch';
+/**
+ * Run one launch attempt, owning the AbortController that ties it to the view.
+ *
+ * The controller lives on the model because two things end a launch and neither
+ * is here: the Cancel button, and the disposer `afterCreate` registers. Before
+ * it existed, closing a view mid-BLAST left the poller checking EBI for the
+ * job's lifetime and then writing to a node that was gone.
+ */
+export function runLaunch({ self, message, launch, onLaunched, }) {
+    const controller = new AbortController();
+    const { signal } = controller;
+    self.setLaunchController(controller);
+    const act = (fn) => {
+        if (!signal.aborted) {
+            fn();
+        }
+    };
+    const scope = {
+        signal,
+        act,
+        onProgress: arg => {
+            act(() => {
+                self.setProgress(arg);
+            });
+        },
+        onRid: arg => {
+            act(() => {
+                self.setRid(arg);
+            });
+        },
+    };
+    void (async () => {
+        try {
+            act(() => {
+                self.setProgress(message);
+                self.setError(undefined);
+            });
+            const data = await launch(scope);
+            act(() => {
+                self.setData(data);
+                onLaunched();
+            });
+        }
+        catch (e) {
+            // a cancel is not a failure: drawing the error panel for one would tell
+            // the user their launch broke when they are the one who stopped it
+            if (!isAbortError(e)) {
+                act(() => {
+                    self.setError(e);
+                });
+                console.error(e);
+            }
+        }
+        finally {
+            act(() => {
+                self.setProgress('');
+                // only if a later launch has not already claimed the slot
+                if (self.launchController === controller) {
+                    self.setLaunchController(undefined);
+                }
+            });
+        }
+    })();
+}

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

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

package/dist/MsaViewPanel/runLaunch.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, test, vi } from 'vitest';
+import { runLaunch } from './runLaunch';
+/**
+ * A model that records every write, so "no model actions after abort" is
+ * assertable rather than inferred. The real thing throws on a destroyed node;
+ * here a write that should not have happened simply shows up in the log.
+ */
+function makeModel() {
+    const writes = [];
+    const model = {
+        launchController: undefined,
+        setLaunchController(arg) {
+            model.launchController = arg;
+            writes.push(`setLaunchController:${arg ? 'set' : 'cleared'}`);
+        },
+        setProgress: (arg) => writes.push(`setProgress:${arg}`),
+        setError: (e) => writes.push(`setError:${e instanceof Error ? e.message : String(e)}`),
+        setRid: (arg) => writes.push(`setRid:${arg}`),
+        setData: () => writes.push('setData'),
+    };
+    return { model, writes };
+}
+const DATA = { msa: '>a\nMK', tree: '(a);', treeMetadata: '{}' };
+/** run the microtask queue out so the launch's async body has finished */
+const settle = () => new Promise(res => setTimeout(res, 0));
+describe('a launch that finishes', () => {
+    test('applies its data, clears its params and releases the controller', async () => {
+        const { model, writes } = makeModel();
+        const onLaunched = vi.fn();
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched,
+            launch: async (scope) => {
+                scope.onRid('ncbiblast-1');
+                scope.onProgress('Re-checking BLAST status in... 7');
+                return DATA;
+            },
+        });
+        await settle();
+        expect(writes).toEqual([
+            'setLaunchController:set',
+            'setProgress:Submitting query',
+            'setError:undefined',
+            'setRid:ncbiblast-1',
+            'setProgress:Re-checking BLAST status in... 7',
+            'setData',
+            'setProgress:',
+            'setLaunchController:cleared',
+        ]);
+        expect(onLaunched).toHaveBeenCalled();
+    });
+});
+// The failure this file exists for: closing a view mid-BLAST left the poller
+// running for the job's lifetime and then writing to a destroyed
+// mobx-state-tree node, whose throw surfaced as an unhandled rejection.
+describe('a launch that is abandoned', () => {
+    async function abandonMidFlight(reject) {
+        const { model, writes } = makeModel();
+        let released;
+        const held = new Promise(res => {
+            released = res;
+        });
+        let captured;
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched: () => {
+                throw new Error('a cancelled launch must not report success');
+            },
+            launch: async (scope) => {
+                captured = scope;
+                await held;
+                // what the network hop does once its signal is aborted: either it
+                // rejects with an AbortError, or it had already resolved and returns
+                if (reject) {
+                    throw new DOMException('Aborted', 'AbortError');
+                }
+                return DATA;
+            },
+        });
+        await settle();
+        const before = writes.length;
+        model.launchController.abort();
+        // everything the launch would still try to do after the abort
+        captured.onProgress('Re-checking BLAST status in... 3');
+        captured.onRid('ncbiblast-2');
+        captured.act(() => {
+            throw new Error('act must not run its callback after an abort');
+        });
+        released();
+        await settle();
+        return writes.slice(before);
+    }
+    test('nothing is written to the model once the abort lands', async () => {
+        expect(await abandonMidFlight(true)).toEqual([]);
+    });
+    test('a launch that resolved anyway still applies nothing', async () => {
+        expect(await abandonMidFlight(false)).toEqual([]);
+    });
+    test('an abort renders no error, so a cancel does not read as a failure', async () => {
+        const { model, writes } = makeModel();
+        runLaunch({
+            self: model,
+            message: 'Submitting query',
+            onLaunched: () => { },
+            launch: () => Promise.reject(new DOMException('Aborted', 'AbortError')),
+        });
+        await settle();
+        expect(writes.some(w => w.startsWith('setError:Aborted'))).toBe(false);
+    });
+});
+describe('a launch that fails', () => {
+    test('records the error and stops the spinner', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        const { model, writes } = makeModel();
+        runLaunch({
+            self: model,
+            message: 'Resolving orthologs',
+            onLaunched: () => {
+                throw new Error('a failed launch must not report success');
+            },
+            launch: () => Promise.reject(new Error('Only 1 ortholog(s) found')),
+        });
+        await settle();
+        expect(writes).toContain('setError:Only 1 ortholog(s) found');
+        expect(writes.at(-2)).toBe('setProgress:');
+    });
+});

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

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

package/dist/MsaViewPanel/storedData.test.js

@@ -0,0 +1,160 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { loadStoredData, storeDataToIndexedDB } from './afterCreateAutoruns';
+import { generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
+// IndexedDB itself is msaDataStore.test.ts's subject; what is under test here is
+// which writes these two autoruns decide to make.
+vi.mock('./msaDataStore', () => ({
+    cleanupOldData: vi.fn(),
+    generateDataStoreId: vi.fn(),
+    retrieveMsaData: vi.fn(),
+    storeMsaData: vi.fn(),
+}));
+const mockRetrieve = vi.mocked(retrieveMsaData);
+const mockStore = vi.mocked(storeMsaData);
+const mockGenerateId = vi.mocked(generateDataStoreId);
+const MSA = '>a\nMK';
+const NEW_ID = 'msa-generated';
+function makeModel(over = {}) {
+    const model = {
+        dataStoreId: undefined,
+        rows: [],
+        data: {},
+        msaFilehandle: undefined,
+        treeFilehandle: undefined,
+        isStoringData: false,
+        lastStoredData: undefined,
+        loadingStoredData: false,
+        error: undefined,
+        setDataStoreId(arg) {
+            model.dataStoreId = arg;
+        },
+        setIsStoringData(arg) {
+            model.isStoringData = arg;
+        },
+        setLastStoredData(arg) {
+            model.lastStoredData = arg;
+        },
+        setLoadingStoredData(arg) {
+            model.loadingStoredData = arg;
+        },
+        setError(arg) {
+            model.error = arg;
+        },
+        setMSA(arg) {
+            model.data.msa = arg;
+        },
+        setTree(arg) {
+            model.data.tree = arg;
+        },
+        setTreeMetadata(arg) {
+            model.data.treeMetadata = arg;
+        },
+        ...over,
+    };
+    return model;
+}
+const settle = () => new Promise(res => setTimeout(res, 0));
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockGenerateId.mockReturnValue(NEW_ID);
+    mockStore.mockResolvedValue(true);
+});
+describe('restoring a view from IndexedDB', () => {
+    test('a row that is still there is applied and recorded as stored', async () => {
+        mockRetrieve.mockResolvedValue({
+            msa: MSA,
+            tree: '(a);',
+            treeMetadata: '{}',
+        });
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.data.msa).toBe(MSA);
+        expect(model.error).toBeUndefined();
+        // recorded, so the store autorun does not write the restored data straight
+        // back out again
+        expect(model.lastStoredData).toEqual({
+            msa: MSA,
+            tree: '(a);',
+            treeMetadata: '{}',
+        });
+        model.rows = [['a', 'MK']];
+        storeDataToIndexedDB(model);
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+    // the row expires or the user clears site data, and the view used to reopen as
+    // a blank import form with no hint that anything had been lost
+    test('a row that is gone says so, in words that name the policy', async () => {
+        mockRetrieve.mockResolvedValue(undefined);
+        const model = makeModel({ dataStoreId: 'msa-1' });
+        loadStoredData(model);
+        await settle();
+        expect(model.error).toBeInstanceOf(Error);
+        expect(model.error.message).toMatch(/7 days/);
+        // the id names nothing now, so it goes -- otherwise react-msaview's "Return
+        // to import form" lands straight back on this error
+        expect(model.dataStoreId).toBeUndefined();
+    });
+});
+describe('keeping IndexedDB up to date', () => {
+    test('the first alignment is written under a fresh id', async () => {
+        const model = makeModel({ rows: [['a', 'MK']], data: { msa: MSA } });
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith(NEW_ID, { msa: MSA });
+        expect(model.dataStoreId).toBe(NEW_ID);
+        expect(model.isStoringData).toBe(false);
+    });
+    // react-msaview's "calculate neighbor-joining tree" replaces data.tree long
+    // after the first write; the row used to keep the alignment's original tree
+    // forever, so a reopened session restored a picture the user had replaced
+    test('an edit after the first write updates the existing row', async () => {
+        const model = makeModel({
+            dataStoreId: 'msa-1',
+            rows: [['a', 'MK']],
+            data: { msa: MSA, tree: '(a);' },
+            lastStoredData: { msa: MSA, tree: '(a);' },
+        });
+        storeDataToIndexedDB(model);
+        expect(mockStore).not.toHaveBeenCalled();
+        model.data.tree = '(a:0.1);';
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledWith('msa-1', {
+            msa: MSA,
+            tree: '(a:0.1);',
+            treeMetadata: undefined,
+        });
+        expect(model.dataStoreId).toBe('msa-1');
+    });
+    // a browser that refuses IndexedDB (private mode) answers every write the same
+    // way, and the autorun reruns on its own isStoringData flag -- so a write that
+    // is not recorded as attempted is a write that retries forever
+    test('a write that fails is not retried on the same data', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+        mockStore.mockResolvedValue(false);
+        const model = makeModel({ rows: [['a', 'MK']], data: { msa: MSA } });
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(model.dataStoreId).toBeUndefined();
+        storeDataToIndexedDB(model);
+        await settle();
+        expect(mockStore).toHaveBeenCalledTimes(1);
+    });
+    test('a view reading from a filehandle stores nothing, since the file is the source', () => {
+        storeDataToIndexedDB(makeModel({
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            msaFilehandle: { uri: 'msa.fa', locationType: 'UriLocation' },
+        }));
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+    test('a write already in flight is not duplicated', () => {
+        storeDataToIndexedDB(makeModel({
+            rows: [['a', 'MK']],
+            data: { msa: MSA },
+            isStoringData: true,
+        }));
+        expect(mockStore).not.toHaveBeenCalled();
+    });
+});