@opencloning/opencloningdb 1.9.1 → 2.2.0

package/src/sequencing_check/SequencingCheckModal.cy.jsx

@@ -0,0 +1,258 @@
+import React from 'react';
+import { ConfigProvider } from '@opencloning/ui/providers/ConfigProvider';
+import { convertToTeselaJson } from '@opencloning/utils/readNwrite';
+import SequencingCheckModal from './SequencingCheckModal';
+import { formatSequenceName } from '../common';
+
+const BACKEND_URL = 'http://localhost:8000';
+const testConfig = { backendUrl: BACKEND_URL, showAppBar: false, noExternalRequests: true, enableAssembler: false, enablePlannotate: false };
+const ALIGN_DELAY = 500;
+
+// Short reads, aligned with a stubbed response, the value is the expected identity
+const READS = {
+  AAAAAAAAAA: { alignment: ['AAAAAAAAAA', 'AAAAAAAAAA'], identity: '100.00' },
+  CCCCCCCCCC: { alignment: ['CCCCCCCCCC', 'CCCCCCCCC-'], identity: '90.00' },
+  GGGGGGGGGG: { alignment: ['GGGGGGGGGG', 'GGGGGGGGGA'], identity: '90.00' },
+  TTTTTTTTTT: { alignment: ['TTTTTTTTTTTTTTTTTTTT', 'TTTTTTTTTTTTTTTTT---'], identity: '85.00' },
+  ACGTACGTAC: { alignment: ['ACGTACGTAC', '--GTACGTAC'], identity: '80.00' },
+};
+
+/** Pick the sequences with the gibson_assembly tag in the bulk component. */
+function loadSequencesByTag() {
+  cy.wait('@getTags');
+  // Like clickMultiSelectOption, but the menu is closed with Escape (the page body has no size behind the modal)
+  cy.get('[data-testid="sequencing-check-modal"]').contains('label', 'Tags').siblings('div').first().click();
+  cy.get('div[role="presentation"]').contains('gibson_assembly').click();
+  cy.focused().type('{esc}');
+  cy.contains('button', 'Load sequences').click();
+  cy.wait('@getSequences');
+}
+
+describe('<SequencingCheckModal />', () => {
+  beforeEach(() => {
+    cy.setupOpenCloningDBTestAuth();
+    cy.interceptOpenCloningDBStub('get_tags', { alias: 'getTags' });
+    cy.interceptOpenCloningDBStub('get_text_file_sequences_by_tag', { alias: 'getSequences' });
+  });
+
+  it('checks the sequencing files of the sequences and sorts them by identity', () => {
+    cy.viewport(1400, 900);
+    cy.getStub('get_text_file_sequences_by_tag').then((stub) => {
+      // pREP42-MCS+ (28, circular), NC_003424 (29), ase1_CDS (30), digested_vector (31), pREP42-ase1 (32)
+      const [plasmid] = stub.response.body;
+      const plasmidSeguid = plasmid.sequence_ref.seguid;
+      const plasmidBases = convertToTeselaJson(plasmid.sequence).sequence.toUpperCase();
+      // Same length as the plasmid, one base changed: the seguid does not match, so it is aligned
+      const mutantBases = (plasmidBases[0] === 'A' ? 'C' : 'A') + plasmidBases.slice(1);
+
+      const files = {
+        1: { name: 'exact.fa', sequence: plasmidBases },
+        2: { name: 'mutant.fa', sequence: mutantBases },
+        3: { name: 'ase1_read.fa', sequence: 'ACGTACGTAC' },
+        4: { name: 'read_a.fa', sequence: 'AAAAAAAAAA' },
+        5: { name: 'read_c.fa', sequence: 'CCCCCCCCCC' },
+        6: { name: 'read_g.fa', sequence: 'GGGGGGGGGG' },
+        7: { name: 'read_t.fa', sequence: 'TTTTTTTTTT' },
+        8: { name: 'broken.fa', sequence: 'ACGTTGCAAC' },
+      };
+      const filesBySequenceId = { 28: [1, 2], 29: [], 30: [3], 31: [4, 5, 6, 7], 32: [8] };
+
+      cy.intercept('GET', Cypress.getDbURL('/sequences/*/sequencing_files'), (req) => {
+        const sequenceId = Number(req.url.split('/').at(-2));
+        req.reply(filesBySequenceId[sequenceId].map((id) => ({ id, original_name: files[id].name }))); // eslint-disable-line camelcase
+      }).as('getSequencingFiles');
+      cy.intercept('GET', Cypress.getDbURL('/sequencing_files/*/download'), (req) => {
+        const file = files[Number(req.url.split('/').at(-2))];
+        req.reply({ body: `>${file.name}\n${file.sequence}\n`, headers: { 'content-type': 'application/octet-stream' } });
+      }).as('downloadFile');
+
+      const seguidRequests = [];
+      cy.intercept('POST', `${BACKEND_URL}/seguid`, (req) => {
+        seguidRequests.push(req.body);
+        req.reply(JSON.stringify(req.body.sequence.toUpperCase() === plasmidBases ? plasmidSeguid : 'cdseguid=something_else'));
+      }).as('seguid');
+
+      const alignStarts = [];
+      const alignedTraces = [];
+      cy.intercept('POST', `${BACKEND_URL}/align_sanger`, (req) => {
+        alignStarts.push(Date.now());
+        const trace = req.body.traces[0].toUpperCase();
+        alignedTraces.push(trace);
+        if (trace === 'ACGTTGCAAC') {
+          req.reply({ statusCode: 400, body: { detail: 'Alignment failed' }, delay: ALIGN_DELAY });
+        } else if (trace === mutantBases) {
+          req.reply({ body: ['ACGT', 'ACGA'], delay: ALIGN_DELAY });
+        } else if (trace === plasmidBases) {
+          // Only aligned when the exact match is viewed
+          req.reply({ body: [plasmidBases, plasmidBases], delay: ALIGN_DELAY });
+        } else {
+          req.reply({ body: READS[trace].alignment, delay: ALIGN_DELAY });
+        }
+      }).as('alignSanger');
+
+      cy.mount(
+        <ConfigProvider config={testConfig}>
+          <SequencingCheckModal open onClose={() => {}} />
+        </ConfigProvider>,
+      );
+
+      // Pick the sequences with the bulk component
+      loadSequencesByTag();
+
+      // Before the check: sequences in the original order, the one without files last
+      cy.get('[data-testid="sequencing-check-sequence-cell"]').should('have.length', 5);
+      cy.get('[data-testid="sequencing-check-file-row"]').should('have.length', 8);
+      cy.get('[data-testid="sequencing-check-empty-row"]').should('have.length', 1).and('contain', 'NC_003424').and('contain', 'No sequencing data');
+      cy.get('[data-testid="sequencing-check-sequence-cell"]').last().should('contain', 'NC_003424');
+      // The sequence cell spans the rows of its files
+      cy.get('[data-testid="sequencing-check-sequence-cell"]').first().should('contain', 'pREP42-MCS+').and('have.attr', 'rowspan', '2');
+      cy.get('@seguid.all').should('have.length', 0);
+      cy.get('@alignSanger.all').should('have.length', 0);
+
+      cy.get('[data-testid="sequencing-check-run-button"]').click();
+      cy.get('[data-testid="status-icon-pending"]').should('exist');
+      cy.get('[data-testid="sequencing-check-progress"]', { timeout: 10000 }).should('contain', '8 / 8');
+      cy.get('[data-testid="sequencing-check-run-button"]').should('not.be.disabled');
+
+      // Sorted: error first, then lowest identity first, no sequencing data last
+      const namesById = Object.fromEntries(stub.response.body.map(({ sequence_ref: ref }) => [ref.id, formatSequenceName(ref)]));
+      const expectedOrder = [32, 28, 30, 31, 29].map((id) => namesById[id]);
+      cy.get('[data-testid="sequencing-check-sequence-cell"]').should(($cells) => {
+        const cells = $cells.toArray();
+        expect(cells.map((cell) => cell.querySelector('[data-testid="sequencing-check-sequence-name"]').innerText)).to.deep.equal(expectedOrder);
+        expect(cells.map((cell) => cell.rowSpan)).to.deep.equal([1, 2, 1, 4, 1]);
+      });
+
+      // Files sorted within each sequence, the exact match was found by seguid
+      const expectedFiles = [
+        ['broken.fa', ''],
+        ['mutant.fa', '75.00'],
+        ['exact.fa', '100.00'],
+        ['ase1_read.fa', '80.00'],
+        ['read_t.fa', '85.00'],
+        ['read_c.fa', '90.00'],
+        ['read_g.fa', '90.00'],
+        ['read_a.fa', '100.00'],
+      ];
+      cy.get('[data-testid="sequencing-check-file-row"]').should(($rows) => {
+        const actual = $rows.toArray().map((row) => [
+          row.querySelector('[data-testid="sequencing-check-file-name"]').innerText.trim(),
+          row.querySelector('[data-testid="sequencing-check-identity"]').innerText.trim(),
+        ]);
+        expect(actual).to.deep.equal(expectedFiles);
+      });
+      cy.get('[data-testid="sequencing-check-file-row"]').first().should('contain', 'Alignment failed');
+      cy.get('[data-testid="sequencing-check-file-row"]').eq(1).should('contain', 'Identity below 100%');
+
+      cy.then(() => {
+        // Only files with the same length as the reference get their seguid computed, with its topology
+        expect(seguidRequests).to.have.length(2);
+        seguidRequests.forEach((body) => expect(body.circular).to.equal(true));
+        // The exact match is not aligned
+        expect(alignedTraces).to.have.length(7);
+        expect(alignedTraces).not.to.include(plasmidBases);
+        // At most 4 checks at the same time: any 5 alignment requests span at least one alignment delay
+        const starts = [...alignStarts].sort((a, b) => a - b);
+        for (let i = 0; i + 4 < starts.length; i++) {
+          expect(starts[i + 4] - starts[i]).to.be.at.least(ALIGN_DELAY * 0.8);
+        }
+      });
+
+      // The alignments and the files of the check are reused by the alignment viewer
+      cy.get('@downloadFile.all').should('have.length', 8);
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'read_c.fa').find('[aria-label="View alignment"]').click();
+      cy.get('[data-testid="sequencing-alignment-viewer"] .veTabActive.veTabAlignments').should('be.visible');
+      cy.get('@alignSanger.all').should('have.length', 7);
+      // The exact match was not aligned during the check, so it is aligned now, but not downloaded again
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'exact.fa').find('[aria-label="View alignment"]').click();
+      cy.get('[data-testid="sequencing-alignment-viewer"] .veTabActive.veTabAlignments').should('be.visible');
+      cy.get('[data-testid="sequencing-alignment-viewer"]').should('contain', 'exact.fa');
+      cy.get('@alignSanger.all').should((calls) => {
+        expect(calls).to.have.length(8);
+        expect(calls.at(-1).request.body.traces).to.deep.equal([plasmidBases]);
+      });
+      cy.get('@downloadFile.all').should('have.length', 8);
+      cy.get('[aria-label="Close alignment"]').click();
+
+      // Checking again only recomputes the seguids, and retries the alignment that failed (errors are not cached)
+      cy.get('[data-testid="sequencing-check-run-button"]').click();
+      cy.get('[data-testid="sequencing-check-run-button"]').should('not.be.disabled');
+      cy.get('[data-testid="sequencing-check-progress"]').should('contain', '8 / 8');
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'mutant.fa').should('contain', '75.00');
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'broken.fa').should('contain', 'Alignment failed');
+      cy.get('@alignSanger.all').should((calls) => {
+        expect(calls).to.have.length(9);
+        expect(calls.at(-1).request.body.traces).to.deep.equal(['ACGTTGCAAC']);
+      });
+      cy.get('@downloadFile.all').should('have.length', 8);
+      cy.get('@seguid.all').should('have.length', 4);
+
+      // Pick other sequences goes back to the bulk component
+      cy.contains('button', 'Pick other sequences').click();
+      cy.contains('button', 'Load sequences').should('exist');
+    });
+  });
+
+  it('shows the alignment of a sequencing file below the table', () => {
+    cy.viewport(1400, 900);
+    cy.getStub('get_text_file_sequences_by_tag').then((stub) => {
+      const [plasmid] = stub.response.body;
+      const plasmidBases = convertToTeselaJson(plasmid.sequence).sequence.toUpperCase();
+      const mutantBases = (plasmidBases[0] === 'A' ? 'C' : 'A') + plasmidBases.slice(1);
+      const files = {
+        1: { name: 'mutant.fa', sequence: mutantBases },
+        2: { name: 'other.fa', sequence: plasmidBases },
+      };
+
+      cy.intercept('GET', Cypress.getDbURL('/sequences/*/sequencing_files'), (req) => {
+        const sequenceId = Number(req.url.split('/').at(-2));
+        req.reply(sequenceId === plasmid.sequence_ref.id ? [1, 2].map((id) => ({ id, original_name: files[id].name })) : []); // eslint-disable-line camelcase
+      });
+      cy.intercept('GET', Cypress.getDbURL('/sequencing_files/*/download'), (req) => {
+        const file = files[Number(req.url.split('/').at(-2))];
+        req.reply({ body: `>${file.name}\n${file.sequence}\n`, headers: { 'content-type': 'application/octet-stream' } });
+      });
+      cy.intercept('POST', `${BACKEND_URL}/align_sanger`, (req) => {
+        req.reply({ body: [plasmidBases, req.body.traces[0].toUpperCase()], delay: 200 });
+      }).as('alignSanger');
+
+      cy.mount(
+        <ConfigProvider config={testConfig}>
+          <SequencingCheckModal open onClose={() => {}} />
+        </ConfigProvider>,
+      );
+      loadSequencesByTag();
+
+      // No alignment shown by default
+      cy.get('[data-testid="sequencing-check-file-row"]').should('have.length', 2);
+      cy.get('[data-testid="sequencing-alignment-viewer"]').should('not.exist');
+
+      // The eye button aligns the file to its sequence (without running the check) and shows the alignment tab
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'mutant.fa').find('[aria-label="View alignment"]').click();
+      cy.get('[data-testid="sequencing-alignment-viewer"]').find('.MuiCircularProgress-root').should('exist');
+      cy.wait('@alignSanger').its('request.body').should((body) => {
+        expect(body.sequence.id).to.equal(plasmid.sequence.id);
+        expect(body.traces).to.deep.equal([mutantBases]);
+      });
+      cy.get('[data-testid="sequencing-alignment-viewer"]').should('contain', 'mutant.fa');
+      cy.get('[data-testid="sequencing-alignment-viewer"] .veTabActive.veTabAlignments').should('be.visible');
+      cy.get('[data-testid="sequencing-alignment-viewer"] .veTabActive').should('have.length', 1);
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'mutant.fa').should('have.class', 'Mui-selected');
+
+      // Another file replaces the alignment
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'other.fa').find('[aria-label="View alignment"]').click();
+      cy.wait('@alignSanger').its('request.body.traces').should('deep.equal', [plasmidBases]);
+      cy.get('[data-testid="sequencing-alignment-viewer"]').should('contain', 'other.fa').and('not.contain', 'mutant.fa');
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'mutant.fa').should('not.have.class', 'Mui-selected');
+
+      // Hide it with the eye button, show it again from the cache, and close it
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'other.fa').find('[aria-label="Hide alignment"]').click();
+      cy.get('[data-testid="sequencing-alignment-viewer"]').should('not.exist');
+      cy.get('[data-testid="sequencing-check-file-row"]').contains('tr', 'mutant.fa').find('[aria-label="View alignment"]').click();
+      cy.get('[data-testid="sequencing-alignment-viewer"] .veTabActive.veTabAlignments').should('be.visible');
+      cy.get('@alignSanger.all').should('have.length', 2);
+      cy.get('[aria-label="Close alignment"]').click();
+      cy.get('[data-testid="sequencing-alignment-viewer"]').should('not.exist');
+    });
+  });
+});

