@apollo-annotation/shared 0.1.11

package/src/Checks/CDSCheck.ts

@@ -0,0 +1,275 @@
+import { Check } from '@apollo-annotation/common'
+import {
+  AnnotationFeatureSnapshot,
+  CheckResultSnapshot,
+} from '@apollo-annotation/mst'
+import ObjectID from 'bson-objectid'
+
+enum STOP_CODONS {
+  'TAG',
+  'TAA',
+  'TGA',
+}
+
+const iupacComplements: Record<string, string | undefined> = {
+  G: 'C',
+  A: 'T',
+  T: 'A',
+  C: 'G',
+  R /* G or A */: 'Y',
+  Y /* T or C */: 'R',
+  M /* A or C */: 'K',
+  K /* G or T */: 'M',
+  S /* G or C */: 'S',
+  W /* A or T */: 'W',
+  H /* A or C or T */: 'D',
+  B /* G or T or C */: 'V',
+  V /* G or C or A */: 'B',
+  D /* G or A or T */: 'H',
+  N /* G or A or T or C */: 'N',
+}
+
+function reverseComplement(dna: string): string {
+  const complement: string[] = []
+  for (const nt of dna) {
+    const rc = iupacComplements[nt.toUpperCase()]
+    if (rc === undefined) {
+      throw new TypeError(`Cannot complement nucleotide: "${nt}"`)
+    }
+    if (nt === nt.toLowerCase()) {
+      complement.push(rc.toLowerCase())
+    } else {
+      complement.push(rc)
+    }
+  }
+  return complement.reverse().join('')
+}
+
+async function getSequenceFromSingleFeature(
+  feature: AnnotationFeatureSnapshot,
+  getSequence: (start: number, end: number) => Promise<string>,
+) {
+  let seq = ''
+  if (
+    feature.discontinuousLocations !== undefined &&
+    feature.discontinuousLocations.length > 0
+  ) {
+    for (const loc of feature.discontinuousLocations) {
+      seq = seq + (await getSequence(loc.start, loc.end))
+    }
+  } else {
+    seq = await getSequence(feature.start, feature.end)
+  }
+  if (feature.strand === -1) {
+    return reverseComplement(seq)
+  }
+  return seq
+}
+
+async function getSequenceFromMultipleFeatures(
+  features: AnnotationFeatureSnapshot[],
+  getSequence: (start: number, end: number) => Promise<string>,
+) {
+  const strands = features.map((feature) => feature.strand)
+  if (!strands.every((strand) => strand === strands[0])) {
+    throw new Error(
+      `Strands do not match in features: "${features
+        .map((f) => f._id)
+        .join(', ')}"`,
+    )
+  }
+  let seq = ''
+  for (const feature of features) {
+    seq = seq + (await getSequence(feature.start, feature.end))
+  }
+  if (strands[0] === -1) {
+    return reverseComplement(seq)
+  }
+  return seq
+}
+
+function splitSequenceInCodons(cds: string): string[] {
+  const codons: string[] = []
+  for (let i = 0; i <= cds.length - 3; i += 3) {
+    codons.push(cds.slice(i, i + 3))
+  }
+  return codons
+}
+
+function getOriginalCodonLocation(
+  feature: AnnotationFeatureSnapshot | AnnotationFeatureSnapshot[],
+  index: number,
+): [number, number] {
+  let lengthToStart = index * 3
+  let lengthToEnd = lengthToStart + 3
+  if (Array.isArray(feature)) {
+    let startLocation: number | undefined = undefined,
+      endLocation: number | undefined = undefined
+    for (const f of feature) {
+      const featureLength = f.end - f.start
+      if (startLocation === undefined && featureLength > lengthToStart) {
+        startLocation = f.start + lengthToStart
+      } else {
+        lengthToStart -= featureLength
+      }
+      if (endLocation === undefined && featureLength > lengthToEnd) {
+        endLocation = f.start + lengthToEnd
+      } else {
+        lengthToEnd -= featureLength
+      }
+      if (startLocation !== undefined && endLocation !== undefined) {
+        return [startLocation, endLocation]
+      }
+    }
+    throw new Error('Could not determine original CDS location')
+  } else {
+    if (
+      feature.discontinuousLocations !== undefined &&
+      feature.discontinuousLocations.length > 0
+    ) {
+      let startLocation: number | undefined = undefined,
+        endLocation: number | undefined = undefined
+      for (const loc of feature.discontinuousLocations) {
+        const locLength = loc.end - loc.start
+        if (startLocation === undefined && locLength > lengthToStart) {
+          startLocation = loc.start + lengthToStart
+        } else {
+          lengthToStart -= locLength
+        }
+        if (endLocation === undefined && locLength > lengthToEnd) {
+          endLocation = loc.start + lengthToEnd
+        } else {
+          lengthToEnd -= locLength
+        }
+        if (startLocation !== undefined && endLocation !== undefined) {
+          return [startLocation, endLocation]
+        }
+      }
+      throw new Error('Could not determine original CDS location')
+    } else {
+      return [feature.start + lengthToStart, feature.start + lengthToEnd]
+    }
+  }
+}
+
+async function checkCDS(
+  feature: AnnotationFeatureSnapshot | AnnotationFeatureSnapshot[],
+  getSequence: (start: number, end: number) => Promise<string>,
+): Promise<CheckResultSnapshot[]> {
+  const checkResults: CheckResultSnapshot[] = []
+  let _id: string,
+    ids: string[],
+    start: number,
+    end: number,
+    refSeq: string,
+    sequence: string
+  if (Array.isArray(feature)) {
+    sequence = await getSequenceFromMultipleFeatures(feature, getSequence)
+    ids = feature.map((f) => f._id)
+    _id = ids.join(',')
+    ;[{ refSeq, start }] = feature
+    const lastFeature = feature.at(-1)
+    if (!lastFeature) {
+      throw new Error('Zero-length feature array encountered')
+    }
+    ;({ end } = lastFeature)
+  } else {
+    sequence = await getSequenceFromSingleFeature(feature, getSequence)
+    ;({ _id, end, refSeq, start } = feature)
+    ids = [_id]
+  }
+  const codons = splitSequenceInCodons(sequence)
+  if (sequence.length % 3 === 0) {
+    const lastCodon = codons.pop() // Last codon is supposed to be a stop
+    if (!lastCodon) {
+      throw new Error(`No sequence found for feature "${_id}"`)
+    }
+    if (!(lastCodon.toUpperCase() in STOP_CODONS)) {
+      checkResults.push({
+        _id: new ObjectID().toHexString(),
+        name: 'MissingStopCodonCheck',
+        ids,
+        refSeq: refSeq.toString(),
+        start: end,
+        end,
+        message: `Feature "${_id}" is missing a stop codon`,
+      })
+    }
+  } else {
+    checkResults.push({
+      _id: new ObjectID().toHexString(),
+      name: 'MultipleOfThreeCheck',
+      ids,
+      refSeq: refSeq.toString(),
+      start,
+      end,
+      message: `The coding sequence for feature "${_id}" is not a multiple of three`,
+    })
+  }
+  for (const [idx, codon] of codons.entries()) {
+    const [codonStart, codonEnd] = getOriginalCodonLocation(feature, idx)
+    if (codon.toUpperCase() in STOP_CODONS) {
+      checkResults.push({
+        _id: new ObjectID().toHexString(),
+        name: 'InternalStopCodonCheck',
+        ids,
+        refSeq: refSeq.toString(),
+        start: codonStart,
+        end: codonEnd,
+        message: `The coding sequence for feature "${_id}" has an internal stop codon`,
+      })
+    }
+  }
+  return checkResults
+}
+
+export class CDSCheck extends Check {
+  name = 'CDSCheck'
+  version = 1
+  default = true
+
+  async checkFeature(
+    feature: AnnotationFeatureSnapshot,
+    getSequence: (start: number, end: number) => Promise<string>,
+  ): Promise<CheckResultSnapshot[]> {
+    if (feature.type === 'CDS') {
+      return checkCDS(feature, getSequence)
+    }
+
+    if (!feature.children) {
+      return []
+    }
+
+    if (feature.type !== 'mRNA') {
+      const checkResults: CheckResultSnapshot[] = []
+      for (const child of Object.values(feature.children)) {
+        checkResults.push(...(await this.checkFeature(child, getSequence)))
+      }
+      return checkResults
+    }
+
+    const cdsChildren = Object.values(feature.children).filter(
+      (child) => child.type === 'CDS',
+    )
+    if (cdsChildren.length === 0) {
+      throw new Error(`mRNA "${feature._id}" has no CDS children`)
+    }
+    const cdsChildrenWithDiscontinuousLocations = cdsChildren.filter(
+      (child) =>
+        child.discontinuousLocations && child.discontinuousLocations.length > 0,
+    )
+    if (cdsChildrenWithDiscontinuousLocations.length === 0) {
+      return checkCDS(cdsChildren, getSequence)
+    }
+    if (cdsChildrenWithDiscontinuousLocations.length === cdsChildren.length) {
+      const checkResults: CheckResultSnapshot[] = []
+      for (const child of cdsChildren) {
+        checkResults.push(...(await this.checkFeature(child, getSequence)))
+      }
+      return checkResults
+    }
+    throw new Error(
+      `Mix of CDS with and without discontinuous locations found in mRNA "${feature._id}"`,
+    )
+  }
+}

