@apollo-annotation/shared 0.1.18 → 0.1.19

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@apollo-annotation/shared",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "main": "./dist/index.js",
   "scripts": {
     "start": "tsc --build --watch",
     "build": "yarn clean && tsc --build",
-    "clean": "rimraf dist"
+    "clean": "rimraf dist",
+    "test": "glob -c \"tsx --test --test-reporter spec \" \"**/*.test.ts\"",
+    "test:ci": "NODE_V8_COVERAGE=./coverage glob -c \"tsx --test --test-reporter spec --experimental-test-coverage \" \"**/*.test.ts\""
   },
   "dependencies": {
-    "@apollo-annotation/common": "^0.1.18",
-    "@apollo-annotation/mst": "^0.1.18",
-    "@apollo-annotation/schemas": "^0.1.18",
+    "@apollo-annotation/common": "^0.1.19",
+    "@apollo-annotation/mst": "^0.1.19",
+    "@apollo-annotation/schemas": "^0.1.19",
     "@gmod/gff": "1.2.0",
     "@gmod/indexedfasta": "^2.0.4",
-    "@jbrowse/core": "^2.7.0",
+    "@jbrowse/core": "^2.13.1",
     "bson-objectid": "^2.0.4",
     "generic-filehandle": "^3.0.0",
     "jwt-decode": "^3.1.2",
@@ -26,11 +28,15 @@
     "@nestjs/core": "^10.1.0",
     "@types/node": "^18.14.2",
     "@types/rimraf": "^3",
+    "glob": "^11.0.0",
     "mobx": "^6.6.1",
     "mobx-state-tree": "^5.1.7",
     "mongoose": "^6.12.0",
+    "react-dom": "^18.2.0",
     "rimraf": "^3.0.2",
-    "typescript": "^5.1.6"
+    "rxjs": "^7.4.0",
+    "tsx": "^4.6.2",
+    "typescript": "^5.5.3"
   },
   "peerDependencies": {
     "@mui/material": "^5.11.14",

package/src/Changes/AddAssemblyAndFeaturesFromFileChange.ts

@@ -1,8 +1,6 @@
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
 /* eslint-disable @typescript-eslint/require-await */
 
 import {
-  AssemblySpecificChange,
   ChangeOptions,
   ClientDataStore,
   LocalGFF3DataStore,
@@ -11,6 +9,8 @@ import {
 } from '@apollo-annotation/common'
 import { GFF3Feature } from '@gmod/gff'
 
+import { FromFileBaseChange } from './FromFileBaseChange'
+
 export interface SerializedAddAssemblyAndFeaturesFromFileChangeBase
   extends SerializedAssemblySpecificChange {
   typeName: 'AddAssemblyAndFeaturesFromFileChange'
@@ -34,7 +34,7 @@ export type SerializedAddAssemblyAndFeaturesFromFileChange =
   | SerializedAddAssemblyAndFeaturesFromFileChangeSingle
   | SerializedAddAssemblyAndFeaturesFromFileChangeMultiple
 
-export class AddAssemblyAndFeaturesFromFileChange extends AssemblySpecificChange {
+export class AddAssemblyAndFeaturesFromFileChange extends FromFileBaseChange {
   typeName = 'AddAssemblyAndFeaturesFromFileChange' as const
   changes: AddAssemblyAndFeaturesFromFileChangeDetails[]
 
@@ -93,7 +93,7 @@ export class AddAssemblyAndFeaturesFromFileChange extends AssemblySpecificChange
         { _id: assembly, name: assemblyName, user, status: -1 },
       ])
       logger.debug?.(
-        `Added new assembly "${assemblyName}", docId "${newAssemblyDoc._id}"`,
+        `Added new assembly "${assemblyName}", docId "${newAssemblyDoc._id.toHexString()}"`,
       )
       logger.debug?.(`File type: "${fileDoc.type}"`)
 
@@ -106,6 +106,9 @@ export class AddAssemblyAndFeaturesFromFileChange extends AssemblySpecificChange
       )
 
       // Loop all features
+      logger.debug?.(
+        `**************** LOOPATAAN KAIKKI FEATURET SEURAAVAKSI File type: "${fileDoc.type}"`,
+      )
       const featureStream = filesService.parseGFF3(
         filesService.getFileStream(fileDoc),
       )

package/src/Changes/AddAssemblyFromFileChange.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 /* eslint-disable @typescript-eslint/require-await */
 import {
-  AssemblySpecificChange,
   ChangeOptions,
   ClientDataStore,
   LocalGFF3DataStore,
@@ -9,6 +8,8 @@ import {
   ServerDataStore,
 } from '@apollo-annotation/common'
 
+import { FromFileBaseChange } from './FromFileBaseChange'
+
 export interface SerializedAddAssemblyFromFileChangeBase
   extends SerializedAssemblySpecificChange {
   typeName: 'AddAssemblyFromFileChange'
@@ -32,7 +33,7 @@ export type SerializedAddAssemblyFromFileChange =
   | SerializedAddAssemblyFromFileChangeSingle
   | SerializedAddAssemblyFromFileChangeMultiple
 
-export class AddAssemblyFromFileChange extends AssemblySpecificChange {
+export class AddAssemblyFromFileChange extends FromFileBaseChange {
   typeName = 'AddAssemblyFromFileChange' as const
   changes: AddAssemblyFromFileChangeDetails[]
 

package/src/Changes/AddFeatureChange.ts

@@ -34,7 +34,7 @@ interface SerializedAddFeatureChangeMultiple
   changes: AddFeatureChangeDetails[]
 }
 
-type SerializedAddFeatureChange =
+export type SerializedAddFeatureChange =
   | SerializedAddFeatureChangeSingle
   | SerializedAddFeatureChangeMultiple
 
@@ -113,7 +113,6 @@ export class AddFeatureChange extends FeatureChange {
         )
         featureCnt++
       } else {
-        addedFeature.gffId = _id // User added manually new feature so then gffId = _id
         // Adding new child feature
         if (parentFeatureId) {
           const topLevelFeature = await featureModel
@@ -158,7 +157,7 @@ export class AddFeatureChange extends FeatureChange {
           // Child features should be sorted for click and drag of gene glyphs to work properly
           parentFeature.children = new Map(
             [...parentFeature.children.entries()].sort(
-              (a, b) => a[1].start - b[1].start,
+              (a, b) => a[1].min - b[1].min,
             ),
           )
           const childIds = this.getChildFeatureIds(addedFeature)

package/src/Changes/AddFeaturesFromFileChange.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/require-await */
 import {
-  AssemblySpecificChange,
   ChangeOptions,
   ClientDataStore,
   LocalGFF3DataStore,
@@ -9,6 +8,8 @@ import {
 } from '@apollo-annotation/common'
 import { GFF3Feature } from '@gmod/gff'
 
+import { FromFileBaseChange } from './FromFileBaseChange'
+
 export interface SerializedAddFeaturesFromFileChangeBase
   extends SerializedAssemblySpecificChange {
   typeName: 'AddFeaturesFromFileChange'
@@ -32,7 +33,7 @@ export type SerializedAddFeaturesFromFileChange =
   | SerializedAddFeaturesFromFileChangeSingle
   | SerializedAddFeaturesFromFileChangeMultiple
 
-export class AddFeaturesFromFileChange extends AssemblySpecificChange {
+export class AddFeaturesFromFileChange extends FromFileBaseChange {
   typeName = 'AddFeaturesFromFileChange' as const
   changes: AddFeaturesFromFileChangeDetails[]
   deleteExistingFeatures = false
@@ -91,13 +92,17 @@ export class AddFeaturesFromFileChange extends AssemblySpecificChange {
       const featureStream = filesService.parseGFF3(
         filesService.getFileStream(fileDoc),
       )
+      let featureCount = 0
       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)
+        featureCount++
+        if (featureCount % 1000 === 0) {
+          logger.debug?.(`Processed ${featureCount} features`)
+        }
       }
     }
     logger.debug?.('New features added into database!')

package/src/Changes/AddRefSeqAliasesChange.ts

@@ -0,0 +1,88 @@
+import {
+  AssemblySpecificChange,
+  Change,
+  ChangeOptions,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  SerializedAssemblySpecificChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { getSession } from '@jbrowse/core/util'
+
+export interface SerializedRefSeqAliases {
+  refName: string
+  aliases: string[]
+}
+
+export interface SerializedRefSeqAliasesChange
+  extends SerializedAssemblySpecificChange {
+  typeName: 'AddRefSeqAliasesChange'
+  refSeqAliases: SerializedRefSeqAliases[]
+}
+
+export class AddRefSeqAliasesChange extends AssemblySpecificChange {
+  typeName = 'AddRefSeqAliasesChange' as const
+  refSeqAliases: SerializedRefSeqAliases[]
+
+  constructor(json: SerializedRefSeqAliasesChange, options?: ChangeOptions) {
+    super(json, options)
+    this.refSeqAliases = json.refSeqAliases
+  }
+
+  executeOnClient(clientDataStore: ClientDataStore) {
+    const { assemblyManager } = getSession(clientDataStore)
+    const assembly = assemblyManager.get(this.assembly)
+    if (!assembly) {
+      throw new Error(`assembly ${this.assembly} not found`)
+    }
+    const sessionAliases = assembly.refNameAliases
+    const sessionLCAliases = assembly.lowerCaseRefNameAliases
+
+    if (!sessionAliases || !sessionLCAliases) {
+      throw new Error('Session refNameAliases not found in assembly')
+    }
+
+    for (const refSeqAlias of this.refSeqAliases) {
+      const { aliases, refName } = refSeqAlias
+      for (const alias of aliases) {
+        sessionAliases[alias] = refName
+        sessionLCAliases[alias.toLowerCase()] = refName
+      }
+    }
+    assembly.setRefNameAliases(sessionAliases, sessionLCAliases)
+    return Promise.resolve()
+  }
+
+  getInverse(): Change {
+    throw new Error('Method not implemented.')
+  }
+
+  toJSON(): SerializedRefSeqAliasesChange {
+    const { assembly, refSeqAliases, typeName } = this
+    return { assembly, typeName, refSeqAliases }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { refSeqModel, session } = backend
+    const { assembly, logger, refSeqAliases } = this
+
+    for (const refSeqAlias of refSeqAliases) {
+      logger.debug?.(
+        `Updating Refname alias for assembly: ${assembly}, refSeqAlias: ${JSON.stringify(refSeqAlias)}`,
+      )
+      const { aliases, refName } = refSeqAlias
+      await refSeqModel
+        .updateOne({ assembly, name: refName }, { $set: { aliases } })
+        .session(session)
+    }
+  }
+
+  executeOnLocalGFF3(_backend: LocalGFF3DataStore): Promise<unknown> {
+    throw new Error('Method not implemented.')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/class-literal-property-style
+  get notification(): string {
+    return 'RefSeq aliases have been added.'
+  }
+}

package/src/Changes/DeleteAssemblyChange.ts

@@ -11,7 +11,7 @@ import {
 } from '@apollo-annotation/common'
 import { getSession } from '@jbrowse/core/util'
 
-interface SerializedDeleteAssemblyChange
+export interface SerializedDeleteAssemblyChange
   extends SerializedAssemblySpecificChange {
   typeName: 'DeleteAssemblyChange'
 }

package/src/Changes/DeleteFeatureChange.ts

@@ -32,7 +32,7 @@ interface SerializedDeleteFeatureChangeMultiple
   changes: DeleteFeatureChangeDetails[]
 }
 
-type SerializedDeleteFeatureChange =
+export type SerializedDeleteFeatureChange =
   | SerializedDeleteFeatureChangeSingle
   | SerializedDeleteFeatureChangeMultiple
 

package/src/Changes/FeatureAttributeChange.ts

@@ -29,7 +29,7 @@ interface SerializedFeatureAttributeChangeMultiple
   changes: FeatureAttributeChangeDetails[]
 }
 
-type SerializedFeatureAttributeChange =
+export type SerializedFeatureAttributeChange =
   | SerializedFeatureAttributeChangeSingle
   | SerializedFeatureAttributeChangeMultiple
 

package/src/Changes/FromFileBaseChange.ts

@@ -0,0 +1,221 @@
+/* eslint-disable @typescript-eslint/restrict-plus-operands */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import {
+  AssemblySpecificChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { FileDocument, RefSeqDocument } from '@apollo-annotation/schemas'
+import { GFF3Feature } from '@gmod/gff'
+
+import { gff3ToAnnotationFeature } from '../GFF3'
+
+export abstract class FromFileBaseChange extends AssemblySpecificChange {
+  async addRefSeqIntoDb(
+    fileDoc: FileDocument,
+    assembly: string,
+    backend: ServerDataStore,
+  ) {
+    const { logger } = this
+    const { filesService, refSeqChunkModel, refSeqModel, user } = backend
+    const { CHUNK_SIZE } = process.env
+    const customChunkSize = CHUNK_SIZE && Number(CHUNK_SIZE)
+    let chunkIndex = 0
+    let refSeqLen = 0
+    let refSeqDoc: RefSeqDocument | undefined
+    let fastaInfoStarted = fileDoc.type !== 'text/x-gff3'
+
+    // Read data from compressed file and parse the content
+    const sequenceStream = filesService.getFileStream(fileDoc)
+    let sequenceBuffer = ''
+    let incompleteLine = ''
+    let lastLineIsIncomplete = true
+    let parsingStarted = false
+    logger.debug?.('starting sequence stream')
+    let lineCount = 0
+    for await (const data of sequenceStream) {
+      const chunk = data.toString()
+      lastLineIsIncomplete = !chunk.endsWith('\n')
+      // chunk is small enough that you can split the whole thing into lines without having to make it into smaller chunks first.
+      const lines = chunk.split(/\r?\n/)
+      if (incompleteLine) {
+        lines[0] = `${incompleteLine}${lines[0]}`
+        incompleteLine = ''
+      }
+      if (lastLineIsIncomplete) {
+        incompleteLine = lines.pop() || ''
+      }
+      for await (const line of lines) {
+        lineCount++
+        if (lineCount % 1_000_000 === 0) {
+          logger.debug?.(`Processed ${lineCount} lines`)
+        }
+        // In case of GFF3 file we start to read sequence after '##FASTA' is found
+        if (!fastaInfoStarted) {
+          if (line.trim() === '##FASTA') {
+            fastaInfoStarted = true
+          }
+          continue
+        }
+        const refSeqInfoLine = /^>\s*(\S+)\s*(.*)/.exec(line)
+        // Add new ref sequence info if we are reference seq info line
+        if (refSeqInfoLine) {
+          parsingStarted = true
+          logger.debug?.(
+            `Reference sequence information line "${refSeqInfoLine[0]}"`,
+          )
+
+          // If there is sequence from previous reference sequence then we need to add it to previous ref seq
+          if (sequenceBuffer !== '') {
+            if (!refSeqDoc) {
+              throw new Error('No refSeq document found')
+            }
+            refSeqLen += sequenceBuffer.length
+            // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+            await refSeqChunkModel.create([
+              {
+                refSeq: refSeqDoc._id,
+                n: chunkIndex,
+                sequence: sequenceBuffer,
+                user,
+                status: -1,
+              },
+            ])
+            sequenceBuffer = ''
+          }
+          await refSeqDoc?.updateOne({ length: refSeqLen })
+          // await refSeqDoc?.updateOne({ length: refSeqLen }, { session })
+          refSeqLen = 0
+          chunkIndex = 0
+
+          const name = refSeqInfoLine[1].trim()
+          const description = refSeqInfoLine[2] ? refSeqInfoLine[2].trim() : ''
+
+          // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+          const [newRefSeqDoc] = await refSeqModel.create([
+            {
+              name,
+              description,
+              assembly,
+              length: 0,
+              ...(customChunkSize ? { chunkSize: customChunkSize } : null),
+              user,
+              status: -1,
+            },
+          ])
+          logger.debug?.(
+            `Added new refSeq "${name}", desc "${description}", docId "${newRefSeqDoc._id}"`,
+          )
+          refSeqDoc = newRefSeqDoc
+        } else if (/\S/.test(line)) {
+          if (!refSeqDoc) {
+            throw new Error('No refSeq document found')
+          }
+          const { _id, chunkSize } = refSeqDoc
+          sequenceBuffer += line.replaceAll(/\s/g, '')
+          // If sequence block > chunk size then save chunk into Mongo
+          while (sequenceBuffer.length >= chunkSize) {
+            const sequence = sequenceBuffer.slice(0, chunkSize)
+            refSeqLen += sequence.length
+            // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+            await refSeqChunkModel.create([
+              { refSeq: _id, n: chunkIndex, sequence, user, status: -1 },
+            ])
+            chunkIndex++
+            // Set remaining sequence
+            sequenceBuffer = sequenceBuffer.slice(chunkSize)
+          }
+        }
+      }
+    }
+    if (!parsingStarted) {
+      throw new Error('No reference sequences found in file')
+    }
+
+    if (sequenceBuffer || lastLineIsIncomplete) {
+      if (!refSeqDoc) {
+        throw new Error('No refSeq document found')
+      }
+      // If the file did not end with line break so the last line is incomplete
+      if (lastLineIsIncomplete) {
+        sequenceBuffer += incompleteLine
+      }
+      refSeqLen += sequenceBuffer.length
+      logger.verbose?.(
+        `*** Add the very last chunk to ref seq ("${refSeqDoc._id}", index ${chunkIndex} and total length for ref seq is ${refSeqLen}): "${sequenceBuffer}"`,
+      )
+      logger.debug?.(
+        `Creating refSeq chunk number ${chunkIndex} of "${refSeqDoc._id}"`,
+      )
+      // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+      await refSeqChunkModel.create([
+        {
+          refSeq: refSeqDoc._id,
+          n: chunkIndex,
+          sequence: sequenceBuffer,
+          user,
+          status: -1,
+        },
+      ])
+      await refSeqDoc.updateOne({ length: refSeqLen })
+    }
+  }
+
+  private refSeqCache = new Map<string, RefSeqDocument>()
+
+  async removeExistingFeatures(backend: ServerDataStore) {
+    const { featureModel, refSeqModel } = backend
+    const { assembly, logger } = this
+    logger.debug?.(`Removing existing features for assembly = ${assembly}`)
+
+    const refSeqs: RefSeqDocument[] = await refSeqModel
+      .find({ assembly })
+      .exec()
+
+    for (const refSeq of refSeqs) {
+      await featureModel.deleteMany({ refSeq: refSeq._id })
+    }
+  }
+
+  async addFeatureIntoDb(gff3Feature: GFF3Feature, backend: ServerDataStore) {
+    const { featureModel, refSeqModel, user } = backend
+    const { assembly, refSeqCache } = this
+
+    const [{ seq_id: refName }] = gff3Feature
+    if (!refName) {
+      throw new Error(
+        `Valid seq_id not found in feature ${JSON.stringify(gff3Feature)}`,
+      )
+    }
+    let refSeqDoc = refSeqCache.get(refName)
+    if (!refSeqDoc) {
+      refSeqDoc =
+        (await refSeqModel.findOne({ assembly, name: refName }).exec()) ??
+        undefined
+      if (refSeqDoc) {
+        refSeqCache.set(refName, refSeqDoc)
+      }
+    }
+    if (!refSeqDoc) {
+      throw new Error(
+        `RefSeq was not found by assembly "${assembly}" and seq_id "${refName}" not found`,
+      )
+    }
+    // Let's add featureId to parent feature
+    const featureIds: string[] = []
+
+    const newFeature = gff3ToAnnotationFeature(
+      gff3Feature,
+      refSeqDoc._id,
+      featureIds,
+    )
+
+    // Add into Mongo
+    // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+    await featureModel.create([
+      { allIds: featureIds, ...newFeature, user, status: -1 },
+    ])
+  }
+}

