@apollo-annotation/shared 0.3.6 → 0.3.8

package/src/Changes/UndoMergeExonsChange.ts

@@ -0,0 +1,149 @@
+/* eslint-disable @typescript-eslint/require-await */
+
+import {
+  type ChangeOptions,
+  type ClientDataStore,
+  FeatureChange,
+  type LocalGFF3DataStore,
+  type SerializedFeatureChange,
+  type ServerDataStore,
+} from '@apollo-annotation/common'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+import { MergeExonsChange } from './MergeExonsChange'
+
+interface SerializedUndoMergeExonsChangeBase extends SerializedFeatureChange {
+  typeName: 'UndoMergeExonsChange'
+}
+
+export interface UndoMergeExonsChangeDetails {
+  exonsToRestore: AnnotationFeatureSnapshot[]
+  parentFeatureId: string
+}
+
+interface SerializedUndoMergeExonsChangeSingle
+  extends SerializedUndoMergeExonsChangeBase,
+    UndoMergeExonsChangeDetails {}
+
+interface SerializedUndoMergeExonsChangeMultiple
+  extends SerializedUndoMergeExonsChangeBase {
+  changes: UndoMergeExonsChangeDetails[]
+}
+
+export type SerializedUndoMergeExonsChange =
+  | SerializedUndoMergeExonsChangeSingle
+  | SerializedUndoMergeExonsChangeMultiple
+export class UndoMergeExonsChange extends FeatureChange {
+  typeName = 'UndoMergeExonsChange' as const
+  changes: UndoMergeExonsChangeDetails[]
+
+  constructor(json: SerializedUndoMergeExonsChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedUndoMergeExonsChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ exonsToRestore, parentFeatureId }] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        exonsToRestore,
+        parentFeatureId,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes } = this
+    for (const change of changes) {
+      const { exonsToRestore, parentFeatureId } = change
+      if (exonsToRestore.length !== 2) {
+        throw new Error(
+          `Expected exactly two exons to restore. Got :${exonsToRestore.length}`,
+        )
+      }
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: parentFeatureId })
+        .session(session)
+        .exec()
+      if (!topLevelFeature) {
+        throw new Error(`Could not find feature with ID "${parentFeatureId}"`)
+      }
+      const parentFeature = this.getFeatureFromId(
+        topLevelFeature,
+        parentFeatureId,
+      )
+      if (!parentFeature) {
+        throw new Error(
+          `Could not find feature with ID "${parentFeatureId}" in feature "${topLevelFeature._id.toString()}"`,
+        )
+      }
+      if (!parentFeature.children) {
+        parentFeature.children = new Map()
+      }
+      for (const exon of exonsToRestore) {
+        this.addChild(parentFeature, exon)
+        const childIds = this.getChildFeatureIds(exon)
+        topLevelFeature.allIds.push(exon._id, ...childIds)
+      }
+      await topLevelFeature.save()
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const { changes } = this
+    for (const change of changes) {
+      const { exonsToRestore, parentFeatureId } = change
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      for (const exon of exonsToRestore) {
+        parentFeature.addChild(exon)
+      }
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes]
+      .reverse()
+      .map((undoMergeExonsChange) => ({
+        firstExon: undoMergeExonsChange.exonsToRestore[0],
+        secondExon: undoMergeExonsChange.exonsToRestore[1],
+        parentFeatureId: undoMergeExonsChange.parentFeatureId,
+      }))
+
+    return new MergeExonsChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'MergeExonsChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}

package/src/Changes/UndoMergeTranscriptsChange.ts