package/src/sequencing_check/SequencingCheckModal.jsx

@@ -0,0 +1,90 @@
+import React from 'react';
+import { Alert, Box, Button, CircularProgress, Typography } from '@mui/material';
+import error2String from '@opencloning/utils/error2String';
+import BulkUploadModal from '../bulk_upload/BulkUploadModal';
+import { BulkTableContainer } from '../bulk_upload/common';
+import GetSequencesInBulkComponent from '../GetSequencesInBulkComponent';
+import SequencingCheckTable from './SequencingCheckTable';
+import SequencingAlignmentViewer from './SequencingAlignmentViewer';
+import useSequencingCheck from './useSequencingCheck';
+
+function SequencingCheckResults({ sequences, onPickOtherSequences, renderSequenceName }) {
+  const { rows, filesLoading, filesError, run, isRunning, progress } = useSequencingCheck(sequences);
+  // { sequence, file } of the alignment shown below the table, null if none
+  const [selectedAlignment, setSelectedAlignment] = React.useState(null);
+  const onViewAlignment = (sequence, file) => setSelectedAlignment(sequence ? { sequence, file } : null);
+
+  return (
+    <>
+      <Typography variant="body2" sx={{ mb: 2 }}>
+        Each sequencing file is aligned to its sequence (exact matches are detected without aligning).
+        Sequences are sorted by percentage identity, lowest first.
+      </Typography>
+      {filesError && <Alert severity="error" sx={{ mb: 2 }}>Could not load the sequencing files: {error2String(filesError)}</Alert>}
+      {/* Scrolls when the alignment is shown, so that the buttons stay visible */}
+      <Box sx={{ flex: 1, minHeight: 0, overflowY: 'auto' }}>
+        <BulkTableContainer>
+          <SequencingCheckTable
+            rows={rows}
+            renderSequenceName={renderSequenceName}
+            selectedFileId={selectedAlignment?.file.id ?? null}
+            onViewAlignment={onViewAlignment}
+          />
+        </BulkTableContainer>
+        {selectedAlignment && (
+          <SequencingAlignmentViewer
+            key={selectedAlignment.file.id}
+            sequence={selectedAlignment.sequence}
+            file={selectedAlignment.file}
+            onClose={() => setSelectedAlignment(null)}
+          />
+        )}
+      </Box>
+      <Box sx={{ display: 'flex', justifyContent: 'flex-end', alignItems: 'center', gap: 1 }}>
+        {progress.total > 0 && (
+          <Typography variant="body2" sx={{ mr: 'auto' }} data-testid="sequencing-check-progress">
+            {progress.done} / {progress.total} sequencing files checked
+          </Typography>
+        )}
+        <Button variant="outlined" onClick={onPickOtherSequences} disabled={isRunning}>
+          Pick other sequences
+        </Button>
+        <Button
+          variant="contained"
+          onClick={() => run()}
+          disabled={isRunning || filesLoading || progress.total === 0}
+          data-testid="sequencing-check-run-button"
+        >
+          {isRunning ? <CircularProgress size={24} /> : 'Check sequencing files'}
+        </Button>
+      </Box>
+    </>
+  );
+}
+
+function SequencingCheckContent({ renderSequenceName }) {
+  const [sequences, setSequences] = React.useState(null);
+  if (sequences === null) {
+    return <GetSequencesInBulkComponent onSequencesLoaded={setSequences} />;
+  }
+  return (
+    <SequencingCheckResults
+      sequences={sequences}
+      onPickOtherSequences={() => setSequences(null)}
+      renderSequenceName={renderSequenceName}
+    />
+  );
+}
+
+/**
+ * Pick sequences in bulk and check them against their sequencing files (percentage identity).
+ * renderSequenceName(sequence) can be passed to render the sequence names (e.g. as links), sequence is
+ * an item of the output of GetSequencesInBulkComponent ({ databaseId, name, ... }).
+ */
+export default function SequencingCheckModal({ open, onClose, renderSequenceName }) {
+  return (
+    <BulkUploadModal open={open} onClose={onClose} title="Check sequencing files" dataTestId="sequencing-check-modal">
+      <SequencingCheckContent renderSequenceName={renderSequenceName} />
+    </BulkUploadModal>
+  );
+}

