@apollo-annotation/shared 0.1.18 → 0.1.20

package/src/Checks/CDSCheck.ts

@@ -3,6 +3,7 @@ import {
   AnnotationFeatureSnapshot,
   CheckResultSnapshot,
 } from '@apollo-annotation/mst'
+import { intersection2 } from '@jbrowse/core/util'
 import ObjectID from 'bson-objectid'
 
 enum STOP_CODONS {
@@ -29,6 +30,9 @@ const iupacComplements: Record<string, string | undefined> = {
   N /* G or A or T or C */: 'N',
 }
 
+type CDSLocation = { min: number; max: number; phase: 0 | 1 | 2 }[]
+type CDSLocations = CDSLocation[]
+
 function reverseComplement(dna: string): string {
   const complement: string[] = []
   for (const nt of dna) {
@@ -45,47 +49,18 @@ function reverseComplement(dna: string): string {
   return complement.reverse().join('')
 }
 
-async function getSequenceFromSingleFeature(
-  feature: AnnotationFeatureSnapshot,
-  getSequence: (start: number, end: number) => Promise<string>,
-) {
-  let seq = ''
-  if (
-    feature.discontinuousLocations !== undefined &&
-    feature.discontinuousLocations.length > 0
-  ) {
-    for (const loc of feature.discontinuousLocations) {
-      seq = seq + (await getSequence(loc.start, loc.end))
-    }
-  } else {
-    seq = await getSequence(feature.start, feature.end)
-  }
-  if (feature.strand === -1) {
-    return reverseComplement(seq)
-  }
-  return seq
-}
-
-async function getSequenceFromMultipleFeatures(
-  features: AnnotationFeatureSnapshot[],
+async function getCDSSequence(
+  cdsLocation: CDSLocation,
+  strand: 1 | -1 | undefined,
   getSequence: (start: number, end: number) => Promise<string>,
-) {
-  const strands = features.map((feature) => feature.strand)
-  if (!strands.every((strand) => strand === strands[0])) {
-    throw new Error(
-      `Strands do not match in features: "${features
-        .map((f) => f._id)
-        .join(', ')}"`,
-    )
-  }
-  let seq = ''
-  for (const feature of features) {
-    seq = seq + (await getSequence(feature.start, feature.end))
+): Promise<string> {
+  const sequences = await Promise.all(
+    cdsLocation.map(({ max, min }) => getSequence(min, max)),
+  )
+  if (strand === -1) {
+    return sequences.map((seq) => reverseComplement(seq)).join('')
   }
-  if (strands[0] === -1) {
-    return reverseComplement(seq)
-  }
-  return seq
+  return sequences.join('')
 }
 
 function splitSequenceInCodons(cds: string): string[] {
@@ -97,132 +72,135 @@ function splitSequenceInCodons(cds: string): string[] {
 }
 
 function getOriginalCodonLocation(
-  feature: AnnotationFeatureSnapshot | AnnotationFeatureSnapshot[],
+  cdsLocation: CDSLocation,
+  strand: 1 | -1 | undefined,
   index: number,
-): [number, number] {
+): [number, number] | undefined {
   let lengthToStart = index * 3
   let lengthToEnd = lengthToStart + 3
-  if (Array.isArray(feature)) {
-    let startLocation: number | undefined = undefined,
-      endLocation: number | undefined = undefined
-    for (const f of feature) {
-      const featureLength = f.end - f.start
-      if (startLocation === undefined && featureLength > lengthToStart) {
-        startLocation = f.start + lengthToStart
-      } else {
-        lengthToStart -= featureLength
-      }
-      if (endLocation === undefined && featureLength > lengthToEnd) {
-        endLocation = f.start + lengthToEnd
-      } else {
-        lengthToEnd -= featureLength
-      }
-      if (startLocation !== undefined && endLocation !== undefined) {
-        return [startLocation, endLocation]
-      }
+
+  let startLocation: number | undefined = undefined,
+    endLocation: number | undefined = undefined
+  for (const loc of cdsLocation) {
+    const locLength = loc.max - loc.min
+    if (startLocation === undefined && locLength > lengthToStart) {
+      startLocation = loc.min + lengthToStart
+    } else {
+      lengthToStart -= locLength
     }
-    throw new Error('Could not determine original CDS location')
-  } else {
-    if (
-      feature.discontinuousLocations !== undefined &&
-      feature.discontinuousLocations.length > 0
-    ) {
-      let startLocation: number | undefined = undefined,
-        endLocation: number | undefined = undefined
-      for (const loc of feature.discontinuousLocations) {
-        const locLength = loc.end - loc.start
-        if (startLocation === undefined && locLength > lengthToStart) {
-          startLocation = loc.start + lengthToStart
-        } else {
-          lengthToStart -= locLength
-        }
-        if (endLocation === undefined && locLength > lengthToEnd) {
-          endLocation = loc.start + lengthToEnd
-        } else {
-          lengthToEnd -= locLength
-        }
-        if (startLocation !== undefined && endLocation !== undefined) {
-          return [startLocation, endLocation]
-        }
-      }
-      throw new Error('Could not determine original CDS location')
+    if (endLocation === undefined && locLength > lengthToEnd) {
+      endLocation = loc.min + lengthToEnd
     } else {
-      return [feature.start + lengthToStart, feature.start + lengthToEnd]
+      lengthToEnd -= locLength
+    }
+    if (startLocation !== undefined && endLocation !== undefined) {
+      return [startLocation, endLocation]
     }
   }
+  return
 }
 
-async function checkCDS(
-  feature: AnnotationFeatureSnapshot | AnnotationFeatureSnapshot[],
+async function checkMRNA(
+  feature: AnnotationFeatureSnapshot,
   getSequence: (start: number, end: number) => Promise<string>,
 ): Promise<CheckResultSnapshot[]> {
   const checkResults: CheckResultSnapshot[] = []
-  let _id: string,
-    ids: string[],
-    start: number,
-    end: number,
-    refSeq: string,
-    sequence: string
-  if (Array.isArray(feature)) {
-    sequence = await getSequenceFromMultipleFeatures(feature, getSequence)
-    ids = feature.map((f) => f._id)
-    _id = ids.join(',')
-    ;[{ refSeq, start }] = feature
-    const lastFeature = feature.at(-1)
-    if (!lastFeature) {
-      throw new Error('Zero-length feature array encountered')
-    }
-    ;({ end } = lastFeature)
-  } else {
-    sequence = await getSequenceFromSingleFeature(feature, getSequence)
-    ;({ _id, end, refSeq, start } = feature)
-    ids = [_id]
+  const { _id, max, min, refSeq, strand } = feature
+  const cdsLocations = getCDSLocations(feature)
+  if (!cdsLocations) {
+    return checkResults
   }
-  const codons = splitSequenceInCodons(sequence)
-  if (sequence.length % 3 === 0) {
-    const lastCodon = codons.pop() // Last codon is supposed to be a stop
-    if (!lastCodon) {
-      throw new Error(`No sequence found for feature "${_id}"`)
-    }
-    if (!(lastCodon.toUpperCase() in STOP_CODONS)) {
+  const ids = [_id]
+  for (const cdsLocation of cdsLocations) {
+    const sequence = await getCDSSequence(cdsLocation, strand, getSequence)
+    const codons = splitSequenceInCodons(sequence)
+    if (sequence.length % 3 === 0) {
+      const lastCodon = codons.pop() // Last codon is supposed to be a stop
+      if (lastCodon && !(lastCodon.toUpperCase() in STOP_CODONS)) {
+        checkResults.push({
+          _id: new ObjectID().toHexString(),
+          name: 'MissingStopCodonCheck',
+          ids,
+          refSeq: refSeq.toString(),
+          start: max,
+          end: max,
+          message: `Feature "${_id}" is missing a stop codon`,
+        })
+      }
+    } else {
       checkResults.push({
         _id: new ObjectID().toHexString(),
-        name: 'MissingStopCodonCheck',
+        name: 'MultipleOfThreeCheck',
         ids,
         refSeq: refSeq.toString(),
-        start: end,
-        end,
-        message: `Feature "${_id}" is missing a stop codon`,
+        start: min,
+        end: max,
+        message: `The coding sequence for feature "${_id}" is not a multiple of three`,
       })
     }
-  } else {
-    checkResults.push({
-      _id: new ObjectID().toHexString(),
-      name: 'MultipleOfThreeCheck',
-      ids,
-      refSeq: refSeq.toString(),
-      start,
-      end,
-      message: `The coding sequence for feature "${_id}" is not a multiple of three`,
-    })
-  }
-  for (const [idx, codon] of codons.entries()) {
-    const [codonStart, codonEnd] = getOriginalCodonLocation(feature, idx)
-    if (codon.toUpperCase() in STOP_CODONS) {
-      checkResults.push({
-        _id: new ObjectID().toHexString(),
-        name: 'InternalStopCodonCheck',
-        ids,
-        refSeq: refSeq.toString(),
-        start: codonStart,
-        end: codonEnd,
-        message: `The coding sequence for feature "${_id}" has an internal stop codon`,
-      })
+    for (const [idx, codon] of codons.entries()) {
+      const location = getOriginalCodonLocation(cdsLocation, strand, idx)
+      if (location && codon.toUpperCase() in STOP_CODONS) {
+        const [codonStart, codonEnd] = location
+        checkResults.push({
+          _id: new ObjectID().toHexString(),
+          name: 'InternalStopCodonCheck',
+          ids,
+          refSeq: refSeq.toString(),
+          start: codonStart,
+          end: codonEnd,
+          message: `The coding sequence for feature "${_id}" has an internal stop codon`,
+        })
+      }
     }
   }
   return checkResults
 }
 
+function getCDSLocations(
+  feature: AnnotationFeatureSnapshot,
+): CDSLocations | undefined {
+  if (feature.type !== 'mRNA') {
+    return
+  }
+  const { children, strand } = feature
+  if (!children) {
+    return
+  }
+  const cdsChildren = Object.values(children).filter(
+    (child) => child.type === 'CDS',
+  )
+  if (cdsChildren.length === 0) {
+    return
+  }
+  const cdsLocations: CDSLocations = []
+  for (const cds of cdsChildren) {
+    const { max: cdsMax, min: cdsMin } = cds
+    const locs: { min: number; max: number }[] = []
+    for (const child of Object.values(children)) {
+      if (child.type !== 'exon') {
+        continue
+      }
+      const [start, end] = intersection2(cdsMin, cdsMax, child.min, child.max)
+      if (start !== undefined && end !== undefined) {
+        locs.push({ min: start, max: end })
+      }
+    }
+    locs.sort(({ min: a }, { min: b }) => a - b)
+    if (strand === -1) {
+      locs.reverse()
+    }
+    let nextPhase: 0 | 1 | 2 = 0
+    const phasedLocs = locs.map((loc) => {
+      const phase = nextPhase
+      nextPhase = ((3 - ((loc.max - loc.min - phase + 3) % 3)) % 3) as 0 | 1 | 2
+      return { ...loc, phase }
+    })
+    cdsLocations.push(phasedLocs)
+  }
+  return cdsLocations
+}
+
 export class CDSCheck extends Check {
   name = 'CDSCheck'
   version = 1
@@ -232,44 +210,18 @@ export class CDSCheck extends Check {
     feature: AnnotationFeatureSnapshot,
     getSequence: (start: number, end: number) => Promise<string>,
   ): Promise<CheckResultSnapshot[]> {
-    if (feature.type === 'CDS') {
-      return checkCDS(feature, getSequence)
+    if (feature.type === 'mRNA') {
+      return checkMRNA(feature, getSequence)
     }
 
     if (!feature.children) {
       return []
     }
 
-    if (feature.type !== 'mRNA') {
-      const checkResults: CheckResultSnapshot[] = []
-      for (const child of Object.values(feature.children)) {
-        checkResults.push(...(await this.checkFeature(child, getSequence)))
-      }
-      return checkResults
-    }
-
-    const cdsChildren = Object.values(feature.children).filter(
-      (child) => child.type === 'CDS',
-    )
-    if (cdsChildren.length === 0) {
-      throw new Error(`mRNA "${feature._id}" has no CDS children`)
-    }
-    const cdsChildrenWithDiscontinuousLocations = cdsChildren.filter(
-      (child) =>
-        child.discontinuousLocations && child.discontinuousLocations.length > 0,
-    )
-    if (cdsChildrenWithDiscontinuousLocations.length === 0) {
-      return checkCDS(cdsChildren, getSequence)
-    }
-    if (cdsChildrenWithDiscontinuousLocations.length === cdsChildren.length) {
-      const checkResults: CheckResultSnapshot[] = []
-      for (const child of cdsChildren) {
-        checkResults.push(...(await this.checkFeature(child, getSequence)))
-      }
-      return checkResults
+    const checkResults: CheckResultSnapshot[] = []
+    for (const child of Object.values(feature.children)) {
+      checkResults.push(...(await this.checkFeature(child, getSequence)))
     }
-    throw new Error(
-      `Mix of CDS with and without discontinuous locations found in mRNA "${feature._id}"`,
-    )
+    return checkResults
   }
 }

package/src/Common/jwtPayload.ts

@@ -3,7 +3,7 @@ import jwtDecode from 'jwt-decode'
 export interface JWTPayload {
   username: string
   email: string
-  role?: 'admin' | 'user' | 'readOnly'
+  role?: 'admin' | 'user' | 'readOnly' | 'none'
   id: string
 }
 

package/src/GFF3/gff3ToAnnotationFeature.test.ts

@@ -0,0 +1,209 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+import { describe, it } from 'node:test'
+import { readFileSync } from 'node:fs'
+
+import gff, { GFF3Feature } from '@gmod/gff'
+import { assert, use } from 'chai'
+import chaiExclude from 'chai-exclude'
+
+import { gff3ToAnnotationFeature } from './gff3ToAnnotationFeature'
+import { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+use(chaiExclude)
+
+const testCases: [string, string, AnnotationFeatureSnapshot][] = [
+  [
+    'a feature with no children',
+    'ctgA	example	remark	1000	2000	.	.	.	Name=Remark:hga;Alias=hga\n',
+    {
+      _id: '66c51f3e002c683eaf98a223',
+      refSeq: 'ctgA',
+      type: 'remark',
+      min: 999,
+      max: 2000,
+      attributes: {
+        gff_source: ['example'],
+        gff_name: ['Remark:hga'],
+        gff_alias: ['hga'],
+      },
+    },
+  ],
+  [
+    'a feature with two children',
+    `ctgA	est	EST_match	1050	3202	.	+	.	ID=Match1;Name=agt830.5;Target=agt830.5 1 654
+ctgA	est	match_part	1050	1500	.	+	.	Parent=Match1;Name=agt830.5;Target=agt830.5 1 451
+ctgA	est	match_part	3000	3202	.	+	.	Parent=Match1;Name=agt830.5;Target=agt830.5 452 654
+`,
+    {
+      _id: '66cf9fbb4e947fa2c27d3d6a',
+      refSeq: 'ctgA',
+      type: 'EST_match',
+      min: 1049,
+      max: 3202,
+      strand: 1,
+      children: {
+        '66cf9fbb4e947fa2c27d3d68': {
+          _id: '66cf9fbb4e947fa2c27d3d68',
+          refSeq: 'ctgA',
+          type: 'match_part',
+          min: 1049,
+          max: 1500,
+          strand: 1,
+          attributes: {
+            gff_source: ['est'],
+            gff_name: ['agt830.5'],
+            gff_target: ['agt830.5 1 451'],
+          },
+        },
+        '66cf9fbb4e947fa2c27d3d69': {
+          _id: '66cf9fbb4e947fa2c27d3d69',
+          refSeq: 'ctgA',
+          type: 'match_part',
+          min: 2999,
+          max: 3202,
+          strand: 1,
+          attributes: {
+            gff_source: ['est'],
+            gff_name: ['agt830.5'],
+            gff_target: ['agt830.5 452 654'],
+          },
+        },
+      },
+      attributes: {
+        gff_source: ['est'],
+        gff_id: ['Match1'],
+        gff_name: ['agt830.5'],
+        gff_target: ['agt830.5 1 654'],
+      },
+    },
+  ],
+]
+
+interface AnnotationFeatureSnapshotWithChildrenArray
+  extends Omit<AnnotationFeatureSnapshot, 'children'> {
+  children?: AnnotationFeatureSnapshotWithChildrenArray[]
+}
+
+function childrenToArray(
+  feature: AnnotationFeatureSnapshot,
+): AnnotationFeatureSnapshotWithChildrenArray {
+  const { children } = feature
+  if (!children) {
+    return feature as AnnotationFeatureSnapshotWithChildrenArray
+  }
+  const childrenArray = Object.values(children).map((child) =>
+    childrenToArray(child),
+  )
+  return { ...feature, children: childrenArray }
+}
+
+function compareFeatures(
+  feature1: AnnotationFeatureSnapshot,
+  feature2: AnnotationFeatureSnapshot,
+) {
+  assert.deepEqualExcludingEvery(
+    childrenToArray(feature1),
+    childrenToArray(feature2),
+    '_id',
+  )
+}
+
+function readFeatureFile(fn: string): GFF3Feature[] {
+  const lines = readFileSync(fn).toString().split('\n')
+  const feature: string[] = []
+  for (const line of lines) {
+    if (!line.startsWith('#')) {
+      feature.push(line)
+    }
+  }
+  const inGff = gff.parseStringSync(feature.join('\n')) as GFF3Feature[]
+  return inGff
+}
+
+function readAnnotationFeatureSnapshot(fn: string): AnnotationFeatureSnapshot {
+  const lines = readFileSync(fn).toString()
+  return JSON.parse(lines) as AnnotationFeatureSnapshot
+}
+
+const [ex1, ex2, ex3, ex4] = readFeatureFile(
+  'test_data/gene_representations.gff3',
+)
+
+describe('gff3ToAnnotationFeature examples', () => {
+  it('Convert one CDS', () => {
+    const actual = gff3ToAnnotationFeature(
+      readFeatureFile('test_data/one_cds.gff3')[0],
+    )
+    const expected = readAnnotationFeatureSnapshot('test_data/one_cds.json')
+    compareFeatures(actual, expected)
+  })
+  it('Convert two CDSs', () => {
+    const actual = gff3ToAnnotationFeature(
+      readFeatureFile('test_data/two_cds.gff3')[0],
+    )
+    const expected = readAnnotationFeatureSnapshot('test_data/two_cds.json')
+    compareFeatures(actual, expected)
+  })
+  it('Convert example 1', () => {
+    const actual = gff3ToAnnotationFeature(ex1)
+    const txt = JSON.stringify(actual, null, 2)
+
+    assert.equal(txt.match(/"type": "CDS"/g)?.length, 4)
+    assert.equal(txt.match(/"type": "TF_binding_site"/g)?.length, 1)
+
+    const expected = readAnnotationFeatureSnapshot('test_data/example01.json')
+    compareFeatures(actual, expected)
+  })
+  it('Convert example 2', () => {
+    const actual = gff3ToAnnotationFeature(ex2)
+    const txt = JSON.stringify(actual, null, 2)
+    assert.equal(txt.match(/"type": "CDS"/g)?.length, 4)
+    const expected = readAnnotationFeatureSnapshot('test_data/example02.json')
+    compareFeatures(actual, expected)
+  })
+  it('Convert example 3', () => {
+    // NB: In example 3 (and in the other examples) mRNA10003 produces two proteins.
+    // In the other examples the two proteins are identified by sharing the same cds id.
+    // In example 3 instead each cds has a unique id so the two proteins are identified by the order they
+    // appear in the gff.
+    const actual = gff3ToAnnotationFeature(ex3)
+    const txt = JSON.stringify(actual, null, 2)
+    assert.equal(txt.match(/"type": "CDS"/g)?.length, 4)
+
+    // const expected = readAnnotationFeatureSnapshot('test_data/example03.json')
+    // compareFeatures(actual, expected)
+  })
+  it('Convert example 4', () => {
+    const ft = JSON.stringify(ex4, null, 2)
+    assert.equal(ft.match(/"type": "five_prime_UTR"/g)?.length, 6)
+    assert.equal(ft.match(/"type": "three_prime_UTR"/g)?.length, 3)
+
+    const actual = gff3ToAnnotationFeature(ex4)
+    const txt = JSON.stringify(actual, null, 2)
+    assert.equal(txt.match(/"type": "CDS"/g)?.length, 4)
+    assert.equal(txt.match(/prime_UTR/g), null)
+
+    const expected = readAnnotationFeatureSnapshot('test_data/example04.json')
+    compareFeatures(actual, expected)
+  })
+  it('Convert braker gff', () => {
+    const [gffFeature] = readFeatureFile('test_data/braker.gff')
+    const actual = gff3ToAnnotationFeature(gffFeature)
+    const txt = JSON.stringify(actual, null, 2)
+    assert.equal(txt.match(/intron/g), null)
+    assert.equal(txt.match(/_codon/g), null)
+  })
+})
+
+describe('gff3ToAnnotationFeature', () => {
+  for (const testCase of testCases) {
+    const [description, featureLine, convertedFeature] = testCase
+    it(`converts ${description}`, () => {
+      const gff3Feature = gff.parseStringSync(featureLine, {
+        parseSequences: false,
+      })
+      const feature = gff3ToAnnotationFeature(gff3Feature[0])
+      compareFeatures(convertedFeature, feature)
+    })
+  }
+})