@apollo-annotation/shared 0.3.6 → 0.3.7

package/src/Changes/SplitExonChange.ts

@@ -0,0 +1,249 @@
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+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 { UndoSplitExonChange } from './UndoSplitExonChange'
+
+interface SerializedSplitExonChangeBase extends SerializedFeatureChange {
+  typeName: 'SplitExonChange'
+}
+
+export interface SplitExonChangeDetails {
+  exonToBeSplit: AnnotationFeatureSnapshot
+  parentFeatureId: string
+  upstreamCut: number
+  downstreamCut: number
+  leftExonId: string
+  rightExonId: string
+}
+
+interface SerializedSplitExonChangeSingle
+  extends SerializedSplitExonChangeBase,
+    SplitExonChangeDetails {}
+
+interface SerializedSplitExonChangeMultiple
+  extends SerializedSplitExonChangeBase {
+  changes: SplitExonChangeDetails[]
+}
+
+export type SerializedSplitExonChange =
+  | SerializedSplitExonChangeSingle
+  | SerializedSplitExonChangeMultiple
+export class SplitExonChange extends FeatureChange {
+  typeName = 'SplitExonChange' as const
+  changes: SplitExonChangeDetails[]
+
+  constructor(json: SerializedSplitExonChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+  // eslint-disable-next-line @typescript-eslint/class-literal-property-style
+  get notification() {
+    return 'Exon successfully split'
+  }
+
+  toJSON(): SerializedSplitExonChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [
+        {
+          exonToBeSplit,
+          parentFeatureId,
+          upstreamCut,
+          downstreamCut,
+          leftExonId,
+          rightExonId,
+        },
+      ] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        exonToBeSplit,
+        parentFeatureId,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes, logger } = this
+    for (const change of changes) {
+      const {
+        exonToBeSplit,
+        parentFeatureId,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      } = change
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: exonToBeSplit._id })
+        .session(session)
+        .exec()
+      if (!topLevelFeature) {
+        const errMsg = `*** ERROR: The following featureId was not found in database ='${exonToBeSplit._id}'`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      const tx = this.getFeatureFromId(topLevelFeature, parentFeatureId)
+      if (!tx?.children) {
+        throw new Error(
+          'ERROR: There should be at least one child (i.e. the exon to be split)',
+        )
+      }
+
+      const [leftExon, rightExon] = this.makeSplitExons(
+        exonToBeSplit,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      )
+
+      tx.children.set(leftExon._id, {
+        allIds: [],
+        ...leftExon,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        _id: leftExon._id,
+      })
+      tx.children.set(rightExon._id, {
+        allIds: [],
+        ...rightExon,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        _id: rightExon._id,
+      })
+      // Child features should be sorted for click and drag of gene glyphs to work properly
+      tx.children = new Map(
+        [...tx.children.entries()].sort((a, b) => a[1].min - b[1].min),
+      )
+
+      const deletedIds = findAndDeleteChildFeature(
+        topLevelFeature,
+        exonToBeSplit._id,
+        this,
+      )
+      deletedIds.push(exonToBeSplit._id)
+      topLevelFeature.allIds = topLevelFeature.allIds.filter(
+        (id) => !deletedIds.includes(id),
+      )
+      topLevelFeature.allIds.push(leftExon._id, rightExon._id)
+      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')
+    }
+
+    for (const [idx] of this.changedIds.entries()) {
+      const {
+        exonToBeSplit,
+        parentFeatureId,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      } = this.changes[idx]
+      if (!parentFeatureId) {
+        throw new Error('TODO: Split exon without parent')
+      }
+
+      const [leftExon, rightExon] = this.makeSplitExons(
+        exonToBeSplit,
+        upstreamCut,
+        downstreamCut,
+        leftExonId,
+        rightExonId,
+      )
+
+      const parentFeature = dataStore.getFeature(parentFeatureId)
+      if (!parentFeature) {
+        throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+      }
+
+      parentFeature.addChild(leftExon)
+      parentFeature.addChild(rightExon)
+      if (dataStore.getFeature(exonToBeSplit._id)) {
+        dataStore.deleteFeature(exonToBeSplit._id)
+      }
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes].reverse().map((splitExonChange) => ({
+      exonToRestore: splitExonChange.exonToBeSplit,
+      parentFeatureId: splitExonChange.parentFeatureId,
+      idsToDelete: [splitExonChange.leftExonId, splitExonChange.rightExonId],
+      upstreamCut: splitExonChange.upstreamCut,
+      downstreamCut: splitExonChange.downstreamCut,
+      leftExonId: splitExonChange.leftExonId,
+      rightExonId: splitExonChange.rightExonId,
+    }))
+    logger.debug?.(`INVERSE CHANGE '${JSON.stringify(inverseChanges)}'`)
+    return new UndoSplitExonChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'UndoSplitExonChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+
+  makeSplitExons(
+    exonToBeSplit: AnnotationFeatureSnapshot,
+    upstreamCut: number,
+    downstreamCut: number,
+    leftExonId: string,
+    rightExonId: string,
+  ): AnnotationFeatureSnapshot[] {
+    // eslint-disable-next-line unicorn/prefer-structured-clone
+    const exon = JSON.parse(JSON.stringify(exonToBeSplit))
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    delete exon.attributes._id
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    delete exon.attributes.gff_id
+
+    const leftExon = structuredClone(
+      exon,
+    ) as unknown as AnnotationFeatureSnapshot
+    leftExon._id = leftExonId
+    leftExon.max = upstreamCut
+
+    const rightExon = structuredClone(
+      exon,
+    ) as unknown as AnnotationFeatureSnapshot
+    rightExon.min = downstreamCut
+    rightExon._id = rightExonId
+
+    return [leftExon, rightExon]
+  }
+}

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 },
+    )
+  }
+}