@apollo-annotation/jbrowse-plugin-apollo 0.1.0

package/src/session/ClientDataStore.ts

@@ -0,0 +1,282 @@
+import { getConf, readConfObject } from '@jbrowse/core/configuration'
+import { ConfigurationModel } from '@jbrowse/core/configuration/types'
+import { Region, getSession, isElectron } from '@jbrowse/core/util'
+import { LocalPathLocation, UriLocation } from '@jbrowse/core/util/types/mst'
+import { ClientDataStore as ClientDataStoreType } from 'apollo-common'
+import {
+  AnnotationFeature,
+  AnnotationFeatureSnapshot,
+  ApolloAssembly,
+  ApolloRefSeq,
+  CheckResult,
+  CheckResultSnapshot,
+} from 'apollo-mst'
+import {
+  Instance,
+  SnapshotOut,
+  flow,
+  getParentOfType,
+  getRoot,
+  resolveIdentifier,
+  types,
+} from 'mobx-state-tree'
+
+import {
+  ApolloInternetAccount,
+  CollaborationServerDriver,
+  DesktopFileDriver,
+  InMemoryFileDriver,
+} from '../BackendDrivers'
+import { ChangeManager } from '../ChangeManager'
+import ApolloPluginConfigurationSchema from '../config'
+import {
+  OntologyManagerType,
+  OntologyRecordConfiguration,
+  TextIndexFieldDefinition,
+} from '../OntologyManager'
+import { ApolloRootModel } from '../types'
+
+export function clientDataStoreFactory(
+  AnnotationFeatureExtended: typeof AnnotationFeature,
+) {
+  const clientStoreType = types
+    .model('ClientDataStore', {
+      typeName: types.optional(types.literal('Client'), 'Client'),
+      assemblies: types.map(ApolloAssembly),
+      checkResults: types.map(CheckResult),
+    })
+    .views((self) => ({
+      get internetAccounts() {
+        return getRoot<ApolloRootModel>(self).internetAccounts
+      },
+
+      get pluginConfiguration() {
+        return getRoot<ApolloRootModel>(self).jbrowse.configuration
+          .ApolloPlugin as Instance<typeof ApolloPluginConfigurationSchema>
+      },
+      getFeature(featureId: string) {
+        return resolveIdentifier(
+          AnnotationFeatureExtended,
+          self.assemblies,
+          featureId,
+        )
+      },
+    }))
+    .actions((self) => ({
+      addAssembly(assemblyId: string) {
+        return self.assemblies.put({ _id: assemblyId, refSeqs: {} })
+      },
+      addFeature(assemblyId: string, feature: AnnotationFeatureSnapshot) {
+        const assembly = self.assemblies.get(assemblyId)
+        if (!assembly) {
+          throw new Error(
+            `Could not find assembly "${assemblyId}" to add feature "${feature._id}"`,
+          )
+        }
+        const ref = assembly.refSeqs.get(feature.refSeq)
+        if (!ref) {
+          throw new Error(
+            `Could not find refSeq "${feature.refSeq}" to add feature "${feature._id}"`,
+          )
+        }
+        ref.features.put(feature)
+      },
+      deleteFeature(featureId: string) {
+        const feature = self.getFeature(featureId)
+        if (!feature) {
+          throw new Error(`Could not find feature "${featureId}" to delete`)
+        }
+        const { _id, parent } = feature
+        if (parent) {
+          parent.deleteChild(featureId)
+        } else {
+          const refSeq = getParentOfType(feature, ApolloRefSeq)
+          refSeq.deleteFeature(_id)
+        }
+      },
+      deleteAssembly(assemblyId: string) {
+        self.assemblies.delete(assemblyId)
+      },
+      addCheckResult(checkResult: CheckResultSnapshot) {
+        self.checkResults.put(checkResult)
+      },
+      addCheckResults(checkResults: CheckResultSnapshot[]) {
+        for (const checkResult of checkResults) {
+          if (!self.checkResults.has(checkResult._id)) {
+            self.checkResults.put(checkResult)
+          }
+        }
+      },
+      deleteCheckResult(checkResultId: string) {
+        self.checkResults.delete(checkResultId)
+      },
+    }))
+    .volatile((self) => ({
+      changeManager: new ChangeManager(self as unknown as ClientDataStoreType),
+      collaborationServerDriver: new CollaborationServerDriver(
+        self as unknown as ClientDataStoreType,
+      ),
+      inMemoryFileDriver: new InMemoryFileDriver(
+        self as unknown as ClientDataStoreType,
+      ),
+      desktopFileDriver: isElectron
+        ? new DesktopFileDriver(self as unknown as ClientDataStoreType)
+        : undefined,
+      ontologyManager: OntologyManagerType.create(),
+    }))
+    .actions((self) => ({
+      afterCreate() {
+        // Merge in the ontologies from our plugin configuration.
+        // Ontologies of a given name that are already in the session
+        // take precedence over the ontologies in the configuration.
+        const { ontologyManager, pluginConfiguration } = self
+        const configuredOntologies =
+          pluginConfiguration.ontologies as ConfigurationModel<
+            typeof OntologyRecordConfiguration
+          >[]
+
+        for (const ont of configuredOntologies || []) {
+          const [name, version, source, indexFields] = [
+            readConfObject(ont, 'name') as string,
+            readConfObject(ont, 'version') as string,
+            readConfObject(ont, 'source') as
+              | Instance<typeof LocalPathLocation>
+              | Instance<typeof UriLocation>,
+            readConfObject(
+              ont,
+              'textIndexFields',
+            ) as TextIndexFieldDefinition[],
+          ]
+          if (!ontologyManager.findOntology(name)) {
+            ontologyManager.addOntology(name, version, source, {
+              textIndexing: { indexFields },
+            })
+          }
+        }
+
+        // TODO: add in any configured ontology prefixes that we don't already
+        // have in the session (or hardcoded in the model)
+      },
+    }))
+    .views((self) => ({
+      getBackendDriver(assemblyId: string) {
+        if (!assemblyId) {
+          return self.collaborationServerDriver
+        }
+        const session = getSession(self)
+        const { assemblyManager } = session
+        const assembly = assemblyManager.get(assemblyId)
+        if (!assembly) {
+          return self.collaborationServerDriver
+        }
+        const { file, internetAccountConfigId } = getConf(assembly, [
+          'sequence',
+          'metadata',
+        ]) as { internetAccountConfigId?: string; file: string }
+        if (isElectron && file) {
+          return self.desktopFileDriver
+        }
+        if (internetAccountConfigId) {
+          return self.collaborationServerDriver
+        }
+        return self.inMemoryFileDriver
+      },
+      getInternetAccount(assemblyName?: string, internetAccountId?: string) {
+        if (!(assemblyName ?? internetAccountId)) {
+          throw new Error(
+            'Must provide either assemblyName or internetAccountId',
+          )
+        }
+        let configId = internetAccountId
+        if (assemblyName && !configId) {
+          const { assemblyManager } = getSession(self)
+          const assembly = assemblyManager.get(assemblyName)
+          if (!assembly) {
+            throw new Error(`No assembly found with name ${assemblyName}`)
+          }
+          ;({ internetAccountConfigId: configId } = getConf(assembly, [
+            'sequence',
+            'metadata',
+          ]) as { internetAccountConfigId: string })
+        }
+        const { internetAccounts } = self
+        const internetAccount = internetAccounts.find(
+          (ia) => ia.internetAccountId === configId,
+        ) as ApolloInternetAccount | undefined
+        if (!internetAccount) {
+          throw new Error(
+            `No InternetAccount found with config id ${internetAccountId}`,
+          )
+        }
+        return internetAccount
+      },
+    }))
+    .actions((self) => ({
+      loadFeatures: flow(function* loadFeatures(regions: Region[]) {
+        for (const region of regions) {
+          const backendDriver = self.getBackendDriver(region.assemblyName)
+          if (!backendDriver) {
+            return
+          }
+          const [features, checkResults] = (yield backendDriver.getFeatures(
+            region,
+          )) as [AnnotationFeatureSnapshot[], CheckResultSnapshot[]]
+          if (features.length === 0) {
+            continue
+          }
+          const { assemblyName, refName } = region
+          let assembly = self.assemblies.get(assemblyName)
+          if (!assembly) {
+            assembly = self.assemblies.put({ _id: assemblyName, refSeqs: {} })
+          }
+          const [firstFeature] = features
+          let ref = assembly.refSeqs.get(firstFeature.refSeq)
+          if (!ref) {
+            ref = assembly.refSeqs.put({
+              _id: firstFeature.refSeq,
+              name: refName,
+              features: {},
+            })
+          }
+          for (const feature of features) {
+            if (!ref.features.has(feature._id)) {
+              ref.features.put(feature)
+            }
+          }
+          self.addCheckResults(checkResults)
+        }
+      }),
+      loadRefSeq: flow(function* loadRefSeq(regions: Region[]) {
+        for (const region of regions) {
+          const backendDriver = self.getBackendDriver(region.assemblyName)
+          if (!backendDriver) {
+            return
+          }
+          const { refSeq, seq } = yield backendDriver.getSequence(region)
+          const { assemblyName, end, refName, start } = region
+          let assembly = self.assemblies.get(assemblyName)
+          if (!assembly) {
+            assembly = self.assemblies.put({ _id: assemblyName, refSeqs: {} })
+          }
+          let ref = assembly.refSeqs.get(refSeq)
+          if (!ref) {
+            ref = assembly.refSeqs.put({
+              _id: refSeq,
+              name: refName,
+              sequence: [],
+            })
+          }
+          ref.addSequence({ start, stop: end, sequence: seq })
+        }
+      }),
+    }))
+
+  // assembly and feature data isn't actually reloaded on reload unless we delete it from the snap
+  return types.snapshotProcessor(clientStoreType, {
+    postProcessor(snap: SnapshotOut<typeof clientStoreType>) {
+      snap.assemblies = {}
+      snap.checkResults = {}
+      return snap
+    },
+  })
+}

