@apollo-annotation/shared 0.3.6 → 0.3.7

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/GFF3/annotationFeatureToGFF3.ts

@@ -252,7 +252,13 @@ function getTranscriptParts(
 function getCdsLocations(
   feature: AnnotationFeatureSnapshot,
 ): TranscriptPartCoding[][] {
-  const transcriptParts = getTranscriptParts(feature)
+  let transcriptParts: TranscriptParts[] = []
+  try {
+    transcriptParts = getTranscriptParts(feature)
+  } catch {
+    return []
+  }
+
   return transcriptParts.map((transcript) =>
     transcript.filter((transcriptPart) => transcriptPart.type === 'CDS'),
   )

package/src/Validations/ParentChildValidation.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
+
 import { type Change } from '@apollo-annotation/common'
 import { type Feature, type FeatureDocument } from '@apollo-annotation/schemas'
 import { type ClientSession, type Model } from 'mongoose'
@@ -10,6 +10,7 @@ import {
   isLocationEndChange,
   isLocationStartChange,
 } from '../Changes'
+import { getPrintableId } from '../util'
 
 import { Validation, type ValidationResult } from './Validation'
 
@@ -80,7 +81,7 @@ export class ParentChildValidation extends Validation {
         (childFeature.max > feature.max || childFeature.min < feature.min)
       ) {
         throw new Error(
-          `Feature "${childFeature._id}" exceeds the bounds of its parent, "${feature._id}"`,
+          `Feature ${getPrintableId(childFeature)} exceeds the bounds of its parent, ${getPrintableId(feature)}`,
         )
       }
       this.checkChildFeatureBoundaries(childFeature)

package/src/util.ts

@@ -1,3 +1,6 @@
+import { type AnnotationFeature } from '@apollo-annotation/mst'
+import { type Feature } from '@apollo-annotation/schemas'
+
 export function splitStringIntoChunks(
   input: string,
   chunkSize: number,
@@ -9,3 +12,16 @@ export function splitStringIntoChunks(
   }
   return chunks
 }
+
+export function getPrintableId(feature: Feature): string {
+  const ff = feature as unknown as AnnotationFeature
+  const gff_id = ff.attributes.get('gff_id')?.join(',')
+  if (gff_id) {
+    return `ID=${gff_id} (_id: ${feature._id.toString()})`
+  }
+  const gff_name = ff.attributes.get('gff_name')?.join(',')
+  if (gff_name) {
+    return `Name=${gff_name} (_id: ${feature._id.toString()})`
+  }
+  return `_id: ${feature._id.toString()}`
+}