@@ -0,0 +1,153 @@
+/* eslint-disable @typescript-eslint/require-await */
+
+import {
+  type ChangeOptions,
+  type ClientDataStore,
+  FeatureChange,
+  type LocalGFF3DataStore,
+  type SerializedFeatureChange,
+  type ServerDataStore,
+} from '@apollo-annotation/common'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+import { MergeTranscriptsChange } from './MergeTranscriptsChange'
+
+interface SerializedUndoMergeTranscriptsChangeBase
+  extends SerializedFeatureChange {
+  typeName: 'UndoMergeTranscriptsChange'
+}
+
+export interface UndoMergeTranscriptsChangeDetails {
+  transcriptsToRestore: AnnotationFeatureSnapshot[]
+  parentFeatureId: string
+}
+
+interface SerializedUndoMergeTranscriptsChangeSingle
+  extends SerializedUndoMergeTranscriptsChangeBase,
+    UndoMergeTranscriptsChangeDetails {}
+
+interface SerializedUndoMergeTranscriptsChangeMultiple
+  extends SerializedUndoMergeTranscriptsChangeBase {
+  changes: UndoMergeTranscriptsChangeDetails[]
+}
+
+export type SerializedUndoMergeTranscriptsChange =
+  | SerializedUndoMergeTranscriptsChangeSingle
+  | SerializedUndoMergeTranscriptsChangeMultiple
+export class UndoMergeTranscriptsChange extends FeatureChange {
+  typeName = 'UndoMergeTranscriptsChange' as const
+  changes: UndoMergeTranscriptsChangeDetails[]
+
+  constructor(
+    json: SerializedUndoMergeTranscriptsChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedUndoMergeTranscriptsChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ transcriptsToRestore, parentFeatureId }] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        transcriptsToRestore,
+        parentFeatureId,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes } = this
+    for (const change of changes) {
+      const { transcriptsToRestore, parentFeatureId } = change
+      if (transcriptsToRestore.length !== 2) {
+        throw new Error(
+          `Expected exactly two transcripts to restore. Got :${transcriptsToRestore.length}`,
+        )
+      }
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: parentFeatureId })
+        .session(session)
+        .exec()
+      if (!topLevelFeature) {
+        throw new Error(`Could not find feature with ID "${parentFeatureId}"`)
+      }
+      const parentFeature = this.getFeatureFromId(
+        topLevelFeature,
+        parentFeatureId,
+      )
+      if (!parentFeature) {
+        throw new Error(
+          `Could not find feature with ID "${parentFeatureId}" in feature "${topLevelFeature._id.toString()}"`,
+        )
+      }
+      if (!parentFeature.children) {
+        parentFeature.children = new Map()
+      }
+      for (const transcript of transcriptsToRestore) {
+        this.addChild(parentFeature, transcript)
+        const childIds = this.getChildFeatureIds(transcript)
+        topLevelFeature.allIds.push(transcript._id, ...childIds)
+      }
+      await topLevelFeature.save()
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const { changes } = this
+    for (const change of changes) {
+      const { transcriptsToRestore, parentFeatureId } = change
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      for (const transcript of transcriptsToRestore) {
+        parentFeature.addChild(transcript)
+      }
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes]
+      .reverse()
+      .map((undoMergeTranscriptsChange) => ({
+        firstTranscript: undoMergeTranscriptsChange.transcriptsToRestore[0],
+        secondTranscript: undoMergeTranscriptsChange.transcriptsToRestore[1],
+        parentFeatureId: undoMergeTranscriptsChange.parentFeatureId,
+      }))
+
+    return new MergeTranscriptsChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'MergeTranscriptsChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}

package/src/Changes/UndoSplitExonChange.ts