package/src/session/index.ts

@@ -0,0 +1 @@
+export * from './session'

package/src/session/session.ts

@@ -0,0 +1,373 @@
+import { AssemblyModel } from '@jbrowse/core/assemblyManager/assembly'
+import { getConf } from '@jbrowse/core/configuration'
+import { BaseInternetAccountModel } from '@jbrowse/core/pluggableElementTypes'
+import PluginManager from '@jbrowse/core/PluginManager'
+import {
+  AbstractSessionModel,
+  SessionWithConfigEditing,
+} from '@jbrowse/core/util'
+import { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
+import { ClientDataStore as ClientDataStoreType } from 'apollo-common'
+import { AnnotationFeature, AnnotationFeatureI } from 'apollo-mst'
+import { UserLocation } from 'apollo-shared'
+import { autorun, observable } from 'mobx'
+import { Instance, flow, getRoot, types } from 'mobx-state-tree'
+
+import { ApolloInternetAccountModel } from '../ApolloInternetAccount/model'
+import { ApolloJobModel } from '../ApolloJobModel'
+import { ChangeManager } from '../ChangeManager'
+import { ApolloRootModel } from '../types'
+import { createFetchErrorMessage } from '../util'
+import { clientDataStoreFactory } from './ClientDataStore'
+
+export interface ApolloSession extends AbstractSessionModel {
+  apolloDataStore: ClientDataStoreType & { changeManager: ChangeManager }
+  apolloSelectedFeature?: AnnotationFeatureI
+  apolloSetSelectedFeature(feature?: AnnotationFeatureI): void
+}
+
+interface ApolloAssemblyResponse {
+  _id: string
+  name: string
+  displayName?: string
+  description?: string
+  aliases?: string[]
+}
+
+export interface ApolloRefSeqResponse {
+  _id: string
+  name: string
+  description?: string
+  length: string
+  assembly: string
+}
+
+export interface Collaborator {
+  name: string
+  id: string
+  locations: UserLocation[]
+}
+
+export function extendSession(
+  pluginManager: PluginManager,
+  sessionModel: ReturnType<typeof types.model>,
+) {
+  const aborter = new AbortController()
+  const { signal } = aborter
+  const AnnotationFeatureExtended = pluginManager.evaluateExtensionPoint(
+    'Apollo-extendAnnotationFeature',
+    AnnotationFeature,
+  ) as typeof AnnotationFeature
+  const ClientDataStore = clientDataStoreFactory(AnnotationFeatureExtended)
+  return sessionModel
+    .props({
+      apolloDataStore: types.optional(ClientDataStore, { typeName: 'Client' }),
+      apolloSelectedFeature: types.safeReference(AnnotationFeatureExtended),
+      jobsManager: types.optional(ApolloJobModel, {}),
+    })
+    .extend(() => {
+      const collabs = observable.array<Collaborator>([])
+
+      return {
+        views: {
+          get collaborators() {
+            return collabs
+          },
+        },
+        actions: {
+          addOrUpdateCollaborator(collaborator: Collaborator) {
+            const existingCollaborator = collabs.find(
+              (obj: Collaborator) => obj.id === collaborator.id,
+            )
+            if (existingCollaborator) {
+              existingCollaborator.locations = collaborator.locations
+            } else {
+              collabs.push(collaborator)
+            }
+          },
+        },
+      }
+    })
+    .actions((self) => ({
+      apolloSetSelectedFeature(feature?: AnnotationFeatureI) {
+        self.apolloSelectedFeature = feature
+      },
+      addApolloTrackConfig(assembly: AssemblyModel, baseURL?: string) {
+        const trackId = `apollo_track_${assembly.name}`
+        const hasTrack = (self as unknown as AbstractSessionModel).tracks.some(
+          (track) => track.trackId === trackId,
+        )
+        if (!hasTrack) {
+          ;(self as unknown as SessionWithConfigEditing).addTrackConf({
+            type: 'ApolloTrack',
+            trackId,
+            name: `Annotations (${
+              // @ts-expect-error getConf types don't quite work here for some reason
+              getConf(assembly, 'displayName') || assembly.name
+            })`,
+            assemblyNames: [assembly.name],
+            textSearching: {
+              textSearchAdapter: {
+                type: 'ApolloTextSearchAdapter',
+                trackId,
+                assemblyNames: [assembly.name],
+                textSearchAdapterId: `apollo_search_${assembly.name}`,
+                ...(baseURL
+                  ? { baseURL: { uri: baseURL, locationType: 'UriLocation' } }
+                  : {}),
+              },
+            },
+            displays: [
+              {
+                type: 'LinearApolloDisplay',
+                displayId: `${trackId}-LinearApolloDisplay`,
+              },
+              {
+                type: 'SixFrameFeatureDisplay',
+                displayId: `${trackId}-SixFrameFeatureDisplay`,
+              },
+            ],
+          })
+        }
+      },
+      broadcastLocations() {
+        const { internetAccounts } = getRoot<ApolloRootModel>(self)
+        const locations: {
+          assemblyName: string
+          refName: string
+          start: number
+          end: number
+        }[] = []
+        for (const view of (self as unknown as AbstractSessionModel).views) {
+          if (view.type !== 'LinearGenomeView') {
+            return
+          }
+          const lgv = view as unknown as LinearGenomeViewModel
+          if (lgv.initialized) {
+            const { dynamicBlocks } = lgv
+            // eslint-disable-next-line unicorn/no-array-for-each
+            dynamicBlocks.forEach((block) => {
+              if (block.regionNumber !== undefined) {
+                const { assemblyName, end, refName, start } = block
+                locations.push({ assemblyName, refName, start, end })
+              }
+            })
+          }
+        }
+        if (locations.length === 0) {
+          for (const internetAccount of internetAccounts as (
+            | BaseInternetAccountModel
+            | ApolloInternetAccountModel
+          )[]) {
+            if ('baseURL' in internetAccount) {
+              internetAccount.postUserLocation([])
+            }
+          }
+          return
+        }
+
+        const allLocations: UserLocation[] = []
+        for (const internetAccount of internetAccounts as (
+          | BaseInternetAccountModel
+          | ApolloInternetAccountModel
+        )[]) {
+          if ('baseURL' in internetAccount) {
+            for (const location of locations) {
+              const tmpLoc: UserLocation = {
+                assemblyId: location.assemblyName,
+                refSeq: location.refName,
+                start: location.start,
+                end: location.end,
+              }
+              allLocations.push(tmpLoc)
+            }
+            internetAccount.postUserLocation(allLocations)
+          }
+        }
+      },
+    }))
+    .actions((self) => ({
+      afterCreate: flow(function* afterCreate() {
+        const { internetAccounts } = getRoot<ApolloRootModel>(self)
+        autorun(
+          () => {
+            // broadcastLocations() // **** This is not working and therefore we need to duplicate broadcastLocations() -method code here because autorun() does not observe changes otherwise
+            const locations: {
+              assemblyName: string
+              refName: string
+              start: number
+              end: number
+            }[] = []
+            for (const view of (self as unknown as AbstractSessionModel)
+              .views) {
+              if (view.type !== 'LinearGenomeView') {
+                return
+              }
+              const lgv = view as unknown as LinearGenomeViewModel
+              if (lgv.initialized) {
+                const { dynamicBlocks } = lgv as LinearGenomeViewModel
+                // eslint-disable-next-line unicorn/no-array-for-each
+                dynamicBlocks.forEach((block) => {
+                  if (block.regionNumber !== undefined) {
+                    const { assemblyName, end, refName, start } = block
+                    locations.push({ assemblyName, refName, start, end })
+                  }
+                })
+              }
+            }
+            if (locations.length === 0) {
+              for (const internetAccount of internetAccounts as (
+                | BaseInternetAccountModel
+                | ApolloInternetAccountModel
+              )[]) {
+                if ('baseURL' in internetAccount) {
+                  internetAccount.postUserLocation([])
+                }
+              }
+              return
+            }
+
+            const allLocations: UserLocation[] = []
+            for (const internetAccount of internetAccounts as (
+              | BaseInternetAccountModel
+              | ApolloInternetAccountModel
+            )[]) {
+              if ('baseURL' in internetAccount) {
+                for (const location of locations) {
+                  const tmpLoc: UserLocation = {
+                    assemblyId: location.assemblyName,
+                    refSeq: location.refName,
+                    start: location.start,
+                    end: location.end,
+                  }
+                  allLocations.push(tmpLoc)
+                }
+                internetAccount.postUserLocation(allLocations)
+              }
+            }
+          },
+          { name: 'ApolloSession' },
+        )
+        // END AUTORUN
+
+        // fetch and initialize assemblies for each of our Apollo internet accounts
+        for (const internetAccount of internetAccounts as ApolloInternetAccountModel[]) {
+          if (internetAccount.type !== 'ApolloInternetAccount') {
+            continue
+          }
+
+          const { baseURL, configuration } = internetAccount
+          const uri = new URL('assemblies', baseURL).href
+          const fetch = internetAccount.getFetcher({
+            locationType: 'UriLocation',
+            uri,
+          })
+          let response: Response
+          try {
+            response = yield fetch(uri, { signal })
+          } catch (error) {
+            console.error(error)
+            // setError(e instanceof Error ? e : new Error(String(e)))
+            continue
+          }
+          if (!response.ok) {
+            const errorMessage = yield createFetchErrorMessage(
+              response,
+              'Failed to fetch assemblies',
+            )
+            console.error(errorMessage)
+            continue
+          }
+          let fetchedAssemblies
+          try {
+            fetchedAssemblies =
+              (yield response.json()) as ApolloAssemblyResponse[]
+          } catch (error) {
+            console.error(error)
+            continue
+          }
+          for (const assembly of fetchedAssemblies) {
+            const { addAssembly, addSessionAssembly, assemblyManager } =
+              self as unknown as AbstractSessionModel & {
+                // eslint-disable-next-line @typescript-eslint/ban-types
+                addSessionAssembly: Function
+              }
+            const selectedAssembly = assemblyManager.get(assembly.name)
+            if (selectedAssembly) {
+              // @ts-expect-error MST type coercion problem?
+              self.addApolloTrackConfig(selectedAssembly, baseURL)
+              continue
+            }
+            const url = new URL('refSeqs', baseURL)
+            const searchParams = new URLSearchParams({ assembly: assembly._id })
+            url.search = searchParams.toString()
+            const uri2 = url.toString()
+            const fetch2 = internetAccount.getFetcher({
+              locationType: 'UriLocation',
+              uri: uri2,
+            })
+            const response2 = (yield fetch2(uri2, {
+              signal,
+            })) as unknown as Response
+            if (!response2.ok) {
+              let errorMessage
+              try {
+                errorMessage = yield response2.text()
+              } catch {
+                errorMessage = ''
+              }
+              throw new Error(
+                `Failed to fetch fasta info — ${response2.status} (${
+                  response2.statusText
+                })${errorMessage ? ` (${errorMessage})` : ''}`,
+              )
+            }
+            const f = (yield response2.json()) as ApolloRefSeqResponse[]
+            const ids: Record<string, string> = {}
+            const refNameAliasesFeatures = f.map((contig) => {
+              ids[contig.name] = contig._id
+              return {
+                refName: contig.name,
+                aliases: [contig._id],
+                uniqueId: `alias-${contig._id}`,
+              }
+            })
+            const assemblyConfig = {
+              name: assembly._id,
+              aliases: [assembly.name, ...(assembly.aliases ?? [])],
+              displayName: assembly.displayName ?? assembly.name,
+              sequence: {
+                trackId: `sequenceConfigId-${assembly.name}`,
+                type: 'ReferenceSequenceTrack',
+                adapter: {
+                  type: 'ApolloSequenceAdapter',
+                  assemblyId: assembly._id,
+                  baseURL: { uri: baseURL, locationType: 'UriLocation' },
+                },
+                metadata: {
+                  apollo: true,
+                  internetAccountConfigId: configuration.internetAccountId,
+                  ids,
+                },
+              },
+              refNameAliases: {
+                adapter: {
+                  type: 'FromConfigAdapter',
+                  features: refNameAliasesFeatures,
+                },
+              },
+            }
+            ;(addSessionAssembly || addAssembly)(assemblyConfig)
+            const a = yield assemblyManager.waitForAssembly(assemblyConfig.name)
+            self.addApolloTrackConfig(a, baseURL)
+          }
+        }
+      }),
+      beforeDestroy() {
+        aborter.abort()
+      },
+    }))
+}
+
+export type ApolloSessionStateModel = ReturnType<typeof extendSession>
+export type ApolloSessionModel = Instance<ApolloSessionStateModel>

package/src/types.ts

@@ -0,0 +1,10 @@
+import { BaseInternetAccountModel } from '@jbrowse/core/pluggableElementTypes'
+import { AppRootModel } from '@jbrowse/core/util'
+
+import { ApolloInternetAccountModel } from './ApolloInternetAccount/model'
+import { ApolloSessionModel } from './session'
+
+export interface ApolloRootModel extends Omit<AppRootModel, 'session'> {
+  session: ApolloSessionModel
+  internetAccounts: (BaseInternetAccountModel | ApolloInternetAccountModel)[]
+}

package/src/util/index.ts

@@ -0,0 +1,31 @@
+import { getParent } from 'mobx-state-tree'
+
+import { ApolloInternetAccountModel } from '../ApolloInternetAccount/model'
+import { ApolloSessionModel } from '../session'
+import { ApolloRootModel } from '../types'
+
+export async function createFetchErrorMessage(
+  response: Response,
+  additionalText?: string,
+): Promise<string> {
+  let errorMessage
+  try {
+    errorMessage = await response.text()
+  } catch {
+    errorMessage = ''
+  }
+  const responseMessage = `${response.status} ${response.statusText}${
+    errorMessage ? ` (${errorMessage})` : ''
+  }`
+  return `${additionalText ? `${additionalText} — ` : ''}${responseMessage}`
+}
+
+/** given a session, get our ApolloInternetAccount */
+export function getApolloInternetAccount(session: ApolloSessionModel) {
+  const { internetAccounts } = getParent<ApolloRootModel>(session)
+  return internetAccounts.find((ia) => ia.type === 'ApolloInternetAccount') as
+    | ApolloInternetAccountModel
+    | undefined
+}
+
+export * from './loadAssemblyIntoClient'