package/src/Changes/ImportJBrowseConfigChange.ts

@@ -0,0 +1,116 @@
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  Change,
+  ChangeOptions,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+
+interface JBrowseAssembly {
+  sequence: { adapter: { type: string } }
+}
+
+interface JBrowseTrack {
+  type: string
+  trackId: string
+}
+
+interface JBrowsePlugin {
+  name: string
+}
+
+interface JBrowseInternetAccount {
+  type: string
+}
+
+export interface JBrowseConfig {
+  assemblies?: JBrowseAssembly[]
+  tracks?: JBrowseTrack[]
+  plugins?: JBrowsePlugin[]
+  internetAccounts?: JBrowseInternetAccount[]
+  [key: string]: unknown
+}
+
+export interface SerializedImportJBrowseConfigChange {
+  typeName: 'ImportJBrowseConfigChange'
+  oldJBrowseConfig?: JBrowseConfig
+  newJBrowseConfig?: JBrowseConfig
+}
+
+export function filterJBrowseConfig(config: JBrowseConfig): JBrowseConfig {
+  const { assemblies, internetAccounts, plugins, tracks, ...rest } = config
+  const filteredAssemblies = assemblies?.filter(
+    (a) => a.sequence.adapter.type !== 'ApolloSequenceAdapter',
+  )
+  const filteredTracks = tracks?.filter((t) => t.type !== 'ApolloTrack')
+  const filteredPlugins = plugins?.filter((p) => p.name !== 'Apollo')
+  const filteredInternetAccounts = internetAccounts?.filter(
+    (i) => i.type !== 'ApolloInternetAccount',
+  )
+  const filteredConfig = rest as JBrowseConfig
+  if (filteredAssemblies) {
+    filteredConfig.assemblies = filteredAssemblies
+  }
+  if (filteredTracks) {
+    filteredConfig.tracks = filteredTracks
+  }
+  if (filteredPlugins) {
+    filteredConfig.plugins = filteredPlugins
+  }
+  if (filteredInternetAccounts) {
+    filteredConfig.internetAccounts = filteredInternetAccounts
+  }
+  return filteredConfig
+}
+
+export class ImportJBrowseConfigChange extends Change {
+  typeName = 'ImportJBrowseConfigChange' as const
+  oldJBrowseConfig?: JBrowseConfig
+  newJBrowseConfig?: JBrowseConfig
+
+  constructor(
+    json: SerializedImportJBrowseConfigChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.oldJBrowseConfig = json.oldJBrowseConfig
+    this.newJBrowseConfig = json.newJBrowseConfig
+  }
+
+  toJSON(): SerializedImportJBrowseConfigChange {
+    const { newJBrowseConfig, oldJBrowseConfig, typeName } = this
+    return { typeName, oldJBrowseConfig, newJBrowseConfig }
+  }
+
+  async executeOnServer(backend: ServerDataStore) {
+    const { jbrowseConfigModel } = backend
+    const { logger, newJBrowseConfig } = this
+    await jbrowseConfigModel.deleteMany()
+    if (!newJBrowseConfig) {
+      return
+    }
+    const filteredConfig = filterJBrowseConfig(newJBrowseConfig)
+    await jbrowseConfigModel.create(filteredConfig)
+    logger.debug?.('Stored new JBrowse Config')
+  }
+
+  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, newJBrowseConfig, oldJBrowseConfig } = this
+    return new ImportJBrowseConfigChange(
+      {
+        typeName: 'ImportJBrowseConfigChange',
+        oldJBrowseConfig: newJBrowseConfig,
+        newJBrowseConfig: oldJBrowseConfig,
+      },
+      { logger },
+    )
+  }
+}