package/src/Checks/index.ts

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

package/src/Common/index.ts

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

package/src/Common/jwtPayload.ts

@@ -0,0 +1,25 @@
+import jwtDecode from 'jwt-decode'
+
+export interface JWTPayload {
+  username: string
+  email: string
+  role?: 'admin' | 'user' | 'readOnly'
+  id: string
+}
+
+export interface DecodedJWT extends JWTPayload {
+  iat: number
+  exp: number
+}
+
+export function makeUserSessionId(userOrToken: DecodedJWT | string): string {
+  const user =
+    typeof userOrToken === 'string'
+      ? jwtDecode<DecodedJWT>(userOrToken)
+      : userOrToken
+  return `${user.id}-${user.iat}`
+}
+
+export function getDecodedToken(token: string): DecodedJWT {
+  return jwtDecode<DecodedJWT>(token)
+}

package/src/Messages.ts

@@ -0,0 +1,32 @@
+import { SerializedChange } from '@apollo-annotation/common'
+import { CheckResultSnapshot } from '@apollo-annotation/mst'
+
+interface BaseMessage {
+  channel: string
+  userName: string
+  userSessionId: string
+}
+
+export interface ChangeMessage extends BaseMessage {
+  changeInfo: SerializedChange
+  changeSequence: number
+}
+export interface CheckResultUpdate extends BaseMessage {
+  checkResult: CheckResultSnapshot
+  deleted?: boolean
+}
+
+export interface UserLocation {
+  assemblyId: string
+  refSeq: string
+  start: number
+  end: number
+}
+
+export interface UserLocationMessage extends BaseMessage {
+  locations: UserLocation[]
+}
+
+export interface RequestUserInformationMessage extends BaseMessage {
+  readonly reqType: 'CURRENT_LOCATION'
+}

