@apollo-annotation/shared 0.3.6 → 0.3.8

package/src/Changes/LocationStartChange.ts

@@ -60,19 +60,32 @@ export class LocationStartChange extends FeatureChange {
   async executeOnServer(backend: ServerDataStore) {
     const { featureModel, session } = backend
     const { changes, logger } = this
-    const featuresForChanges: {
-      feature: Feature
-      topLevelFeature: FeatureDocument
-    }[] = []
     // 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 } = change
-
-      // Search correct feature
-      const topLevelFeature = await featureModel
-        .findOne({ allIds: featureId })
-        .session(session)
-        .exec()
+      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}'`
@@ -84,57 +97,34 @@ export class LocationStartChange extends FeatureChange {
         `*** TOP level feature found: ${JSON.stringify(topLevelFeature)}`,
       )
 
-      const foundFeature = this.getFeatureFromId(topLevelFeature, featureId)
-      if (!foundFeature) {
+      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(foundFeature)}`)
-      if (foundFeature.min === oldStart) {
-        featuresForChanges.push({ feature: foundFeature, topLevelFeature })
-      } else {
-        if (foundFeature.children) {
-          for (const [, childFeature] of foundFeature.children) {
-            if (childFeature.min === oldStart) {
-              logger.debug?.(
-                `*** UPDATE CHILD FEATURE ID= ${featureId}, CHILD: ${JSON.stringify(
-                  childFeature,
-                )}`,
-              )
-              featuresForChanges.push({
-                feature: childFeature,
-                topLevelFeature,
-              })
-              break
-            }
-          }
-        }
+      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)
       }
-    }
-
-    // Let's update objects.
-    for (const [idx, change] of changes.entries()) {
-      const { newStart } = change
-      const { feature, topLevelFeature } = featuresForChanges[idx]
       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 topLevelFeature.save()
+        await tlv.save()
       } catch (error) {
         logger.debug?.(`*** FAILED: ${error}`)
         throw error
       }
-      logger.debug?.(
-        `*** Object updated in Mongo. New object: ${JSON.stringify(
-          topLevelFeature,
-        )}`,
-      )
     }
   }
 
@@ -146,12 +136,13 @@ export class LocationStartChange extends FeatureChange {
     if (!dataStore) {
       throw new Error('No data store')
     }
-    for (const [idx, changedId] of this.changedIds.entries()) {
-      const feature = dataStore.getFeature(changedId)
+    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 "${changedId}"`)
+        throw new Error(`Could not find feature with identifier "${featureId}"`)
       }
-      feature.setMin(this.changes[idx].newStart)
+      feature.setMin(newStart)
     }
   }
 

package/src/Changes/MergeExonsChange.ts

@@ -0,0 +1,201 @@
+/* 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'
+
+import { findAndDeleteChildFeature } from './DeleteFeatureChange'
+import { UndoMergeExonsChange } from './UndoMergeExonsChange'
+
+interface SerializedMergeExonsChangeBase extends SerializedFeatureChange {
+  typeName: 'MergeExonsChange'
+}
+
+export interface MergeExonsChangeDetails {
+  firstExon: AnnotationFeatureSnapshot
+  secondExon: AnnotationFeatureSnapshot
+  parentFeatureId: string
+}
+
+interface SerializedMergeExonsChangeSingle
+  extends SerializedMergeExonsChangeBase,
+    MergeExonsChangeDetails {}
+
+interface SerializedMergeExonsChangeMultiple
+  extends SerializedMergeExonsChangeBase {
+  changes: MergeExonsChangeDetails[]
+}
+
+export type SerializedMergeExonsChange =
+  | SerializedMergeExonsChangeSingle
+  | SerializedMergeExonsChangeMultiple
+
+export class MergeExonsChange extends FeatureChange {
+  typeName = 'MergeExonsChange' as const
+  changes: MergeExonsChangeDetails[]
+
+  constructor(json: SerializedMergeExonsChange, 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 'Exons successfully merged'
+  }
+
+  toJSON(): SerializedMergeExonsChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ firstExon, secondExon, parentFeatureId }] = changes
+
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        firstExon,
+        secondExon,
+        parentFeatureId,
+      }
+    }
+    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()
+    const inverseChanges = [...changes].reverse().map((mergeExonChange) => ({
+      exonsToRestore: [mergeExonChange.firstExon, mergeExonChange.secondExon],
+      parentFeatureId: mergeExonChange.parentFeatureId,
+    }))
+    logger.debug?.(`INVERSE CHANGE '${JSON.stringify(inverseChanges)}'`)
+    return new UndoMergeExonsChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'UndoMergeExonsChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+
+  // mergeAttributes(
+  //   firstExon: AnnotationFeatureSnapshot,
+  //   secondExon: AnnotationFeatureSnapshot,
+  // ): Record<string, string[]> {
+  //   let mergedAttrs: Record<string, string[]> = {}
+  //   if (firstExon.attributes) {
+  //     // eslint-disable-next-line unicorn/prefer-structured-clone
+  //     mergedAttrs = JSON.parse(JSON.stringify(firstExon.attributes))
+  //   }
+
+  //   if (secondExon.attributes) {
+  //     // eslint-disable-next-line unicorn/prefer-structured-clone
+  //     const attrs: Record<string, string[]> = JSON.parse(
+  //       JSON.stringify(secondExon.attributes),
+  //     )
+  //     for (const key of Object.keys(attrs)) {
+  //       if (key === '_id' || key === 'gff_id') {
+  //         continue
+  //       }
+  //       if (!Object.keys(mergedAttrs).includes(key)) {
+  //         mergedAttrs[key] = []
+  //       }
+  //       attrs[key].map((x) => {
+  //         if (!mergedAttrs[key].includes(x)) {
+  //           mergedAttrs[key].push(x)
+  //         }
+  //       })
+  //     }
+  //   }
+  //   return mergedAttrs
+  // }
+}