package/src/sequencing_check/SequencingCheckTable.jsx

@@ -0,0 +1,112 @@
+import React from 'react';
+import { IconButton, Table, TableBody, TableCell, TableHead, TableRow, Tooltip } from '@mui/material';
+import { Visibility as VisibilityIcon, VisibilityOff as VisibilityOffIcon } from '@mui/icons-material';
+import { StatusIcon } from '../bulk_upload/common';
+import { formatIdentity } from './sequencingCheckUtils';
+
+function identityText(result) {
+  return result?.identity === undefined ? '' : formatIdentity(result.identity);
+}
+
+function fileIssues(result, status) {
+  if (status === 'error') {
+    return [result.message || 'Check failed'];
+  }
+  if (status === 'warning') {
+    return ['Identity below 100%'];
+  }
+  return [];
+}
+
+const defaultRenderSequenceName = (sequence) => sequence.name;
+
+function ViewAlignmentButton({ selected, onClick }) {
+  const title = selected ? 'Hide alignment' : 'View alignment';
+  return (
+    <Tooltip title={title} placement="left">
+      <IconButton size="small" onClick={onClick} aria-label={title} color={selected ? 'primary' : 'default'} data-testid="sequencing-check-view-alignment">
+        {selected ? <VisibilityOffIcon fontSize="small" /> : <VisibilityIcon fontSize="small" />}
+      </IconButton>
+    </Tooltip>
+  );
+}
+
+function IssuesCell({ status, issues }) {
+  return (
+    <TableCell>
+      {status !== 'clear' && issues.map((issue) => <div key={issue}>{issue}</div>)}
+    </TableCell>
+  );
+}
+
+/**
+ * Rows from useSequencingCheck: one row per sequencing file, with the sequence cell spanning the rows of its files
+ * (a single row with no file if the sequence has none). Each file has an eye button that calls
+ * onViewAlignment(sequence, file), or onViewAlignment(null) if that file is the selected one (selectedFileId).
+ */
+export default function SequencingCheckTable({ rows, renderSequenceName = defaultRenderSequenceName, selectedFileId = null, onViewAlignment }) {
+  return (
+    <Table stickyHeader size="small" sx={{ tableLayout: 'fixed', width: '100%' }} data-testid="sequencing-check-table">
+      <colgroup>
+        <col style={{ width: '30%' }} />
+        <col style={{ width: '48px' }} />
+        <col style={{ width: '35%' }} />
+        <col style={{ width: '10%' }} />
+        <col style={{ width: '56px' }} />
+        <col style={{ width: '25%' }} />
+      </colgroup>
+      <TableHead>
+        <TableRow>
+          <TableCell>Sequence</TableCell>
+          <TableCell padding="checkbox"></TableCell>
+          <TableCell>Sequencing file</TableCell>
+          <TableCell>% identity</TableCell>
+          <TableCell></TableCell>
+          <TableCell>Notes</TableCell>
+        </TableRow>
+      </TableHead>
+      <TableBody>
+        {rows.map((row) => {
+          const sequenceCell = (
+            <TableCell
+              rowSpan={Math.max(row.files.length, 1)}
+              // Not highlighted with the selected file row
+              sx={{ fontWeight: 'bold', verticalAlign: 'top', bgcolor: 'background.paper', overflowWrap: 'anywhere' }}
+              data-testid="sequencing-check-sequence-cell"
+            >
+              <span data-testid="sequencing-check-sequence-name">{renderSequenceName(row.sequence)}</span>
+            </TableCell>
+          );
+          if (row.files.length === 0) {
+            // Files still loading, or no sequencing files
+            return (
+              <TableRow key={row.sequence.databaseId} data-testid="sequencing-check-empty-row">
+                {sequenceCell}
+                <TableCell align="center" padding="checkbox"><StatusIcon status={row.status} /></TableCell>
+                <TableCell colSpan={3} />
+                <IssuesCell status={row.status} issues={row.filesLoaded ? ['No sequencing data'] : []} />
+              </TableRow>
+            );
+          }
+          return row.files.map(({ file, result, status }, i) => {
+            const selected = file.id === selectedFileId;
+            return (
+              <TableRow key={file.id} selected={selected} data-testid="sequencing-check-file-row">
+                {i === 0 && sequenceCell}
+                <TableCell align="center" padding="checkbox"><StatusIcon status={status} /></TableCell>
+                <TableCell sx={{ fontFamily: 'monospace', overflowWrap: 'anywhere' }} data-testid="sequencing-check-file-name">{file.name}</TableCell>
+                <TableCell data-testid="sequencing-check-identity">{identityText(result)}</TableCell>
+                <TableCell padding="none" align="center">
+                  {onViewAlignment && (
+                    <ViewAlignmentButton selected={selected} onClick={() => (selected ? onViewAlignment(null) : onViewAlignment(row.sequence, file))} />
+                  )}
+                </TableCell>
+                <IssuesCell status={status} issues={fileIssues(result, status)} />
+              </TableRow>
+            );
+          });
+        })}
+      </TableBody>
+    </Table>
+  );
+}

