@apollo-annotation/shared 0.1.18 → 0.1.19

package/src/GFF3/gff3ToAnnotationFeature.ts

@@ -0,0 +1,257 @@
+import { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+import { GFF3Feature, GFF3FeatureLineWithRefs } from '@gmod/gff'
+import { doesIntersect2 } from '@jbrowse/core/util'
+import ObjectID from 'bson-objectid'
+
+import { gffToInternal, isGFFReservedAttribute } from './gffReservedKeys'
+
+export function gff3ToAnnotationFeature(
+  gff3Feature: GFF3Feature,
+  refSeq?: string,
+  featureIds?: string[],
+): AnnotationFeatureSnapshot {
+  const [firstFeature] = gff3Feature
+  const { end, seq_id: refName, start, strand, type } = firstFeature
+  if (!refName) {
+    throw new Error(
+      `feature does not have seq_id: ${JSON.stringify(firstFeature)}`,
+    )
+  }
+  if (!type) {
+    throw new Error(
+      `feature does not have type: ${JSON.stringify(firstFeature)}`,
+    )
+  }
+  if (start === null) {
+    throw new Error(
+      `feature does not have start: ${JSON.stringify(firstFeature)}`,
+    )
+  }
+  if (end === null) {
+    throw new Error(
+      `feature does not have end: ${JSON.stringify(firstFeature)}`,
+    )
+  }
+
+  const [min, max] = getFeatureMinMax(gff3Feature)
+
+  const convertedChildren = convertChildren(gff3Feature, refSeq, featureIds)
+
+  const convertedAttributes = convertFeatureAttributes(gff3Feature)
+
+  const feature: AnnotationFeatureSnapshot = {
+    _id: new ObjectID().toHexString(),
+    refSeq: refSeq ?? refName,
+    type,
+    min,
+    max,
+  }
+  if (strand) {
+    if (strand === '+') {
+      feature.strand = 1
+    } else if (strand === '-') {
+      feature.strand = -1
+    } else {
+      throw new Error(`Unknown strand: "${strand}"`)
+    }
+  }
+  if (convertedChildren) {
+    feature.children = convertedChildren
+  }
+  if (convertedAttributes) {
+    feature.attributes = convertedAttributes
+  }
+  if (featureIds) {
+    featureIds.push(feature._id)
+  }
+  return feature
+}
+
+function getFeatureMinMax(gff3Feature: GFF3Feature): [number, number] {
+  if (gff3Feature.length > 1 && !gff3Feature.every((f) => f.type === 'CDS')) {
+    throw new Error('GFF3 features has multiple locations but is not a CDS')
+  }
+  const mins = gff3Feature.map((f) => f.start).filter((m) => m !== null)
+  const maxes = gff3Feature.map((f) => f.end).filter((m) => m !== null)
+  const min = Math.min(...mins)
+  const max = Math.max(...maxes)
+  return [min - 1, max]
+}
+
+function convertFeatureAttributes(
+  gff3Feature: GFF3Feature,
+): Record<string, string[]> | undefined {
+  const convertedAttributes: Record<string, string[]> = {}
+  const scores = gff3Feature
+    .map((f) => f.score)
+    .filter((score) => score !== null)
+  const sources = gff3Feature
+    .map((f) => f.source)
+    .filter((source) => source !== null)
+  const attributesCollections = gff3Feature
+    .map((f) => f.attributes)
+    .filter((attributes) => attributes !== null)
+  if (scores.length > 0) {
+    let [score] = scores
+    if (scores.length > 1) {
+      const scoresSum = scores.reduce(
+        (accumulator, currentValue) => accumulator + currentValue,
+        0,
+      )
+      // Average score
+      score = scoresSum / scores.length
+    }
+    convertedAttributes.gff_score = [String(score)]
+  }
+  if (sources.length > 0) {
+    let [source] = sources
+    if (sources.length > 1) {
+      const sourceSet = new Set(...sources)
+      source = [...sourceSet].join(',')
+    }
+    convertedAttributes.gff_source = [source]
+  }
+  if (attributesCollections.length > 0) {
+    const newAttributes: Record<string, string[] | undefined> = {}
+    for (const attributesCollection of attributesCollections) {
+      for (const [key, val] of Object.entries(attributesCollection)) {
+        if (!val || key === 'Parent') {
+          continue
+        }
+        const newKey = isGFFReservedAttribute(key) ? gffToInternal[key] : key
+        const existingVal = newAttributes[newKey]
+        if (existingVal) {
+          const valSet = new Set(...existingVal, ...val)
+          convertedAttributes[newKey] = [...valSet]
+        } else {
+          convertedAttributes[newKey] = val
+        }
+      }
+    }
+  }
+  if (Object.keys(convertedAttributes).length > 0) {
+    return convertedAttributes
+  }
+  return
+}
+
+function convertChildren(
+  gff3Feature: GFF3Feature,
+  refSeq?: string,
+  featureIds?: string[],
+): Record<string, AnnotationFeatureSnapshot> | undefined {
+  const convertedChildren: Record<string, AnnotationFeatureSnapshot> = {}
+  const locationsWithChildren = gff3Feature.filter(
+    (feature) => feature.child_features.length > 0,
+  )
+  if (locationsWithChildren.length > 1) {
+    throw new Error('Features with multiple locations may not have children')
+  }
+  if (locationsWithChildren.length === 0) {
+    return
+  }
+  const [firstFeature] = locationsWithChildren
+  const { child_features: childFeatures } = firstFeature
+
+  const cdsFeatures: GFF3Feature[] = []
+  for (const childFeature of childFeatures) {
+    const [firstChildFeatureLocation] = childFeature
+    if (
+      firstChildFeatureLocation.type === 'three_prime_UTR' ||
+      firstChildFeatureLocation.type === 'five_prime_UTR'
+    ) {
+      continue
+    }
+    if (firstChildFeatureLocation.type === 'CDS') {
+      cdsFeatures.push(childFeature)
+    } else {
+      const child = gff3ToAnnotationFeature(childFeature, refSeq, featureIds)
+      convertedChildren[child._id] = child
+    }
+  }
+  const processedCDS =
+    cdsFeatures.length > 0 ? processCDS(cdsFeatures, refSeq, featureIds) : []
+  for (const cds of processedCDS) {
+    convertedChildren[cds._id] = cds
+  }
+
+  if (Object.keys(convertedChildren).length > 0) {
+    return convertedChildren
+  }
+  return
+}
+
+/**
+ * If a GFF3 file has CDS features that either (1) don't have an ID or (2) have
+ * different IDs for each CDS, we have to do a bit of guessing about how they
+ * should be represented in our internal structure
+ * @param cdsFeatures -
+ */
+function processCDS(
+  cdsFeatures: GFF3Feature[],
+  refSeq?: string,
+  featureIds?: string[],
+): AnnotationFeatureSnapshot[] {
+  const locationCounts = cdsFeatures.map((cds) => cds.length)
+  // If any CDS have multiple locations, assume it really is multiple CDS
+  // (e.g. the mRNA has multiple alternative translational start sites)
+  // and process normally.
+  if (locationCounts.some((count) => count > 1)) {
+    return cdsFeatures.map((cds) =>
+      gff3ToAnnotationFeature(cds, refSeq, featureIds),
+    )
+  }
+  // If all CDS have a single location, we guess that this GFF3 represented CDS
+  // as multiple features instead of a single feature with multiple locations.
+  // To figure out if it's actually representing one vs. multiple CDS features,
+  // first check to see if any of the CDS overlap
+  const sortedCDSLocations = cdsFeatures
+    .map((cds) => cds[0])
+    .filter((cds) => cds.start !== null && cds.end !== null)
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    .sort((cdsA, cdsB) => cdsA.start! - cdsB.start!)
+  const overlapping = sortedCDSLocations.some((loc, idx) => {
+    const nextLoc = sortedCDSLocations.at(idx + 1)
+    if (!nextLoc) {
+      return false
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return doesIntersect2(loc.start!, loc.end!, nextLoc.start!, nextLoc.end!)
+  })
+  // If no overlaps, assume it's a single CDS feature
+  if (!overlapping) {
+    return [gff3ToAnnotationFeature(sortedCDSLocations, refSeq, featureIds)]
+  }
+  // Some CDS locations overlap, the best we can do is use the original order to
+  // guess how to group the locations into features
+  const cdsLocations = cdsFeatures.map((cds) => cds[0])
+  const groupedLocations: GFF3FeatureLineWithRefs[][] = []
+  for (const location of cdsLocations) {
+    const lastGroup = groupedLocations.at(-1)
+    if (!lastGroup) {
+      groupedLocations.push([location])
+      continue
+    }
+    const lastGroupLastLocation = lastGroup.at(-1)
+    if (!lastGroupLastLocation) {
+      throw new Error('Got group with no locations')
+    }
+    if (
+      doesIntersect2(
+        /* eslint-disable @typescript-eslint/no-non-null-assertion */
+        lastGroupLastLocation.start!,
+        lastGroupLastLocation.end!,
+        location.start!,
+        location.end!,
+        /* eslint-enable @typescript-eslint/no-non-null-assertion */
+      )
+    ) {
+      groupedLocations.push([location])
+    } else {
+      lastGroup.push(location)
+    }
+  }
+  return groupedLocations.map((group) =>
+    gff3ToAnnotationFeature(group, refSeq, featureIds),
+  )
+}

package/src/GFF3/gffReservedKeys.ts

@@ -0,0 +1,61 @@
+export type GFFReservedAttribute =
+  | 'ID'
+  | 'Name'
+  | 'Alias'
+  | 'Parent'
+  | 'Target'
+  | 'Gap'
+  | 'Derives_from'
+  | 'Note'
+  | 'Dbxref'
+  | 'Ontology_term'
+  | 'Is_circular'
+
+export type GFFInternalAttribute =
+  | 'gff_id'
+  | 'gff_name'
+  | 'gff_alias'
+  | 'gff_parent'
+  | 'gff_target'
+  | 'gff_gap'
+  | 'gff_derives_from'
+  | 'gff_note'
+  | 'gff_dbxref'
+  | 'gff_ontology_term'
+  | 'gff_is_circular'
+
+export const gffToInternal: Record<GFFReservedAttribute, GFFInternalAttribute> =
+  {
+    ID: 'gff_id',
+    Name: 'gff_name',
+    Alias: 'gff_alias',
+    Parent: 'gff_parent',
+    Target: 'gff_target',
+    Gap: 'gff_gap',
+    Derives_from: 'gff_derives_from',
+    Note: 'gff_note',
+    Dbxref: 'gff_dbxref',
+    Ontology_term: 'gff_ontology_term',
+    Is_circular: 'gff_is_circular',
+  }
+
+export function isGFFReservedAttribute(
+  attribute: string,
+): attribute is GFFReservedAttribute {
+  return attribute in gffToInternal
+}
+
+export const internalToGFF: Record<GFFInternalAttribute, GFFReservedAttribute> =
+  {
+    gff_id: 'ID',
+    gff_name: 'Name',
+    gff_alias: 'Alias',
+    gff_parent: 'Parent',
+    gff_target: 'Target',
+    gff_gap: 'Gap',
+    gff_derives_from: 'Derives_from',
+    gff_note: 'Note',
+    gff_dbxref: 'Dbxref',
+    gff_ontology_term: 'Ontology_term',
+    gff_is_circular: 'Is_circular',
+  }

package/src/GFF3/index.ts

@@ -0,0 +1,2 @@
+export * from './gffReservedKeys'
+export * from './gff3ToAnnotationFeature'

package/src/Operations/GetFeaturesOperation.ts

@@ -45,8 +45,8 @@ export class GetFeaturesOperation extends Operation {
     return backend.featureModel
       .find({
         refSeq: this.refSeq,
-        start: { $lte: this.end },
-        end: { $gte: this.start },
+        min: { $lte: this.end },
+        max: { $gte: this.start },
         status: 0,
       })
       .exec()

package/src/Validations/ParentChildValidation.ts

@@ -72,11 +72,11 @@ export class ParentChildValidation extends Validation {
     }
     for (const [, childFeature] of feature.children || new Map()) {
       if (
-        feature.start !== null &&
-        feature.end !== null &&
-        childFeature.start !== null &&
-        childFeature.end !== null &&
-        (childFeature.end > feature.end || childFeature.start < feature.start)
+        feature.min !== null &&
+        feature.max !== null &&
+        childFeature.min !== null &&
+        childFeature.max !== null &&
+        (childFeature.max > feature.max || childFeature.min < feature.min)
       ) {
         throw new Error(
           `Feature "${childFeature._id}" exceeds the bounds of its parent, "${feature._id}"`,

package/src/index.ts

@@ -5,3 +5,4 @@ export * from './Common'
 export * from './Checks'
 export * from './util'
 export * from './Messages'
+export * from './GFF3'

package/src/util.ts

@@ -7,9 +7,10 @@ export function makeGFF3Feature(
   parentId?: string,
   refSeqNames?: Record<string, string | undefined>,
 ): GFF3Feature {
-  const locations = feature.discontinuousLocations?.length
-    ? feature.discontinuousLocations
-    : [{ start: feature.start, end: feature.end, phase: feature.phase }]
+  const locations = [{ start: feature.min, end: feature.max }]
+  // const locations = feature.discontinuousLocations?.length
+  //   ? feature.discontinuousLocations
+  //   : [{ start: feature.start, end: feature.end, phase: feature.phase }]
   const attributes: Record<string, string[] | undefined> = JSON.parse(
     JSON.stringify(feature.attributes),
   )
@@ -76,16 +77,18 @@ export function makeGFF3Feature(
     seq_id: refSeqNames ? refSeqNames[feature.refSeq] ?? null : feature.refSeq,
     source,
     type: feature.type,
-    score: feature.score ?? null,
+    score: null,
+    // score: feature.score ?? null,
     strand: feature.strand ? (feature.strand === 1 ? '+' : '-') : null,
-    phase:
-      location.phase === 0
-        ? '0'
-        : location.phase === 1
-          ? '1'
-          : location.phase === 2
-            ? '2'
-            : null,
+    phase: null,
+    // phase:
+    //   location.phase === 0
+    //     ? '0'
+    //     : location.phase === 1
+    //       ? '1'
+    //       : location.phase === 2
+    //         ? '2'
+    //         : null,
     attributes: Object.keys(attributes).length > 0 ? attributes : null,
     derived_features: [],
     child_features: feature.children

package/tsconfig.json

@@ -12,8 +12,8 @@
   },
   "include": ["./src"],
   "references": [
-    { "path": "../apollo-mst"},
-    { "path": "../apollo-schemas"},
-    { "path": "../apollo-common"},
-  ]
+    { "path": "../apollo-mst" },
+    { "path": "../apollo-schemas" },
+    { "path": "../apollo-common" },
+  ],
 }

package/src/Changes/DiscontinuousLocationEndChange.ts

@@ -1,182 +0,0 @@
-/* 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'
-  )
-}