package/src/Operations/GetAssembliesOperation.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  LocalGFF3DataStore,
+  Operation,
+  SerializedOperation,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+
+interface SerializedGetAssembliesOperation extends SerializedOperation {
+  typeName: 'GetAssembliesOperation'
+}
+
+export class GetAssembliesOperation extends Operation {
+  typeName = 'GetAssembliesOperation' as const
+
+  toJSON(): SerializedGetAssembliesOperation {
+    const { typeName } = this
+    return { typeName }
+  }
+
+  executeOnServer(backend: ServerDataStore) {
+    return backend.assemblyModel.find({ status: 0 }).exec()
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+}

package/src/Operations/GetFeaturesOperation.ts

@@ -0,0 +1,58 @@
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  LocalGFF3DataStore,
+  Operation,
+  OperationOptions,
+  SerializedOperation,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+
+interface SerializedGetFeaturesOperation extends SerializedOperation {
+  typeName: 'GetFeaturesOperation'
+  refSeq: string
+  start: number
+  end: number
+}
+
+export class GetFeaturesOperation extends Operation {
+  typeName = 'GetFeaturesOperation' as const
+  refSeq: string
+  start: number
+  end: number
+
+  constructor(
+    json: SerializedGetFeaturesOperation,
+    options?: OperationOptions,
+  ) {
+    super(json, options)
+    this.refSeq = json.refSeq
+    this.start = json.start
+    this.end = json.end
+  }
+
+  toJSON(): SerializedGetFeaturesOperation {
+    const { end, refSeq, start, typeName } = this
+    return { typeName, refSeq, start, end }
+  }
+
+  /**
+   * Fetch features based on Reference seq, Start and End -values
+   * @param request - Contain search criteria i.e. refSeq, start and end -parameters
+   * @returns Return Array of features if search was successful
+   * or if search data was not found or in case of error throw exception
+   */
+  executeOnServer(backend: ServerDataStore) {
+    return backend.featureModel
+      .find({
+        refSeq: this.refSeq,
+        start: { $lte: this.end },
+        end: { $gte: this.start },
+        status: 0,
+      })
+      .exec()
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+}

package/src/Operations/index.ts

@@ -0,0 +1,6 @@
+import { GetAssembliesOperation } from './GetAssembliesOperation'
+import { GetFeaturesOperation } from './GetFeaturesOperation'
+
+export const operations = { GetAssembliesOperation, GetFeaturesOperation }
+export * from './GetAssembliesOperation'
+export * from './GetFeaturesOperation'

package/src/Validations/CoreValidation.ts

@@ -0,0 +1,37 @@
+/* eslint-disable @typescript-eslint/require-await */
+import { Change } from '@apollo-annotation/common'
+
+import { TypeChange } from '../Changes'
+import soSequenceTypes from './soSequenceTypes'
+import { Validation } from './Validation'
+
+export function isTypeChange(thing: Change): thing is TypeChange {
+  return 'oldType' in thing && 'newType' in thing
+}
+
+export class CoreValidation extends Validation {
+  name = 'Core' as const
+
+  async frontendPreValidate(change: Change) {
+    if (isTypeChange(change)) {
+      for (const subChange of change.changes) {
+        if (!soSequenceTypes.includes(subChange.newType)) {
+          return {
+            validationName: this.name,
+            error: {
+              message: `"${subChange.newType}" is not a valid SO sequence_feature term`,
+            },
+          }
+        }
+      }
+    }
+    return { validationName: this.name }
+  }
+
+  async possibleValues(key: string) {
+    if (key === 'type') {
+      return soSequenceTypes
+    }
+    return
+  }
+}

package/src/Validations/ParentChildValidation.ts

@@ -0,0 +1,88 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+import { Change } from '@apollo-annotation/common'
+import { Feature, FeatureDocument } from '@apollo-annotation/schemas'
+import { ClientSession, Model } from 'mongoose'
+
+import {
+  LocationEndChange,
+  LocationStartChange,
+  isLocationEndChange,
+  isLocationStartChange,
+} from '../Changes'
+import { Validation, ValidationResult } from './Validation'
+
+export class ParentChildValidation extends Validation {
+  name = 'ParentChildValidation' as const
+
+  async backendPostValidate(
+    change: Change,
+    {
+      featureModel,
+      session,
+    }: { session: ClientSession; featureModel: Model<FeatureDocument> },
+  ): Promise<ValidationResult> {
+    if (isLocationEndChange(change) || isLocationStartChange(change)) {
+      return this.validateParentChildRelationships(change, {
+        session,
+        featureModel,
+      })
+    }
+    return { validationName: this.name }
+  }
+
+  async validateParentChildRelationships(
+    change: LocationEndChange | LocationStartChange,
+    {
+      featureModel,
+      session,
+    }: { session: ClientSession; featureModel: Model<FeatureDocument> },
+  ): Promise<ValidationResult> {
+    const topLevelFeatures: FeatureDocument[] = []
+    for (const ch of change.changes) {
+      const { featureId } = ch
+
+      // Search correct feature
+      const topLevelFeature = await featureModel
+        .findOne({ allIds: featureId })
+        .session(session)
+        .exec()
+
+      if (!topLevelFeature) {
+        const errMsg = `ERROR: The following featureId was not found in database ='${featureId}'`
+        throw new Error(errMsg)
+      }
+      if (!topLevelFeatures.some((f) => f._id === topLevelFeature._id)) {
+        topLevelFeatures.push(topLevelFeature)
+      }
+    }
+    for (const topLevelFeature of topLevelFeatures) {
+      try {
+        this.checkChildFeatureBoundaries(topLevelFeature)
+      } catch (error) {
+        return { validationName: this.name, error: { message: String(error) } }
+      }
+    }
+    return { validationName: this.name }
+  }
+
+  checkChildFeatureBoundaries(feature: Feature) {
+    if (!feature.children) {
+      return
+    }
+    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)
+      ) {
+        throw new Error(
+          `Feature "${childFeature._id}" exceeds the bounds of its parent, "${feature._id}"`,
+        )
+      }
+      this.checkChildFeatureBoundaries(childFeature)
+    }
+  }
+}

