@apollo-annotation/shared 0.1.11

package/src/Changes/AddFeaturesFromFileChange.ts

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  AssemblySpecificChange,
+  ChangeOptions,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  SerializedAssemblySpecificChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { GFF3Feature } from '@gmod/gff'
+
+export interface SerializedAddFeaturesFromFileChangeBase
+  extends SerializedAssemblySpecificChange {
+  typeName: 'AddFeaturesFromFileChange'
+  deleteExistingFeatures?: boolean
+}
+
+export interface AddFeaturesFromFileChangeDetails {
+  fileId: string
+}
+
+export interface SerializedAddFeaturesFromFileChangeSingle
+  extends SerializedAddFeaturesFromFileChangeBase,
+    AddFeaturesFromFileChangeDetails {}
+
+export interface SerializedAddFeaturesFromFileChangeMultiple
+  extends SerializedAddFeaturesFromFileChangeBase {
+  changes: AddFeaturesFromFileChangeDetails[]
+}
+
+export type SerializedAddFeaturesFromFileChange =
+  | SerializedAddFeaturesFromFileChangeSingle
+  | SerializedAddFeaturesFromFileChangeMultiple
+
+export class AddFeaturesFromFileChange extends AssemblySpecificChange {
+  typeName = 'AddFeaturesFromFileChange' as const
+  changes: AddFeaturesFromFileChangeDetails[]
+  deleteExistingFeatures = false
+
+  constructor(
+    json: SerializedAddFeaturesFromFileChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.deleteExistingFeatures = json.deleteExistingFeatures ?? false
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  // eslint-disable-next-line @typescript-eslint/class-literal-property-style
+  get notification(): string {
+    return 'Features have been added. To see them, please refresh the page.'
+  }
+
+  toJSON(): SerializedAddFeaturesFromFileChange {
+    const { assembly, changes, deleteExistingFeatures, typeName } = this
+    if (changes.length === 1) {
+      const [{ fileId }] = changes
+      return { typeName, assembly, fileId, deleteExistingFeatures }
+    }
+    return { typeName, assembly, changes, deleteExistingFeatures }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { fileModel, filesService } = backend
+    const { changes, deleteExistingFeatures, logger } = this
+
+    if (deleteExistingFeatures) {
+      await this.removeExistingFeatures(backend)
+    }
+
+    for (const change of changes) {
+      const { fileId } = change
+
+      const { FILE_UPLOAD_FOLDER } = process.env
+      if (!FILE_UPLOAD_FOLDER) {
+        throw new Error('No FILE_UPLOAD_FOLDER found in .env file')
+      }
+      // Get file checksum
+      const fileDoc = await fileModel.findById(fileId).exec()
+      if (!fileDoc) {
+        throw new Error(`File "${fileId}" not found in Mongo`)
+      }
+      logger.debug?.(`FileId "${fileId}", checksum "${fileDoc.checksum}"`)
+
+      // Read data from compressed file and parse the content
+      const featureStream = filesService.parseGFF3(
+        filesService.getFileStream(fileDoc),
+      )
+      for await (const f of featureStream) {
+        const gff3Feature = f as GFF3Feature
+        logger.verbose?.(`ENTRY=${JSON.stringify(gff3Feature)}`)
+
+        // Add new feature into database
+        // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+        await this.addFeatureIntoDb(gff3Feature, backend)
+      }
+    }
+    logger.debug?.('New features added into database!')
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async executeOnClient(_dataStore: ClientDataStore) {}
+
+  getInverse() {
+    const { assembly, changes, logger, typeName } = this
+    return new AddFeaturesFromFileChange(
+      { typeName, changes, assembly },
+      { logger },
+    )
+  }
+}

package/src/Changes/DeleteAssemblyChange.ts

@@ -0,0 +1,100 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+import {
+  AssemblySpecificChange,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  SerializedAssemblySpecificChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { getSession } from '@jbrowse/core/util'
+
+interface SerializedDeleteAssemblyChange
+  extends SerializedAssemblySpecificChange {
+  typeName: 'DeleteAssemblyChange'
+}
+export class DeleteAssemblyChange extends AssemblySpecificChange {
+  typeName = 'DeleteAssemblyChange' as const
+
+  get notification(): string {
+    return `Assembly "${this.assembly}" deleted successfully.`
+  }
+
+  toJSON(): SerializedDeleteAssemblyChange {
+    const { assembly, typeName } = this
+    return { typeName, assembly }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const {
+      assemblyModel,
+      featureModel,
+      refSeqChunkModel,
+      refSeqModel,
+      session,
+    } = backend
+    const { assembly, logger } = this
+
+    const assemblyDoc = await assemblyModel
+      .findById(assembly)
+      .session(session)
+      .exec()
+    if (!assemblyDoc) {
+      const errMsg = `*** ERROR: Assembly with id "${assembly}" not found`
+      logger.error(errMsg)
+      throw new Error(errMsg)
+    }
+
+    // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+
+    // Get RefSeqs
+    const refSeqs = await refSeqModel.find({ assembly }).exec()
+    const refSeqIds = refSeqs.map((refSeq) => refSeq._id)
+
+    // Get and delete RefSeqChunks
+    await refSeqChunkModel.deleteMany({ refSeq: refSeqIds }).exec()
+
+    // Get and delete Features
+    await featureModel.deleteMany({ refSeq: refSeqIds }).exec()
+
+    // Delete RefSeqs and Assembly
+    await refSeqModel.deleteMany({ assembly }).exec()
+    await assemblyModel.findByIdAndDelete(assembly).exec()
+
+    logger.debug?.(`Assembly "${assembly}" deleted from database.`)
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    const { assembly } = this
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const session = getSession(dataStore)
+    // If assemblyId is not present in client data store
+    if (dataStore.assemblies.has(assembly)) {
+      dataStore.deleteAssembly(assembly)
+    }
+    await session.removeAssembly?.(assembly)
+    // @ts-expect-error this isn't on the AbstractSessionModel
+    await session.removeSessionAssembly?.(assembly)
+  }
+
+  getInverse() {
+    const { assembly, logger } = this
+    return new DeleteAssemblyChange(
+      { typeName: 'DeleteAssemblyChange', assembly },
+      { logger },
+    )
+  }
+}

package/src/Changes/DeleteFeatureChange.ts

@@ -0,0 +1,200 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import {
+  ChangeOptions,
+  ClientDataStore,
+  FeatureChange,
+  LocalGFF3DataStore,
+  SerializedFeatureChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+import { Feature } from '@apollo-annotation/schemas'
+
+import { AddFeatureChange } from './AddFeatureChange'
+
+interface SerializedDeleteFeatureChangeBase extends SerializedFeatureChange {
+  typeName: 'DeleteFeatureChange'
+}
+
+export interface DeleteFeatureChangeDetails {
+  deletedFeature: AnnotationFeatureSnapshot
+  parentFeatureId?: string // Parent feature from where feature was deleted.
+}
+
+interface SerializedDeleteFeatureChangeSingle
+  extends SerializedDeleteFeatureChangeBase,
+    DeleteFeatureChangeDetails {}
+
+interface SerializedDeleteFeatureChangeMultiple
+  extends SerializedDeleteFeatureChangeBase {
+  changes: DeleteFeatureChangeDetails[]
+}
+
+type SerializedDeleteFeatureChange =
+  | SerializedDeleteFeatureChangeSingle
+  | SerializedDeleteFeatureChangeMultiple
+
+export class DeleteFeatureChange extends FeatureChange {
+  typeName = 'DeleteFeatureChange' as const
+  changes: DeleteFeatureChangeDetails[]
+
+  constructor(json: SerializedDeleteFeatureChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedDeleteFeatureChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ deletedFeature, parentFeatureId }] = changes
+      return { typeName, changedIds, assembly, deletedFeature, parentFeatureId }
+    }
+    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
+
+    // Loop the changes
+    for (const change of changes) {
+      const { deletedFeature, parentFeatureId } = change
+
+      // Search feature
+      const featureDoc = await featureModel
+        .findOne({ allIds: deletedFeature._id })
+        .session(session)
+        .exec()
+      if (!featureDoc) {
+        const errMsg = `*** ERROR: The following featureId was not found in database ='${deletedFeature._id}'`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+
+      // Check if feature is on top level, then simply delete the whole document (i.e. not just sub-feature inside document)
+      if (featureDoc._id.equals(deletedFeature._id)) {
+        if (parentFeatureId) {
+          throw new Error(
+            `Feature "${deletedFeature._id}" is top-level, but received a parent feature ID`,
+          )
+        }
+        await featureModel.findByIdAndDelete(featureDoc._id)
+        logger.debug?.(
+          `Feature "${deletedFeature._id}" deleted from document "${featureDoc._id}". Whole document deleted.`,
+        )
+        continue
+      }
+
+      const deletedIds = this.findAndDeleteChildFeature(
+        featureDoc,
+        deletedFeature._id,
+      )
+      deletedIds.push(deletedFeature._id)
+      featureDoc.allIds = featureDoc.allIds.filter(
+        (id) => !deletedIds.includes(id),
+      )
+      // Save updated document in Mongo
+      featureDoc.markModified('children') // Mark as modified. Without this save() -method is not updating data in database
+      try {
+        await featureDoc.save()
+      } catch (error) {
+        logger.debug?.(`*** FAILED: ${error}`)
+        throw error
+      }
+
+      logger.debug?.(
+        `Feature "${deletedFeature._id}" deleted from document "${featureDoc._id}"`,
+      )
+    }
+  }
+
+  /**
+   * Delete feature's subfeatures that match an ID and return the IDs of any
+   * sub-subfeatures that were deleted
+   * @param feature -
+   * @param featureIdToDelete -
+   * @returns - list of deleted feature IDs
+   */
+  findAndDeleteChildFeature(
+    feature: Feature,
+    featureIdToDelete: string,
+  ): string[] {
+    if (!feature.children) {
+      throw new Error(`Feature ${feature._id} has no children`)
+    }
+    const { _id, children } = feature
+    const child = children.get(featureIdToDelete)
+    if (child) {
+      const deletedIds = this.getChildFeatureIds(child)
+      children.delete(featureIdToDelete)
+      return deletedIds
+    }
+    for (const [, childFeature] of children) {
+      try {
+        return this.findAndDeleteChildFeature(childFeature, featureIdToDelete)
+      } catch {
+        // pass
+      }
+    }
+
+    throw new Error(`Feature "${featureIdToDelete}" not found in ${_id}`)
+  }
+
+  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 { deletedFeature, parentFeatureId } = change
+      if (parentFeatureId) {
+        const parentFeature = dataStore.getFeature(parentFeatureId)
+        if (!parentFeature) {
+          throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+        }
+        parentFeature.deleteChild(deletedFeature._id)
+      } else {
+        if (dataStore.getFeature(deletedFeature._id)) {
+          dataStore.deleteFeature(deletedFeature._id)
+        }
+      }
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes]
+      .reverse()
+      .map((deleteFeatuerChange) => ({
+        addedFeature: deleteFeatuerChange.deletedFeature,
+        parentFeatureId: deleteFeatuerChange.parentFeatureId,
+      }))
+    logger.debug?.(`INVERSE CHANGE '${JSON.stringify(inverseChanges)}'`)
+    return new AddFeatureChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'AddFeatureChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}
+
+export function isDeleteFeatureChange(
+  change: unknown,
+): change is DeleteFeatureChange {
+  return (change as DeleteFeatureChange).typeName === 'DeleteFeatureChange'
+}

package/src/Changes/DeleteUserChange.ts

@@ -0,0 +1,83 @@
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  Change,
+  ChangeOptions,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  SerializedChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+
+export interface SerializedDeleteUserChangeBase extends SerializedChange {
+  typeName: 'DeleteUserChange'
+  userId: string
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface DeleteUserChangeDetails {}
+
+interface SerializedDeleteUserChangeSingle
+  extends SerializedDeleteUserChangeBase,
+    DeleteUserChangeDetails {}
+
+interface SerializedDeleteUserChangeMultiple
+  extends SerializedDeleteUserChangeBase {
+  changes: DeleteUserChangeDetails[]
+}
+
+export type SerializedDeleteUserChange =
+  | SerializedDeleteUserChangeSingle
+  | SerializedDeleteUserChangeMultiple
+
+export class DeleteUserChange extends Change {
+  typeName = 'DeleteUserChange' as const
+  changes: DeleteUserChangeDetails[]
+  userId: string
+
+  constructor(json: SerializedDeleteUserChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+    this.userId = json.userId
+  }
+
+  toJSON(): SerializedDeleteUserChange {
+    const { typeName, userId } = this
+    return { typeName, userId }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { session, userModel } = backend
+    const { logger, userId } = this
+    const user = await userModel
+      .findOneAndDelete({ _id: userId })
+      .session(session)
+      .exec()
+    if (!user) {
+      const errMsg = `*** ERROR: User with id "${userId}" not found`
+      logger.error(errMsg)
+      throw new Error(errMsg)
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async executeOnClient(_dataStore: ClientDataStore) {}
+
+  getInverse() {
+    const { logger, typeName, userId } = this
+    return new DeleteUserChange({ typeName, userId }, { logger })
+    //   const inverseChangedIds = this.changedIds.slice().reverse()
+    //   const inverseChanges = this.changes
+    //     .slice()
+    //     .reverse()
+    //     .map((deleteUserChange) => ({
+    //       addedUser: deleteUserChange.userId,
+    //     }))
+    //   this.logger.debug?.(`INVERSE CHANGE '${JSON.stringify(inverseChanges)}'`)
+    //   // return new AddUserChange()
+    // }
+  }
+}

package/src/Changes/DiscontinuousLocationEndChange.ts

@@ -0,0 +1,182 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  ChangeOptions,
+  ClientDataStore,
+  FeatureChange,
+  LocalGFF3DataStore,
+  SerializedFeatureChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+
+interface SerializedDiscontinuousLocationEndChangeBase
+  extends SerializedFeatureChange {
+  typeName: 'DiscontinuousLocationEndChange'
+}
+
+interface DiscontinuousLocationEndChangeDetails {
+  featureId: string
+  oldEnd: number
+  newEnd: number
+  index: number
+}
+
+interface SerializedDiscontinuousLocationEndChangeSingle
+  extends SerializedDiscontinuousLocationEndChangeBase,
+    DiscontinuousLocationEndChangeDetails {}
+
+interface SerializedDiscontinuousLocationEndChangeMultiple
+  extends SerializedDiscontinuousLocationEndChangeBase {
+  changes: DiscontinuousLocationEndChangeDetails[]
+}
+
+type SerializedDiscontinuousLocationEndChange =
+  | SerializedDiscontinuousLocationEndChangeSingle
+  | SerializedDiscontinuousLocationEndChangeMultiple
+
+export class DiscontinuousLocationEndChange extends FeatureChange {
+  typeName = 'DiscontinuousLocationEndChange' as const
+  changes: DiscontinuousLocationEndChangeDetails[]
+
+  constructor(
+    json: SerializedDiscontinuousLocationEndChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedDiscontinuousLocationEndChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ featureId, index, newEnd, oldEnd }] = changes
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        featureId,
+        oldEnd,
+        newEnd,
+        index,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes, logger } = this
+    for (const change of changes) {
+      const { featureId, index, newEnd, oldEnd: expectedOldEnd } = change
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: featureId })
+        .session(session)
+        .exec()
+
+      if (!topLevelFeature) {
+        const errMsg = `ERROR: The following featureId was not found in database ='${featureId}'`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+
+      const 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.discontinuousLocations ||
+        feature.discontinuousLocations.length === 0
+      ) {
+        const errMsg =
+          'Must use "LocationEndChange" to change a feature end that does not have discontinuous locations'
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      const oldEnd = feature.discontinuousLocations[index].end
+      if (oldEnd !== expectedOldEnd) {
+        const errMsg = `Location's current end value ${oldEnd} doesn't match with expected value ${expectedOldEnd}`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      const { start } = feature.discontinuousLocations[index]
+      if (newEnd <= start) {
+        const errMsg = `location end (${newEnd}) can't be smaller than location start (${start})`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      const nextLocation = feature.discontinuousLocations[index + 1]
+      if (nextLocation && newEnd >= nextLocation.start) {
+        const errMsg = `Location end (${newEnd}) can't be larger than  the next location's start (${nextLocation.start})`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      feature.discontinuousLocations[index].end = newEnd
+      if (index === feature.discontinuousLocations.length - 1) {
+        feature.end = newEnd
+      }
+
+      try {
+        if (topLevelFeature._id.equals(feature._id)) {
+          topLevelFeature.markModified('discontinuousLocations')
+        } else {
+          topLevelFeature.markModified('children')
+        }
+        await topLevelFeature.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 [idx, changedId] of this.changedIds.entries()) {
+      const feature = dataStore.getFeature(changedId)
+      if (!feature) {
+        throw new Error(`Could not find feature with identifier "${changedId}"`)
+      }
+      const { index, newEnd } = this.changes[idx]
+      feature.setCDSDiscontinuousLocationEnd(newEnd, index)
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger, typeName } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes].reverse().map((change) => ({
+      featureId: change.featureId,
+      oldEnd: change.newEnd,
+      newEnd: change.oldEnd,
+      index: change.index,
+    }))
+    return new DiscontinuousLocationEndChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName,
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}
+
+export function isDiscontinuousLocationEndChange(
+  change: unknown,
+): change is DiscontinuousLocationEndChange {
+  return (
+    (change as DiscontinuousLocationEndChange).typeName ===
+    'DiscontinuousLocationEndChange'
+  )
+}