@apollo-annotation/jbrowse-plugin-apollo 0.1.0

package/src/OntologyManager/OntologyStore/indexeddb-storage.ts

@@ -0,0 +1,180 @@
+import { openLocation } from '@jbrowse/core/util/io'
+import equal from 'fast-deep-equal/es6'
+import { IDBPDatabase, IDBPTransaction, openDB } from 'idb/with-async-ittr'
+
+import { PREFIXED_ID_PATH, getWords } from './fulltext'
+import {
+  OntologyDB,
+  isOntologyDBEdge,
+  isOntologyDBNode,
+} from './indexeddb-schema'
+import { GraphDocument } from './obo-graph-json-schema'
+import OntologyStore from '.'
+import { defaultTextIndexFields } from '..'
+
+/** schema version we are currently on, used for the IndexedDB schema open call */
+const schemaVersion = 2
+
+export type Database = IDBPDatabase<OntologyDB>
+
+/** open the IndexedDB and create the DB schema if necessary */
+export async function openDatabase(this: OntologyStore, dbName: string) {
+  // await deleteDB(dbName) // uncomment this to reload every time during development
+  return openDB<OntologyDB>(dbName, schemaVersion, {
+    upgrade(
+      database: IDBPDatabase<OntologyDB>,
+      oldVersion: number,
+      newVersion: number | null,
+      transaction: IDBPTransaction<
+        OntologyDB,
+        ArrayLike<'nodes' | 'edges' | 'meta'>,
+        'versionchange'
+      >,
+      _event: IDBVersionChangeEvent,
+    ): void {
+      if (oldVersion < schemaVersion) {
+        if (database.objectStoreNames.contains('meta')) {
+          database.deleteObjectStore('meta')
+        }
+        if (database.objectStoreNames.contains('nodes')) {
+          database.deleteObjectStore('nodes')
+        }
+        if (database.objectStoreNames.contains('edges')) {
+          database.deleteObjectStore('edges')
+        }
+      }
+      if (!database.objectStoreNames.contains('meta')) {
+        database.createObjectStore('meta')
+      }
+      if (!database.objectStoreNames.contains('nodes')) {
+        database.createObjectStore('nodes', { keyPath: 'id' })
+        const nodes = transaction.objectStore('nodes')
+        nodes.createIndex('by-label', 'lbl')
+        nodes.createIndex('by-type', 'type')
+        nodes.createIndex('by-synonym', ['meta', 'synonyms', 'val'])
+        nodes.createIndex('full-text-words', 'fullTextWords', {
+          multiEntry: true,
+        })
+      }
+      if (!database.objectStoreNames.contains('edges')) {
+        database.createObjectStore('edges', { autoIncrement: true })
+        const edges = transaction.objectStore('edges')
+        edges.createIndex('by-subject', 'sub')
+        edges.createIndex('by-object', 'obj')
+        edges.createIndex('by-predicate', 'pred')
+      }
+    },
+  })
+}
+
+/** serialize all our words in the DB node so they can be indexed */
+function serializeWords(foundWords: Iterable<[string, string]>): string[] {
+  const allWords = new Set<string>()
+  for (const [, word] of foundWords) {
+    allWords.add(word)
+  }
+  return [...allWords]
+}
+
+/** load a OBO Graph JSON file into a database */
+export async function loadOboGraphJson(this: OntologyStore, db: Database) {
+  const startTime = Date.now()
+
+  // TODO: using file streaming along with an event-based json parser
+  // instead of JSON.parse and .readFile could probably make this faster
+  // and less memory intensive
+  const oboGraph = JSON.parse(
+    await openLocation(this.sourceLocation).readFile('utf8'),
+  ) as GraphDocument
+
+  const parseTime = Date.now()
+
+  const [graph, ...additionalGraphs] = oboGraph.graphs ?? []
+  if (!graph) {
+    return
+  }
+  if (additionalGraphs.length > 0) {
+    throw new Error('multiple graphs not supported')
+  }
+
+  try {
+    const tx = db.transaction(['meta', 'nodes', 'edges'], 'readwrite')
+    await tx.objectStore('meta').clear()
+    await tx.objectStore('nodes').clear()
+    await tx.objectStore('edges').clear()
+
+    // load nodes
+    const nodeStore = tx.objectStore('nodes')
+    const fullTextIndexPaths = getTextIndexFields
+      .call(this)
+      .map((def) => def.jsonPath)
+    for (const node of graph.nodes ?? []) {
+      if (isOntologyDBNode(node)) {
+        await nodeStore.add({
+          ...node,
+          fullTextWords: serializeWords(
+            getWords(node, fullTextIndexPaths, this.prefixes),
+          ),
+        })
+      }
+    }
+
+    // load edges
+    const edgeStore = tx.objectStore('edges')
+    for (const edge of graph.edges ?? []) {
+      if (isOntologyDBEdge(edge)) {
+        await edgeStore.add(edge)
+      }
+    }
+
+    await tx.done
+
+    // record some metadata about this ontology and load operation
+    const tx2 = db.transaction('meta', 'readwrite')
+    await tx2.objectStore('meta').add(
+      {
+        ontologyRecord: {
+          name: this.ontologyName,
+          version: this.ontologyVersion,
+          sourceLocation: this.sourceLocation,
+        },
+        storeOptions: this.options,
+        graphMeta: graph.meta,
+        timestamp: String(new Date()),
+        schemaVersion,
+        timings: {
+          overall: Date.now() - startTime,
+          load: Date.now() - parseTime,
+        },
+      },
+      'meta',
+    )
+
+    await tx2.done
+  } catch (error) {
+    await db.transaction('meta', 'readwrite').objectStore('meta').clear()
+    throw error
+  }
+  return
+}
+
+export function getTextIndexFields(this: OntologyStore) {
+  return [
+    { displayName: 'ID', jsonPath: PREFIXED_ID_PATH },
+    ...(this.options.textIndexing?.indexFields ?? defaultTextIndexFields),
+  ]
+}
+
+export async function isDatabaseCurrent(this: OntologyStore, db: Database) {
+  // since metadata is loaded last, we use it as a signal that all the other data
+  // was loaded
+  const [meta] = await db.transaction('meta').objectStore('meta').getAll()
+  if (!meta) {
+    return false
+  }
+  // check that the index paths and prefixes are the same as our current ones
+  return (
+    equal(this.options.prefixes, meta.storeOptions?.prefixes) &&
+    equal(this.options.textIndexing, meta.storeOptions?.textIndexing)
+  )
+}