package/src/sequencing_check/sequencingCheckUtils.js

@@ -0,0 +1,134 @@
+/**
+ * Helpers for the bulk sequencing check (sequences vs. their sequencing files).
+ *
+ * A file result is one of:
+ *   { status: 'pending' }                       - check in progress
+ *   { status: 'match', identity: 100 }          - query seguid equals the reference seguid (no alignment needed)
+ *   { status: 'aligned', identity: <number> }   - identity computed from the alignment
+ *   { status: 'error', message: <string> }      - the check failed
+ * Files that have not been checked yet have no result (undefined).
+ */
+
+/** Number of files checked at the same time. */
+export const MAX_CONCURRENT_CHECKS = 4;
+
+/**
+ * Percentage identity of a pairwise alignment (gapped strings of the same length).
+ * Columns where both strings have a gap are ignored, any other gap counts as a mismatch.
+ */
+export function percentIdentity(refAligned, queryAligned) {
+  if (refAligned.length !== queryAligned.length) {
+    throw new Error('Aligned sequences must have the same length');
+  }
+  const ref = refAligned.toUpperCase();
+  const query = queryAligned.toUpperCase();
+  let columns = 0;
+  let matches = 0;
+  for (let i = 0; i < ref.length; i++) {
+    if (ref[i] === '-' && query[i] === '-') {
+      continue;
+    }
+    columns++;
+    if (ref[i] === query[i]) {
+      matches++;
+    }
+  }
+  return columns === 0 ? 0 : (100 * matches) / columns;
+}
+
+/** Format an identity with 2 decimals, rounding down so that anything below 100 never shows as 100. */
+export function formatIdentity(identity) {
+  return (Math.floor(identity * 100) / 100).toFixed(2);
+}
+
+/**
+ * Call worker(item) for every item, with at most `limit` calls running at the same time.
+ * Resolves with the results in the order of items. A rejected worker rejects the whole call,
+ * so workers should handle their own errors.
+ */
+export async function runWithConcurrency(items, limit, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  const runNext = async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await worker(items[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, runNext));
+  return results;
+}
+
+/** Status of a file for the StatusIcon in bulk_upload/common.jsx (null if not checked yet). */
+export function fileRowStatus(result) {
+  if (!result) {
+    return null;
+  }
+  if (result.status === 'pending' || result.status === 'error') {
+    return result.status;
+  }
+  return result.identity === 100 ? 'clear' : 'warning';
+}
+
+const STATUS_SEVERITY = ['error', 'warning', 'pending', null, 'clear'];
+
+/** Status of a sequence row: 'info' if it has no sequencing files, otherwise the worst status of its files. */
+export function sequenceRowStatus(files, results) {
+  if (files.length === 0) {
+    return 'info';
+  }
+  const statuses = files.map((file) => fileRowStatus(results[file.id]));
+  return STATUS_SEVERITY.find((status) => statuses.includes(status));
+}
+
+/**
+ * Sort key of a file, compared lexicographically: errors first, then identities (lowest first),
+ * then files that are pending or not checked yet.
+ */
+function fileSortKey(result) {
+  if (result?.status === 'error') {
+    return [0, 0];
+  }
+  if (result?.identity !== undefined) {
+    return [1, result.identity];
+  }
+  return [2, 0];
+}
+
+const NO_FILES_SORT_KEY = [3, 0];
+
+function compareKeys(a, b) {
+  return a[0] - b[0] || a[1] - b[1];
+}
+
+/**
+ * Build the table rows from the sequences, their sequencing files and the results, sorted by
+ * percentage identity (lowest first), both the sequences and the files within each sequence.
+ * Sequences without sequencing files go last. The sort is stable, so ties keep the original order.
+ *
+ * @param {Array} sequences - [{ databaseId, name, ... }]
+ * @param {Object} filesBySequenceId - { [databaseId]: [{ id, name, ... }] | undefined (loading) }
+ * @param {Object} results - { [fileId]: result }
+ * @returns {Array} [{ sequence, files: [{ file, result, status }], status, identity }]
+ */
+export function buildSortedRows(sequences, filesBySequenceId, results) {
+  const rows = sequences.map((sequence) => {
+    const files = (filesBySequenceId[sequence.databaseId] ?? [])
+      .map((file) => ({ file, result: results[file.id], status: fileRowStatus(results[file.id]), sortKey: fileSortKey(results[file.id]) }))
+      .sort((a, b) => compareKeys(a.sortKey, b.sortKey));
+    const identities = files.map(({ result }) => result?.identity).filter((identity) => identity !== undefined);
+    const filesLoaded = filesBySequenceId[sequence.databaseId] !== undefined;
+    if (!filesLoaded) {
+      return { sequence, files, filesLoaded, status: 'pending', identity: undefined, sortKey: fileSortKey(undefined) };
+    }
+    return {
+      sequence,
+      files,
+      filesLoaded,
+      status: sequenceRowStatus(files.map(({ file }) => file), results),
+      identity: identities.length > 0 ? Math.min(...identities) : undefined,
+      sortKey: files.length > 0 ? files[0].sortKey : NO_FILES_SORT_KEY,
+    };
+  });
+  return rows.sort((a, b) => compareKeys(a.sortKey, b.sortKey));
+}