@apollo-annotation/shared 0.3.12 → 1.0.0

package/src/Changes/LocationEndChange.ts

@@ -1,15 +1,9 @@
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable @typescript-eslint/require-await */
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 import {
   type ChangeOptions,
-  type ClientDataStore,
   FeatureChange,
-  type LocalGFF3DataStore,
   type SerializedFeatureChange,
-  type ServerDataStore,
 } from '@apollo-annotation/common'
-import type { Feature, FeatureDocument } from '@apollo-annotation/schemas'
 
 interface SerializedLocationEndChangeBase extends SerializedFeatureChange {
   typeName: 'LocationEndChange'
@@ -52,100 +46,6 @@ export class LocationEndChange extends FeatureChange {
     return { typeName, changedIds, assembly, changes }
   }
 
-  /**
-   * Applies the required change to database
-   * @param backend - parameters from backend
-   * @returns
-   */
-  async executeOnServer(backend: ServerDataStore) {
-    const { featureModel, session } = backend
-    const { changes, logger } = this
-    // Let's first check that all features are found and those old values match with expected ones. We do this just to be sure that all changes can be done.
-    const topLevelFeatures: FeatureDocument[] = []
-    for (const change of changes) {
-      const { featureId, oldEnd, newEnd } = change
-
-      // See if we already have top-level feature for this feature
-      let topLevelFeature: FeatureDocument | undefined | null
-      let feature: Feature | undefined | null
-      for (const tlv of topLevelFeatures) {
-        const childFeature = this.getFeatureFromId(tlv, featureId)
-        if (childFeature) {
-          topLevelFeature = tlv
-          feature = childFeature
-          break
-        }
-      }
-      if (!topLevelFeature) {
-        // Don't already have top-level feature, so let's query it
-        topLevelFeature = await featureModel
-          .findOne({ allIds: featureId })
-          .session(session)
-          .exec()
-        if (topLevelFeature) {
-          topLevelFeatures.push(topLevelFeature)
-        }
-      }
-
-      if (!topLevelFeature) {
-        const errMsg = `*** ERROR: The following featureId was not found in database ='${featureId}'`
-        logger.error(errMsg)
-        throw new Error(errMsg)
-        // throw new NotFoundException(errMsg)  -- This is causing runtime error because Exception comes from @nestjs/common!!!
-      }
-      logger.debug?.(
-        `*** TOP level feature found: ${JSON.stringify(topLevelFeature)}`,
-      )
-
-      if (!feature) {
-        feature = this.getFeatureFromId(topLevelFeature, featureId)
-      }
-      if (!feature) {
-        const errMsg = 'ERROR when searching feature by featureId'
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      logger.debug?.(`*** Found feature: ${JSON.stringify(feature)}`)
-      if (feature.max !== oldEnd) {
-        const errMsg = 'Expected previous max does not match'
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      feature.max = newEnd
-      if (topLevelFeature._id.equals(feature._id)) {
-        topLevelFeature.markModified('end') // Mark as modified. Without this save() -method is not updating data in database
-      } else {
-        topLevelFeature.markModified('children') // Mark as modified. Without this save() -method is not updating data in database
-      }
-    }
-    for (const tlv of topLevelFeatures) {
-      try {
-        await tlv.save()
-      } catch (error) {
-        logger.debug?.(`*** FAILED: ${error}`)
-        throw error
-      }
-    }
-  }
-
-  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
-    throw new Error('executeOnLocalGFF3 not implemented')
-  }
-
-  async executeOnClient(dataStore: ClientDataStore) {
-    if (!dataStore) {
-      throw new Error('No data store')
-    }
-    for (const change of this.changes) {
-      const { featureId, newEnd } = change
-      const feature = dataStore.getFeature(featureId)
-      if (!feature) {
-        throw new Error(`Could not find feature with identifier "${featureId}"`)
-      }
-      feature.setMax(newEnd)
-    }
-  }
-
   getInverse() {
     const { assembly, changedIds, changes, logger, typeName } = this
     const inverseChangedIds = [...changedIds].reverse()

package/src/Changes/LocationStartChange.ts

@@ -1,15 +1,9 @@
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable @typescript-eslint/require-await */
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 import {
   type ChangeOptions,
-  type ClientDataStore,
   FeatureChange,
-  type LocalGFF3DataStore,
   type SerializedFeatureChange,
-  type ServerDataStore,
 } from '@apollo-annotation/common'
-import type { Feature, FeatureDocument } from '@apollo-annotation/schemas'
 
 interface SerializedLocationStartChangeBase extends SerializedFeatureChange {
   typeName: 'LocationStartChange'
@@ -52,100 +46,6 @@ export class LocationStartChange extends FeatureChange {
     return { typeName, changedIds, assembly, changes }
   }
 
-  /**
-   * Applies the required change to database
-   * @param backend - parameters from backend
-   * @returns
-   */
-  async executeOnServer(backend: ServerDataStore) {
-    const { featureModel, session } = backend
-    const { changes, logger } = this
-    // Let's first check that all features are found and those old values match with expected ones. We do this just to be sure that all changes can be done.
-    const topLevelFeatures: FeatureDocument[] = []
-    for (const change of changes) {
-      const { featureId, oldStart, newStart } = change
-
-      // See if we already have top-level feature for this feature
-      let topLevelFeature: FeatureDocument | undefined | null
-      let feature: Feature | undefined | null
-      for (const tlv of topLevelFeatures) {
-        const childFeature = this.getFeatureFromId(tlv, featureId)
-        if (childFeature) {
-          topLevelFeature = tlv
-          feature = childFeature
-          break
-        }
-      }
-      if (!topLevelFeature) {
-        // Don't already have top-level feature, so let's query it
-        topLevelFeature = await featureModel
-          .findOne({ allIds: featureId })
-          .session(session)
-          .exec()
-        if (topLevelFeature) {
-          topLevelFeatures.push(topLevelFeature)
-        }
-      }
-
-      if (!topLevelFeature) {
-        const errMsg = `*** ERROR: The following featureId was not found in database ='${featureId}'`
-        logger.error(errMsg)
-        throw new Error(errMsg)
-        // throw new NotFoundException(errMsg)  -- This is causing runtime error because Exception comes from @nestjs/common!!!
-      }
-      logger.debug?.(
-        `*** TOP level feature found: ${JSON.stringify(topLevelFeature)}`,
-      )
-
-      if (!feature) {
-        feature = this.getFeatureFromId(topLevelFeature, featureId)
-      }
-      if (!feature) {
-        const errMsg = 'ERROR when searching feature by featureId'
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      logger.debug?.(`*** Found feature: ${JSON.stringify(feature)}`)
-      if (feature.min !== oldStart) {
-        const errMsg = 'Expected previous max does not match'
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      feature.min = newStart
-      if (topLevelFeature._id.equals(feature._id)) {
-        topLevelFeature.markModified('start') // Mark as modified. Without this save() -method is not updating data in database
-      } else {
-        topLevelFeature.markModified('children') // Mark as modified. Without this save() -method is not updating data in database
-      }
-    }
-    for (const tlv of topLevelFeatures) {
-      try {
-        await tlv.save()
-      } catch (error) {
-        logger.debug?.(`*** FAILED: ${error}`)
-        throw error
-      }
-    }
-  }
-
-  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
-    throw new Error('executeOnLocalGFF3 not implemented')
-  }
-
-  async executeOnClient(dataStore: ClientDataStore) {
-    if (!dataStore) {
-      throw new Error('No data store')
-    }
-    for (const change of this.changes) {
-      const { featureId, newStart } = change
-      const feature = dataStore.getFeature(featureId)
-      if (!feature) {
-        throw new Error(`Could not find feature with identifier "${featureId}"`)
-      }
-      feature.setMin(newStart)
-    }
-  }
-
   getInverse() {
     const { assembly, changedIds, changes, logger, typeName } = this
     const inverseChangedIds = [...changedIds].reverse()

package/src/Changes/{MergeExonsChange.ts → MergeAndUndoMergeExonsChanges.ts}

@@ -1,22 +1,10 @@
-/* eslint-disable unicorn/prefer-structured-clone */
-/* 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 { attributesToRecords, stringifyAttributes } from '../util.js'
-
-import { findAndDeleteChildFeature } from './DeleteFeatureChange.js'
-import { UndoMergeExonsChange } from './UndoMergeExonsChange.js'
-
 interface SerializedMergeExonsChangeBase extends SerializedFeatureChange {
   typeName: 'MergeExonsChange'
 }
@@ -40,6 +28,28 @@ export type SerializedMergeExonsChange =
   | SerializedMergeExonsChangeSingle
   | SerializedMergeExonsChangeMultiple
 
+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 MergeExonsChange extends FeatureChange {
   typeName = 'MergeExonsChange' as const
   changes: MergeExonsChangeDetails[]
@@ -70,84 +80,6 @@ export class MergeExonsChange extends FeatureChange {
     return { typeName, changedIds, assembly, changes }
   }
 
-  async executeOnServer(backend: ServerDataStore) {
-    const { featureModel, session } = backend
-    const { changes, logger } = this
-    for (const change of changes) {
-      const { firstExon, secondExon } = change
-      const topLevelFeature = await featureModel
-        .findOne({ allIds: firstExon._id })
-        .session(session)
-        .exec()
-      if (!topLevelFeature) {
-        const errMsg = `*** ERROR: The following featureId was not found in database ='${firstExon._id}'`
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      const mergedExon = this.getFeatureFromId(topLevelFeature, firstExon._id)
-      if (!mergedExon) {
-        const errMsg = 'ERROR when searching feature by featureId'
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      mergedExon.min = Math.min(firstExon.min, secondExon.min)
-      mergedExon.max = Math.max(firstExon.max, secondExon.max)
-
-      const mergedAttributes: Record<string, string[]> = mergedExon.attributes
-        ? JSON.parse(JSON.stringify(mergedExon.attributes))
-        : {}
-      mergedAttributes.merged_with = [
-        stringifyAttributes(attributesToRecords(secondExon.attributes)),
-      ]
-      mergedExon.attributes = mergedAttributes
-
-      const deletedIds = findAndDeleteChildFeature(
-        topLevelFeature,
-        secondExon._id,
-        this,
-      )
-      deletedIds.push(secondExon._id)
-      topLevelFeature.allIds = topLevelFeature.allIds.filter(
-        (id) => !deletedIds.includes(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 change of this.changes) {
-      const { firstExon, secondExon } = change
-      const mergedExon = dataStore.getFeature(firstExon._id)
-      if (!mergedExon) {
-        throw new Error(
-          `Could not find feature with identifier "${firstExon._id}"`,
-        )
-      }
-      mergedExon.setMin(Math.min(firstExon.min, secondExon.min))
-      mergedExon.setMax(Math.max(firstExon.max, secondExon.max))
-
-      const mrg = mergedExon.attributes.get('merged_with')?.slice() ?? []
-      const mergedWith = stringifyAttributes(
-        attributesToRecords(secondExon.attributes),
-      )
-      if (!mrg.includes(mergedWith)) {
-        mrg.push(mergedWith)
-      }
-      mergedExon.setAttribute('merged_with', mrg)
-
-      mergedExon.parent?.deleteChild(secondExon._id)
-    }
-  }
-
   getInverse() {
     const { assembly, changedIds, changes, logger } = this
     const inverseChangedIds = [...changedIds].reverse()
@@ -199,3 +131,51 @@ export class MergeExonsChange extends FeatureChange {
   //   return mergedAttrs
   // }
 }
+
+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 }
+  }
+
+  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/{MergeTranscriptsChange.ts → MergeAndUndoMergeTranscriptsChanges.ts}

@@ -1,14 +1,10 @@
 /* eslint-disable unicorn/prefer-structured-clone */
-/* 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 {
   AnnotationFeature,
@@ -20,9 +16,6 @@ import { getSnapshot } from '@jbrowse/mobx-state-tree'
 
 import { attributesToRecords, stringifyAttributes } from '../util.js'
 
-import { findAndDeleteChildFeature } from './DeleteFeatureChange.js'
-import { UndoMergeTranscriptsChange } from './UndoMergeTranscriptsChange.js'
-
 interface SerializedMergeTranscriptsChangeBase extends SerializedFeatureChange {
   typeName: 'MergeTranscriptsChange'
 }
@@ -46,6 +39,29 @@ export type SerializedMergeTranscriptsChange =
   | SerializedMergeTranscriptsChangeSingle
   | SerializedMergeTranscriptsChangeMultiple
 
+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 MergeTranscriptsChange extends FeatureChange {
   typeName = 'MergeTranscriptsChange' as const
   changes: MergeTranscriptsChangeDetails[]
@@ -76,43 +92,6 @@ export class MergeTranscriptsChange extends FeatureChange {
     return { typeName, changedIds, assembly, changes }
   }
 
-  async executeOnServer(backend: ServerDataStore) {
-    const { featureModel, session } = backend
-    const { changes, logger } = this
-    for (const change of changes) {
-      const { firstTranscript, secondTranscript } = change
-      const topLevelFeature = await featureModel
-        .findOne({ allIds: firstTranscript._id })
-        .session(session)
-        .exec()
-      if (!topLevelFeature) {
-        const errMsg = `*** ERROR: The following featureId was not found in database ='${firstTranscript._id}'`
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      const mergedTranscript = this.getFeatureFromId(
-        topLevelFeature,
-        firstTranscript._id,
-      )
-      if (!mergedTranscript) {
-        const errMsg = 'ERROR when searching feature by featureId'
-        logger.error(errMsg)
-        throw new Error(errMsg)
-      }
-      this.mergeTranscriptsOnServer(mergedTranscript, secondTranscript)
-      const deletedIds = findAndDeleteChildFeature(
-        topLevelFeature,
-        secondTranscript._id,
-        this,
-      )
-      deletedIds.push(secondTranscript._id)
-      topLevelFeature.allIds = topLevelFeature.allIds.filter(
-        (id) => !deletedIds.includes(id),
-      )
-      await topLevelFeature.save()
-    }
-  }
-
   mergeTranscriptsOnServer(
     firstTranscript: Feature,
     secondTranscript: AnnotationFeatureSnapshot,
@@ -243,24 +222,6 @@ export class MergeTranscriptsChange extends FeatureChange {
     }
   }
 
-  /* --------------------------------- */
-
-  async executeOnClient(dataStore: ClientDataStore) {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!dataStore) {
-      throw new Error('No data store')
-    }
-    for (const [idx, changedId] of this.changedIds.entries()) {
-      const { firstTranscript, secondTranscript } = this.changes[idx]
-      const mergedTranscript = dataStore.getFeature(firstTranscript._id)
-      if (!mergedTranscript) {
-        throw new Error(`Could not find feature with identifier "${changedId}"`)
-      }
-      this.mergeTranscriptsOnClient(mergedTranscript, secondTranscript)
-      mergedTranscript.parent?.deleteChild(secondTranscript._id)
-    }
-  }
-
   mergeTranscriptsOnClient(
     firstTranscript: AnnotationFeature,
     secondTranscript: AnnotationFeatureSnapshot,
@@ -364,10 +325,6 @@ export class MergeTranscriptsChange extends FeatureChange {
     }
   }
 
-  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
-    throw new Error('executeOnLocalGFF3 not implemented')
-  }
-
   getInverse() {
     const { assembly, changedIds, changes, logger } = this
     const inverseChangedIds = [...changedIds].reverse()
@@ -392,3 +349,54 @@ export class MergeTranscriptsChange extends FeatureChange {
     )
   }
 }
+
+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 }
+  }
+
+  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 },
+    )
+  }
+}