package/src/OntologyManager/OntologyStore/obo-graph-json-schema.ts

@@ -0,0 +1,110 @@
+/** TS types for OBO Graph JSON (https://github.com/geneontology/obographs) */
+// first generated with https://transform.tools/json-schema-to-typescript, then edited for conciseness
+export interface GraphDocument {
+  '@context'?: unknown
+  meta?: Meta
+  graphs?: Graph[]
+  [k: string]: unknown
+}
+
+export interface Meta {
+  definition?: MetaDefinitionPropertyValue
+  comments?: string[]
+  subsets?: string[]
+  synonyms?: MetaSynonymPropertyValue[]
+  xrefs?: MetaXrefPropertyValue[]
+  basicPropertyValues?: MetaBasicPropertyValue[]
+  version?: string
+  deprecated?: boolean
+  [k: string]: unknown
+}
+export interface MetaDefinitionPropertyValue {
+  pred?: string
+  val?: string
+  xrefs?: string[]
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface MetaSynonymPropertyValue {
+  synonymType?: string
+  pred?: string
+  val?: string
+  xrefs?: string[]
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface MetaXrefPropertyValue {
+  lbl?: string
+  pred?: string
+  val?: string
+  xrefs?: string[]
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface MetaBasicPropertyValue {
+  pred?: string
+  val?: string
+  xrefs?: string[]
+  meta?: Meta
+  [k: string]: unknown
+}
+
+export interface Graph {
+  id?: string
+  lbl?: string
+  meta?: Meta
+  nodes?: Node[]
+  edges?: Edge[]
+
+  equivalentNodesSets?: AxiomEquivalentNodesSet[]
+  logicalDefinitionAxioms?: LogicalDefinitionAxiom[]
+  domainRangeAxioms?: DomainRangeAxiom[]
+  propertyChainAxioms?: PropertyChainAxiom[]
+  [k: string]: unknown
+}
+export interface Node {
+  id?: string
+  lbl?: string
+  type?: 'CLASS' | 'INDIVIDUAL' | 'PROPERTY'
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface Edge {
+  sub?: string
+  pred?: string
+  obj?: string
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface AxiomEquivalentNodesSet {
+  representativeNodeId?: string
+  nodeIds?: string[]
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface LogicalDefinitionAxiom {
+  definedClassId?: string
+  genusIds?: string[]
+  restrictions?: AxiomExistentialRestrictionExpression[]
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface AxiomExistentialRestrictionExpression {
+  propertyId?: string
+  fillerId?: string
+  [k: string]: unknown
+}
+export interface DomainRangeAxiom {
+  predicateId?: string
+  domainClassIds?: string[]
+  rangeClassIds?: string[]
+  allValuesFromEdges?: Edge[]
+  meta?: Meta
+  [k: string]: unknown
+}
+export interface PropertyChainAxiom {
+  predicateId?: string
+  chainPredicateIds?: string[]
+  meta?: Meta
+  [k: string]: unknown
+}

package/src/OntologyManager/OntologyStore/prefixes.ts

@@ -0,0 +1,35 @@
+/**
+ * This file contains stuff dealing with IRI prefixes used in ontologies.
+ *
+ * ```
+ * const prefixes = new Map(['GO:', 'http://long.url/GO_'])
+ *
+ * applyPrefixes('http://long.url/GO_1234345') // returns 'GO:1234345'
+ *
+ * expandPrefixes('GO:1234345') // returns 'http://long.url/GO_1234345'
+ * ```
+ */
+
+/**
+ * compact the given URI using the given prefixes
+ */
+export function applyPrefixes(uri: string, prefixes: Map<string, string>) {
+  for (const [prefix, uriBase] of prefixes.entries()) {
+    if (uri.startsWith(uriBase)) {
+      return uri.replace(uriBase, prefix)
+    }
+  }
+  return uri
+}
+
+/**
+ * expand the given compacted URI using given prefixes
+ */
+export function expandPrefixes(uri: string, prefixes: Map<string, string>) {
+  for (const [prefix, uriBase] of prefixes.entries()) {
+    if (uri.startsWith(prefix)) {
+      return uri.replace(prefix, uriBase)
+    }
+  }
+  return uri
+}

package/src/OntologyManager/index.ts

@@ -0,0 +1,173 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+import {
+  BlobLocation,
+  LocalPathLocation,
+  UriLocation,
+} from '@jbrowse/core/util/types/mst'
+import { autorun } from 'mobx'
+import { Instance, addDisposer, getSnapshot, types } from 'mobx-state-tree'
+
+import OntologyStore, { OntologyStoreOptions } from './OntologyStore'
+import { OntologyDBNode } from './OntologyStore/indexeddb-schema'
+import { applyPrefixes, expandPrefixes } from './OntologyStore/prefixes'
+
+export { isDeprecated } from './OntologyStore/indexeddb-schema'
+
+export const OntologyRecordType = types
+  .model('OntologyRecord', {
+    name: types.string,
+    version: 'unversioned',
+    source: types.union(LocalPathLocation, UriLocation, BlobLocation),
+    options: types.frozen<OntologyStoreOptions>(),
+  })
+  .volatile((_self) => ({
+    dataStore: undefined as undefined | OntologyStore,
+  }))
+  .actions((self) => ({
+    /** does nothing, just used to access the model to force its lifecycle hooks to run */
+    ping() {
+      return
+    },
+    initDataStore() {
+      self.dataStore = new OntologyStore(
+        self.name,
+        self.version,
+        getSnapshot(self.source),
+        self.options,
+      )
+    },
+    afterCreate() {
+      addDisposer(
+        self,
+        autorun(() => {
+          this.initDataStore()
+        }),
+      )
+    },
+  }))
+
+export const OntologyManagerType = types
+  .model('OntologyManager', {
+    // create, update, and delete ontologies
+    ontologies: types.array(OntologyRecordType),
+    prefixes: types.optional(types.map(types.string), {
+      'GO:': 'http://purl.obolibrary.org/obo/GO_',
+      'SO:': 'http://purl.obolibrary.org/obo/SO_',
+    }),
+  })
+  .views((self) => ({
+    /**
+     * gets the OntologyRecord for the ontology we should be
+     * using for feature types (e.g. SO or maybe biotypes)
+     **/
+    get featureTypeOntology() {
+      // TODO: change this to read some configuration for which feature type ontology
+      // we should be using. currently hardcoded to use SO.
+      return this.findOntology('Sequence Ontology')
+    },
+
+    findOntology(name: string, version?: string) {
+      return self.ontologies.find((record) => {
+        return (
+          record.name === name &&
+          (version === undefined || record.version === version)
+        )
+      })
+    },
+    openOntology(name: string, version?: string) {
+      return this.findOntology(name, version)?.dataStore
+    },
+    /**
+     * compact the given URI using the currently configured
+     * prefixes
+     */
+    applyPrefixes(uri: string) {
+      return applyPrefixes(uri, self.prefixes)
+    },
+    /**
+     * expand the given compacted URI using the currently
+     * configured prefixes
+     */
+    expandPrefixes(uri: string) {
+      return expandPrefixes(uri, self.prefixes)
+    },
+  }))
+  .actions((self) => ({
+    addOntology(
+      name: string,
+      version: string,
+      source: Instance<typeof LocalPathLocation> | Instance<typeof UriLocation>,
+      options?: OntologyStoreOptions,
+    ) {
+      const newlen = self.ontologies.push({
+        name,
+        version,
+        source,
+        options: { prefixes: new Map(self.prefixes.entries()), ...options },
+      })
+      // access it immediately to fire its lifecycle hooks
+      // (see https://github.com/mobxjs/mobx-state-tree/issues/1665)
+      self.ontologies[newlen - 1].ping()
+    },
+  }))
+
+export default OntologyManagerType
+
+export interface TextIndexFieldDefinition {
+  /** name to display in the UI for text taken from this field or fields */
+  displayName: string
+  /** JSONPath of the field(s) */
+  jsonPath: string
+}
+export const defaultTextIndexFields: TextIndexFieldDefinition[] = [
+  { displayName: 'Label', jsonPath: '$.lbl' },
+  { displayName: 'Synonym', jsonPath: '$.meta.synonyms[*].val' },
+  { displayName: 'Definition', jsonPath: '$.meta.definition.val' },
+]
+
+export const OntologyRecordConfiguration = ConfigurationSchema(
+  'OntologyRecord',
+  {
+    name: {
+      type: 'string',
+      description: 'the full name of the ontology, e.g. "Gene Ontology"',
+      defaultValue: 'My Ontology',
+    },
+    version: {
+      type: 'string',
+      description: "the ontology's version string",
+      defaultValue: 'unversioned',
+    },
+    source: {
+      type: 'fileLocation',
+      description: "the download location for the ontology's source file",
+      defaultValue: {
+        locationType: 'UriLocation',
+        uri: 'http://example.com/myontology.json',
+      },
+    },
+    textIndexFields: {
+      type: 'frozen',
+      description:
+        'JSON paths for text fields that will be indexed for text searching',
+      defaultValue: defaultTextIndexFields,
+    },
+  },
+)
+
+export type OntologyManager = Instance<typeof OntologyManagerType>
+export type OntologyRecord = Instance<typeof OntologyRecordType>
+
+export type OntologyTerm = OntologyDBNode
+
+export type OntologyClass = OntologyTerm & { type: 'CLASS' }
+export function isOntologyClass(term: OntologyTerm): term is OntologyClass {
+  return term.type === 'CLASS'
+}
+
+export type OntologyProperty = OntologyTerm & { type: 'PROPERTY' }
+export function isOntologyProperty(
+  term: OntologyTerm,
+): term is OntologyProperty {
+  return term.type === 'PROPERTY'
+}

package/src/SixFrameFeatureDisplay/components/TrackLines.tsx

@@ -0,0 +1,19 @@
+import { observer } from 'mobx-react'
+import React from 'react'
+
+import { SixFrameFeatureDisplay } from '../stateModel'
+
+export const TrackLines = observer(function TrackLines({
+  model,
+}: {
+  model: SixFrameFeatureDisplay
+}) {
+  const { height } = model
+  return (
+    <div
+      style={{ position: 'absolute', left: 0, top: height / 2, width: '100%' }}
+    >
+      <hr style={{ margin: 0, top: 0, color: 'black' }} />
+    </div>
+  )
+})

package/src/SixFrameFeatureDisplay/components/index.ts

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

package/src/SixFrameFeatureDisplay/configSchema.ts

@@ -0,0 +1,21 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration'
+import PluginManager from '@jbrowse/core/PluginManager'
+import type LinearGenomeViewPlugin from '@jbrowse/plugin-linear-genome-view'
+
+import { configSchema as apolloRendererConfigSchema } from '../ApolloSixFrameRenderer'
+
+export function configSchemaFactory(pluginManager: PluginManager) {
+  const LGVPlugin = pluginManager.getPlugin(
+    'LinearGenomeViewPlugin',
+  ) as LinearGenomeViewPlugin
+  const { baseLinearDisplayConfigSchema } = LGVPlugin.exports
+
+  return ConfigurationSchema(
+    'SixFrameFeatureDisplay',
+    {
+      renderer: apolloRendererConfigSchema,
+      height: { type: 'number', defaultValue: 120 },
+    },
+    { baseConfiguration: baseLinearDisplayConfigSchema, explicitlyTyped: true },
+  )
+}

package/src/SixFrameFeatureDisplay/index.ts

@@ -0,0 +1,2 @@
+export { configSchemaFactory } from './configSchema'
+export { stateModelFactory } from './stateModel'