@jbrowse/plugin-alignments 2.1.7 → 2.2.1

package/src/BamAdapter/configSchema.ts

@@ -1,37 +1,65 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration'
 import { types } from 'mobx-state-tree'
 
-export default types.late(() =>
-  ConfigurationSchema(
-    'BamAdapter',
-    {
-      bamLocation: {
-        type: 'fileLocation',
-        defaultValue: { uri: '/path/to/my.bam', locationType: 'UriLocation' },
+/**
+ * #config BamAdapter
+ * used to configure BAM adapter
+ */
+function x() {} // eslint-disable-line @typescript-eslint/no-unused-vars
+
+const configSchema = ConfigurationSchema(
+  'BamAdapter',
+  {
+    /**
+     * #slot
+     */
+    bamLocation: {
+      type: 'fileLocation',
+      defaultValue: { uri: '/path/to/my.bam', locationType: 'UriLocation' },
+    },
+
+    index: ConfigurationSchema('BamIndex', {
+      /**
+       * #slot index.indexType
+       */
+      indexType: {
+        model: types.enumeration('IndexType', ['BAI', 'CSI']),
+        type: 'stringEnum',
+        defaultValue: 'BAI',
       },
-      index: ConfigurationSchema('BamIndex', {
-        indexType: {
-          model: types.enumeration('IndexType', ['BAI', 'CSI']),
-          type: 'stringEnum',
-          defaultValue: 'BAI',
-        },
-        location: {
-          type: 'fileLocation',
-          defaultValue: {
-            uri: '/path/to/my.bam.bai',
-            locationType: 'UriLocation',
-          },
+      /**
+       * #slot index.location
+       */
+      location: {
+        type: 'fileLocation',
+        defaultValue: {
+          uri: '/path/to/my.bam.bai',
+          locationType: 'UriLocation',
         },
-      }),
-      fetchSizeLimit: {
-        type: 'number',
-        defaultValue: 5_000_000,
-      },
-      sequenceAdapter: {
-        type: 'frozen',
-        defaultValue: null,
       },
+    }),
+    /**
+     * #slot
+     */
+    fetchSizeLimit: {
+      type: 'number',
+      description:
+        'size to fetch in bytes over which to display a warning to the user that too much data will be fetched',
+      defaultValue: 5_000_000,
     },
-    { explicitlyTyped: true },
-  ),
+    /**
+     * #slot
+     * generally refers to the reference genome assembly's sequence adapter
+     * currently needs to be manually added
+     */
+    sequenceAdapter: {
+      type: 'frozen',
+      description:
+        'sequence data adapter, used to calculate SNPs when BAM reads lacking MD tags',
+      defaultValue: null,
+    },
+  },
+  { explicitlyTyped: true },
 )
+
+export default configSchema

package/src/BamAdapter/index.ts

@@ -3,12 +3,11 @@ import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType'
 import configSchema from './configSchema'
 
 export default (pluginManager: PluginManager) => {
-  pluginManager.addAdapterType(
-    () =>
-      new AdapterType({
-        name: 'BamAdapter',
-        configSchema,
-        getAdapterClass: () => import('./BamAdapter').then(r => r.default),
-      }),
-  )
+  pluginManager.addAdapterType(() => {
+    return new AdapterType({
+      name: 'BamAdapter',
+      configSchema,
+      getAdapterClass: () => import('./BamAdapter').then(r => r.default),
+    })
+  })
 }

package/src/CombinationTest.test.ts

@@ -0,0 +1,107 @@
+import PluginManager from '@jbrowse/core/PluginManager'
+import { toArray } from 'rxjs/operators'
+import { LocalFile } from 'generic-filehandle'
+import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'
+
+import CramAdapter from './CramAdapter/CramAdapter'
+import BamAdapter from './BamAdapter/BamAdapter'
+import { SequenceAdapter } from './CramAdapter/CramTestAdapters'
+
+import cramConfigSchema from './CramAdapter/configSchema'
+import bamConfigSchema from './BamAdapter/configSchema'
+
+const pluginManager = new PluginManager()
+
+const getVolvoxSequenceSubAdapter: getSubAdapterType = async () => {
+  return {
+    dataAdapter: new SequenceAdapter(
+      new LocalFile(require.resolve('../test_data/volvox.fa')),
+    ),
+    sessionIds: new Set(),
+  }
+}
+
+async function getFeats(f1: string, f2: string) {
+  const cramAdapter = new CramAdapter(
+    cramConfigSchema.create({
+      cramLocation: {
+        localPath: require.resolve(f1),
+      },
+      craiLocation: {
+        localPath: require.resolve(f1 + '.crai'),
+      },
+    }),
+    getVolvoxSequenceSubAdapter,
+    pluginManager,
+  )
+
+  const bamAdapter = new BamAdapter(
+    bamConfigSchema.create({
+      bamLocation: {
+        localPath: require.resolve(f2),
+      },
+      index: {
+        location: {
+          localPath: require.resolve(f2 + '.bai'),
+        },
+      },
+    }),
+  )
+  const query = {
+    assemblyName: 'volvox',
+    refName: 'ctgA',
+    start: 1,
+    end: 10200,
+  }
+  const bamFeatures = bamAdapter.getFeatures(query)
+  const cramFeatures = cramAdapter.getFeatures(query)
+  const bamFeaturesArray = await bamFeatures.pipe(toArray()).toPromise()
+  const cramFeaturesArray = await cramFeatures.pipe(toArray()).toPromise()
+  return { bamFeaturesArray, cramFeaturesArray }
+}
+
+type M = { start: number }
+
+async function cigarCheck(f: string) {
+  const { cramFeaturesArray, bamFeaturesArray } = await getFeats(
+    `../test_data/${f}.cram`,
+    `../test_data/${f}.bam`,
+  )
+  const cramMap = Object.fromEntries(
+    cramFeaturesArray.map(f => [f.get('name'), f.get('CIGAR')]),
+  )
+  const bamMap = Object.fromEntries(
+    bamFeaturesArray.map(f => [f.get('name'), f.get('CIGAR')]),
+  )
+  expect(bamMap).toEqual(cramMap)
+}
+
+async function mismatchesCheck(f: string) {
+  const { cramFeaturesArray, bamFeaturesArray } = await getFeats(
+    `../test_data/${f}.cram`,
+    `../test_data/${f}.bam`,
+  )
+  const cramMap = Object.fromEntries(
+    cramFeaturesArray.map(f => [
+      f.get('name'),
+      f.get('mismatches').sort((a: M, b: M) => b.start - a.start),
+    ]),
+  )
+  const bamMap = Object.fromEntries(
+    bamFeaturesArray.map(f => [
+      f.get('name'),
+      f.get('mismatches').sort((a: M, b: M) => b.start - a.start),
+    ]),
+  )
+  expect(bamMap).toEqual(cramMap)
+}
+
+test('match CIGAR across file types', async () => {
+  await cigarCheck('volvox-sorted')
+  await cigarCheck('volvox-long-reads.fastq.sorted')
+})
+
+test('mismatches same across file types', async () => {
+  await mismatchesCheck('volvox-sorted')
+  await mismatchesCheck('volvox-long-reads.fastq.sorted')
+})

package/src/CramAdapter/CramAdapter.test.ts

@@ -4,10 +4,9 @@ import PluginManager from '@jbrowse/core/PluginManager'
 import { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'
 import Adapter from './CramAdapter'
 import { SequenceAdapter } from './CramTestAdapters'
-import configSchemaF from './configSchema'
+import configSchema from './configSchema'
 
 const pluginManager = new PluginManager()
-const configSchema = pluginManager.load(configSchemaF)
 
 const getVolvoxSequenceSubAdapter: getSubAdapterType = async () => {
   return {

package/src/CramAdapter/CramAdapter.ts

@@ -1,7 +1,8 @@
-import { CraiIndex, IndexedCramFile } from '@gmod/cram'
+import { CraiIndex, IndexedCramFile, CramRecord } from '@gmod/cram'
 import {
   BaseFeatureDataAdapter,
   BaseOptions,
+  BaseSequenceAdapter,
 } from '@jbrowse/core/data_adapters/BaseAdapter'
 import { checkAbortSignal, Region, Feature } from '@jbrowse/core/util'
 import { openLocation } from '@jbrowse/core/util/io'
@@ -9,15 +10,10 @@ import { ObservableCreate } from '@jbrowse/core/util/rxjs'
 import { toArray } from 'rxjs/operators'
 import CramSlightlyLazyFeature from './CramSlightlyLazyFeature'
 
-interface HeaderLine {
-  tag: string
-  value: any // eslint-disable-line @typescript-eslint/no-explicit-any
-  data: HeaderLine[]
-}
 interface Header {
   idToName?: string[]
   nameToId?: Record<string, number>
-  readGroups?: number[]
+  readGroups?: (string | undefined)[]
 }
 
 interface FilterBy {
@@ -32,8 +28,13 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
 
   private setupP?: Promise<{
     samHeader: Header
-    cram: any // eslint-disable-line @typescript-eslint/no-explicit-any
-    sequenceAdapter: any // eslint-disable-line @typescript-eslint/no-explicit-any
+    cram: IndexedCramFile
+    sequenceAdapter: BaseSequenceAdapter
+  }>
+
+  private configureP?: Promise<{
+    cram: IndexedCramFile
+    sequenceAdapter: BaseSequenceAdapter
   }>
 
   // maps a refname to an id
@@ -42,7 +43,7 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
   // maps a seqId to original refname, passed specially to render args, to a seqid
   private seqIdToOriginalRefName: string[] = []
 
-  public async configure() {
+  public async configurePre() {
     const cramLocation = this.getConf('cramLocation')
     const craiLocation = this.getConf('craiLocation')
     if (!cramLocation) {
@@ -51,48 +52,55 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
     if (!craiLocation) {
       throw new Error('missing craiLocation argument')
     }
+    const pm = this.pluginManager
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const cram: any = new IndexedCramFile({
-      cramFilehandle: openLocation(cramLocation, this.pluginManager),
-      index: new CraiIndex({
-        filehandle: openLocation(craiLocation, this.pluginManager),
-      }),
-      seqFetch: this.seqFetch.bind(this),
+    const cram = new IndexedCramFile({
+      cramFilehandle: openLocation(cramLocation, pm),
+      index: new CraiIndex({ filehandle: openLocation(craiLocation, pm) }),
+      seqFetch: (...args) => this.seqFetch(...args),
       checkSequenceMD5: false,
       fetchSizeLimit: 200_000_000, // just make this a large size to avoid hitting it
     })
-    // instantiate the sequence adapter
-    const sequenceAdapterType = this.getConf(['sequenceAdapter', 'type'])
 
     if (!this.getSubAdapter) {
       throw new Error('Error getting subadapter')
     }
 
     const seqConf = this.getConf('sequenceAdapter')
-    const { dataAdapter: sequenceAdapter } = await this.getSubAdapter(seqConf)
+    const subadapter = await this.getSubAdapter(seqConf)
 
-    if (!(sequenceAdapter instanceof BaseFeatureDataAdapter)) {
-      throw new Error(
-        `CRAM feature adapters cannot use sequence adapters of type '${sequenceAdapterType}'`,
-      )
+    return {
+      cram,
+      sequenceAdapter: subadapter.dataAdapter as BaseSequenceAdapter,
     }
+  }
 
-    return { cram, sequenceAdapter }
+  public async configure() {
+    if (!this.configureP) {
+      this.configureP = this.configurePre().catch(e => {
+        this.configureP = undefined
+        throw e
+      })
+    }
+    return this.configureP
   }
 
   async getHeader(opts?: BaseOptions) {
     const { cram } = await this.configure()
-    return cram.cram.getHeaderText(opts)
+    return cram.cram.getHeaderText()
   }
 
-  private async seqFetch(seqId: number, start: number, end: number) {
+  private async seqFetch(
+    seqId: number,
+    start: number,
+    end: number,
+  ): Promise<string> {
     start -= 1 // convert from 1-based closed to interbase
 
     const { sequenceAdapter } = await this.configure()
     const refName = this.refIdToOriginalName(seqId) || this.refIdToName(seqId)
     if (!refName) {
-      return undefined
+      throw new Error('unknown')
     }
 
     const seqChunks = await sequenceAdapter
@@ -132,10 +140,10 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
 
   private async setupPre(opts?: BaseOptions) {
     const { statusCallback = () => {} } = opts || {}
-    const configured = await this.configure()
+    const conf = await this.configure()
     statusCallback('Downloading index')
-    const { cram } = configured
-    const samHeader: HeaderLine[] = await cram.cram.getSamHeader(opts?.signal)
+    const { cram } = conf
+    const samHeader = await cram.cram.getSamHeader()
 
     // use the @SQ lines in the header to figure out the
     // mapping between ref ID numbers and names
@@ -161,7 +169,7 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
     const data = { idToName, nameToId, readGroups }
     statusCallback('')
     this.samHeader = data
-    return { samHeader: data, ...configured }
+    return { samHeader: data, ...conf }
   }
 
   private async setup(opts?: BaseOptions) {
@@ -197,13 +205,7 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
   // use info from the SAM header if possible, but fall back to using
   // the ref seq order from when the browser's refseqs were loaded
   refIdToName(refId: number) {
-    if (this.samHeader.idToName) {
-      return this.samHeader.idToName[refId]
-    }
-    if (this.seqIdToRefName) {
-      return this.seqIdToRefName[refId]
-    }
-    return undefined
+    return this.samHeader.idToName?.[refId] || this.seqIdToRefName?.[refId]
   }
 
   refIdToOriginalName(refId: number) {
@@ -220,53 +222,48 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
     const { refName, start, end, originalRefName } = region
 
     return ObservableCreate<Feature>(async observer => {
-      const { cram, sequenceAdapter } = await this.setup(opts)
-      statusCallback('Downloading alignments')
-      if (!this.seqIdToRefName) {
-        this.seqIdToRefName = await sequenceAdapter.getRefNames(opts)
-      }
+      const { cram } = await this.setup(opts)
+
       const refId = this.refNameToId(refName)
-      if (refId !== undefined) {
-        if (originalRefName) {
-          this.seqIdToOriginalRefName[refId] = originalRefName
-        }
-        const records = await cram.getRecordsForRange(refId, start, end, opts)
-        checkAbortSignal(signal)
-        const {
-          flagInclude = 0,
-          flagExclude = 0,
-          tagFilter,
-          readName,
-        } = filterBy || {}
-
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let filtered = records.filter((record: any) => {
-          const flags = record.flags
-          return (flags & flagInclude) === flagInclude && !(flags & flagExclude)
-        })
+      if (refId === undefined) {
+        console.warn('Unknown refName', refName)
+        observer.complete()
+        return
+      }
+
+      if (originalRefName) {
+        this.seqIdToOriginalRefName[refId] = originalRefName
+      }
+      statusCallback('Downloading alignments')
+      const records = await cram.getRecordsForRange(refId, start, end)
+      checkAbortSignal(signal)
+      const {
+        flagInclude = 0,
+        flagExclude = 0,
+        tagFilter,
+        readName,
+      } = filterBy || {}
+
+      let filtered = records.filter(record => {
+        const flags = record.flags
+        return (flags & flagInclude) === flagInclude && !(flags & flagExclude)
+      })
 
-        if (tagFilter) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          filtered = filtered.filter((record: any) => {
-            const val = record[tagFilter.tag]
-            return val === '*' ? val !== undefined : val === tagFilter.value
-          })
-        }
-
-        if (readName) {
-          filtered = filtered.filter(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (record: any) => record.readName === readName,
-          )
-        }
-
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        filtered.forEach((record: any) => {
-          observer.next(this.cramRecordToFeature(record))
+      if (tagFilter) {
+        filtered = filtered.filter(record => {
+          // @ts-ignore
+          const val = record[tagFilter.tag]
+          return val === '*' ? val !== undefined : val === tagFilter.value
         })
-      } else {
-        console.warn('Unknown refName', refName)
       }
+
+      if (readName) {
+        filtered = filtered.filter(record => record.readName === readName)
+      }
+
+      filtered.forEach(record => {
+        observer.next(this.cramRecordToFeature(record))
+      })
       statusCallback('')
       observer.complete()
     }, signal)
@@ -274,7 +271,7 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
 
   freeResources(/* { region } */): void {}
 
-  cramRecordToFeature(record: unknown) {
+  cramRecordToFeature(record: CramRecord) {
     return new CramSlightlyLazyFeature(record, this)
   }
 
@@ -299,7 +296,9 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
       regions.map(region => {
         const { refName, start, end } = region
         const chrId = this.refNameToId(refName)
-        return cram.index.getEntriesForRange(chrId, start, end)
+        return chrId !== undefined
+          ? cram.index.getEntriesForRange(chrId, start, end)
+          : [{ sliceBytes: 0 }]
       }),
     )