package/src/Validations/Validation.ts

@@ -0,0 +1,55 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+/* eslint-disable @typescript-eslint/require-await */
+import { Change, ClientDataStore } from '@apollo-annotation/common'
+import { FeatureDocument } from '@apollo-annotation/schemas'
+import type { ExecutionContext } from '@nestjs/common'
+import type { Reflector } from '@nestjs/core'
+import { ClientSession, Model } from 'mongoose'
+
+export interface Context {
+  context: ExecutionContext
+  reflector: Reflector
+}
+
+export function isContext(thing: Change | Context): thing is Context {
+  return (
+    (thing as Context).context !== undefined &&
+    (thing as Context).reflector !== undefined
+  )
+}
+
+export interface ValidationResult {
+  validationName: string
+  error?: { message: string }
+}
+
+export abstract class Validation {
+  abstract name: string
+  async frontendPreValidate(_change: Change): Promise<ValidationResult> {
+    return { validationName: this.name }
+  }
+
+  async frontendPostValidate(
+    _change: Change,
+    _dataStore: ClientDataStore,
+  ): Promise<ValidationResult> {
+    return { validationName: this.name }
+  }
+
+  async backendPreValidate(
+    _changeOrContext: Change | Context,
+  ): Promise<ValidationResult> {
+    return { validationName: this.name }
+  }
+
+  async backendPostValidate(
+    _change: Change,
+    _context: { session: ClientSession; featureModel: Model<FeatureDocument> },
+  ): Promise<ValidationResult> {
+    return { validationName: this.name }
+  }
+
+  async possibleValues(_key: string): Promise<unknown[] | undefined> {
+    return undefined
+  }
+}