@@ -0,0 +1,174 @@
+/* eslint-disable @typescript-eslint/require-await */
+
+import {
+  type ChangeOptions,
+  type ClientDataStore,
+  FeatureChange,
+  type LocalGFF3DataStore,
+  type SerializedFeatureChange,
+  type ServerDataStore,
+} from '@apollo-annotation/common'
+import { type AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+import { findAndDeleteChildFeature } from './DeleteFeatureChange'
+import { SplitExonChange } from './SplitExonChange'
+
+interface SerializedUndoSplitExonChangeBase extends SerializedFeatureChange {
+  typeName: 'UndoSplitExonChange'
+}
+
+export interface UndoSplitExonChangeDetails {
+  exonToRestore: AnnotationFeatureSnapshot
+  parentFeatureId: string
+  idsToDelete: string[]
+  upstreamCut: number
+  downstreamCut: number
+  leftExonId: string
+  rightExonId: string
+}
+
+interface SerializedUndoSplitExonChangeSingle
+  extends SerializedUndoSplitExonChangeBase,
+    UndoSplitExonChangeDetails {}
+
+interface SerializedUndoSplitExonChangeMultiple
+  extends SerializedUndoSplitExonChangeBase {
+  changes: UndoSplitExonChangeDetails[]
+}
+
+export type SerializedUndoSplitExonChange =
+  | SerializedUndoSplitExonChangeSingle
+  | SerializedUndoSplitExonChangeMultiple
+export class UndoSplitExonChange extends FeatureChange {
+  typeName = 'UndoSplitExonChange' as const
+  changes: UndoSplitExonChangeDetails[]
+
+  constructor(json: SerializedUndoSplitExonChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedUndoSplitExonChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [
+        {
+          exonToRestore,
+          parentFeatureId,
+          idsToDelete,
+          upstreamCut,
+          downstreamCut,
+          leftExonId,
+          rightExonId,
+        },
+      ] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        exonToRestore,
+        parentFeatureId,
+        idsToDelete,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes } = this
+    for (const change of changes) {
+      const { exonToRestore, parentFeatureId, idsToDelete } = change
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: parentFeatureId })
+        .session(session)
+        .exec()
+      if (!topLevelFeature) {
+        throw new Error(`Could not find feature with ID "${parentFeatureId}"`)
+      }
+      const parentFeature = this.getFeatureFromId(
+        topLevelFeature,
+        parentFeatureId,
+      )
+      if (!parentFeature) {
+        throw new Error(
+          `Could not find feature with ID "${parentFeatureId}" in feature "${topLevelFeature._id.toString()}"`,
+        )
+      }
+      if (!parentFeature.children) {
+        parentFeature.children = new Map()
+      }
+
+      this.addChild(parentFeature, exonToRestore)
+      const childIds = this.getChildFeatureIds(exonToRestore)
+      topLevelFeature.allIds.push(exonToRestore._id, ...childIds)
+      topLevelFeature.allIds = topLevelFeature.allIds.filter(
+        (id) => !idsToDelete.includes(id),
+      )
+      idsToDelete.map((id) =>
+        findAndDeleteChildFeature(topLevelFeature, id, this),
+      )
+      await topLevelFeature.save()
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const { changes } = this
+    for (const change of changes) {
+      const { exonToRestore, parentFeatureId, idsToDelete } = change
+      if (!parentFeatureId) {
+        throw new Error('Parent ID is missing')
+      }
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+      // create an ID for the parent feature if it does not have one
+      if (!parentFeature.attributes.get('_id')) {
+        parentFeature.setAttribute('_id', [parentFeature._id])
+      }
+      parentFeature.addChild(exonToRestore)
+      idsToDelete.map((id) => {
+        parentFeature.deleteChild(id)
+      })
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes]
+      .reverse()
+      .map((undoSplitExonChange) => ({
+        parentFeatureId: undoSplitExonChange.parentFeatureId,
+        exonToBeSplit: undoSplitExonChange.exonToRestore,
+        upstreamCut: undoSplitExonChange.upstreamCut,
+        downstreamCut: undoSplitExonChange.downstreamCut,
+        leftExonId: undoSplitExonChange.leftExonId,
+        rightExonId: undoSplitExonChange.rightExonId,
+      }))
+
+    return new SplitExonChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'SplitExonChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}

package/src/Changes/index.ts

@@ -1,3 +1,4 @@
+import { AddAssemblyAliasesChange } from './AddAssemblyAliasesChange'
 import { AddAssemblyAndFeaturesFromFileChange } from './AddAssemblyAndFeaturesFromFileChange'
 import { AddAssemblyFromExternalChange } from './AddAssemblyFromExternalChange'
 import { AddAssemblyFromFileChange } from './AddAssemblyFromFileChange'
@@ -11,8 +12,14 @@ import { FeatureAttributeChange } from './FeatureAttributeChange'
 import { ImportJBrowseConfigChange } from './ImportJBrowseConfigChange'
 import { LocationEndChange } from './LocationEndChange'
 import { LocationStartChange } from './LocationStartChange'
+import { MergeExonsChange } from './MergeExonsChange'
+import { MergeTranscriptsChange } from './MergeTranscriptsChange'
+import { SplitExonChange } from './SplitExonChange'
 import { StrandChange } from './StrandChange'
 import { TypeChange } from './TypeChange'
+import { UndoMergeExonsChange } from './UndoMergeExonsChange'
+import { UndoMergeTranscriptsChange } from './UndoMergeTranscriptsChange'
+import { UndoSplitExonChange } from './UndoSplitExonChange'
 import { UserChange } from './UserChange'
 
 export const changes = {
@@ -28,10 +35,17 @@ export const changes = {
   ImportJBrowseConfigChange,
   LocationEndChange,
   LocationStartChange,
+  MergeExonsChange,
+  SplitExonChange,
+  MergeTranscriptsChange,
+  UndoMergeExonsChange,
+  UndoSplitExonChange,
+  UndoMergeTranscriptsChange,
   StrandChange,
   TypeChange,
   UserChange,
   AddRefSeqAliasesChange,
+  AddAssemblyAliasesChange,
 }
 
 export * from './AddAssemblyAndFeaturesFromFileChange'
@@ -46,7 +60,14 @@ export * from './FeatureAttributeChange'
 export * from './ImportJBrowseConfigChange'
 export * from './LocationEndChange'
 export * from './LocationStartChange'
+export * from './MergeExonsChange'
+export * from './SplitExonChange'
+export * from './MergeTranscriptsChange'
+export * from './UndoMergeExonsChange'
+export * from './UndoSplitExonChange'
+export * from './UndoMergeTranscriptsChange'
 export * from './StrandChange'
 export * from './TypeChange'
 export * from './UserChange'
 export * from './AddRefSeqAliasesChange'
+export * from './AddAssemblyAliasesChange'

package/src/Checks/CDSCheck.ts

@@ -22,7 +22,6 @@ enum CAUSES {
   'InternalStopCodon',
   'MissingStartCodon',
   'MissingStopCodon',
-  'MultipleOfThree',
 }
 
 const iupacComplements: Record<string, string | undefined> = {
@@ -156,6 +155,10 @@ async function checkMRNA(
   for (const cdsLocation of cdsLocations) {
     const sequence = await getCDSSequence(cdsLocation, strand, getSequence)
     const codons = splitSequenceInCodons(sequence)
+    const cdsEnd =
+      strand === -1
+        ? cdsLocation.at(0)?.min ?? min
+        : cdsLocation.at(-1)?.max ?? max
     if (sequence.length % 3 === 0) {
       const start_codon = codons.at(0)
       if (start_codon && !(start_codon.toUpperCase() in START_CODONS)) {
@@ -175,12 +178,9 @@ async function checkMRNA(
           message: `Unexpected start codon in feature "${_id}": ${start_codon}`,
         })
       }
+
       const lastCodon = codons.at(-1) // Last codon is supposed to be a stop
       if (lastCodon && !(lastCodon.toUpperCase() in STOP_CODONS)) {
-        const cdsEnd =
-          strand === -1
-            ? cdsLocation.at(0)?.min ?? min
-            : cdsLocation.at(-1)?.max ?? max
         checkResults.push({
           _id: new ObjectID().toHexString(),
           name: CHECK_NAME,
@@ -196,12 +196,12 @@ async function checkMRNA(
       checkResults.push({
         _id: new ObjectID().toHexString(),
         name: CHECK_NAME,
-        cause: CAUSES[CAUSES.MultipleOfThree],
+        cause: CAUSES[CAUSES.MissingStopCodon],
         ids,
         refSeq: refSeq.toString(),
-        start: min,
-        end: max,
-        message: `The coding sequence for feature "${_id}" is not a multiple of three`,
+        start: cdsEnd,
+        end: cdsEnd,
+        message: `Missing stop codon: The coding sequence for feature "${_id}" is not a multiple of three`,
       })
     }
     for (const [idx, codon] of codons.entries()) {
@@ -285,7 +285,7 @@ export class CDSCheck extends Check {
   name = CHECK_NAME
   causes = getCauses()
   version = 1
-  default = true
+  isDefault = true
 
   async checkFeature(
     feature: AnnotationFeatureSnapshot,