@apollo-annotation/shared 0.1.11

package/src/Changes/DiscontinuousLocationStartChange.ts

@@ -0,0 +1,182 @@
+/* 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 SerializedDiscontinuousLocationStartChangeBase
+  extends SerializedFeatureChange {
+  typeName: 'DiscontinuousLocationStartChange'
+}
+
+interface DiscontinuousLocationStartChangeDetails {
+  featureId: string
+  oldStart: number
+  newStart: number
+  index: number
+}
+
+interface SerializedDiscontinuousLocationStartChangeSingle
+  extends SerializedDiscontinuousLocationStartChangeBase,
+    DiscontinuousLocationStartChangeDetails {}
+
+interface SerializedDiscontinuousLocationStartChangeMultiple
+  extends SerializedDiscontinuousLocationStartChangeBase {
+  changes: DiscontinuousLocationStartChangeDetails[]
+}
+
+type SerializedDiscontinuousLocationStartChange =
+  | SerializedDiscontinuousLocationStartChangeSingle
+  | SerializedDiscontinuousLocationStartChangeMultiple
+
+export class DiscontinuousLocationStartChange extends FeatureChange {
+  typeName = 'DiscontinuousLocationStartChange' as const
+  changes: DiscontinuousLocationStartChangeDetails[]
+
+  constructor(
+    json: SerializedDiscontinuousLocationStartChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedDiscontinuousLocationStartChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ featureId, index, newStart, oldStart }] = changes
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        featureId,
+        oldStart,
+        newStart,
+        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, newStart, oldStart: expectedOldStart } = 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 "LocationStartChange" to change a feature start that does not have discontinuous locations'
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      const oldStart = feature.discontinuousLocations[index].start
+      if (oldStart !== expectedOldStart) {
+        const errMsg = `Location's current start value ${oldStart} doesn't match with expected value ${expectedOldStart}`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      const { end } = feature.discontinuousLocations[index]
+      if (newStart >= end) {
+        const errMsg = `location start (${newStart}) can't be larger than location end (${end})`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      const previousLocation = feature.discontinuousLocations[index - 1]
+      if (previousLocation && newStart <= previousLocation.end) {
+        const errMsg = `Location start (${newStart}) can't be larger than  the previous location's end (${previousLocation.end})`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      feature.discontinuousLocations[index].start = newStart
+      if (index === 0) {
+        feature.start = newStart
+      }
+
+      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, newStart } = this.changes[idx]
+      feature.setCDSDiscontinuousLocationStart(newStart, index)
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger, typeName } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes].reverse().map((change) => ({
+      featureId: change.featureId,
+      oldStart: change.newStart,
+      newStart: change.oldStart,
+      index: change.index,
+    }))
+    return new DiscontinuousLocationStartChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName,
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}
+
+export function isDiscontinuousLocationStartChange(
+  change: unknown,
+): change is DiscontinuousLocationStartChange {
+  return (
+    (change as DiscontinuousLocationStartChange).typeName ===
+    'DiscontinuousLocationStartChange'
+  )
+}

package/src/Changes/FeatureAttributeChange.ts

@@ -0,0 +1,164 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import {
+  ChangeOptions,
+  ClientDataStore,
+  FeatureChange,
+  LocalGFF3DataStore,
+  SerializedFeatureChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { Feature, FeatureDocument } from '@apollo-annotation/schemas'
+
+interface SerializedFeatureAttributeChangeBase extends SerializedFeatureChange {
+  typeName: 'FeatureAttributeChange'
+}
+
+export interface FeatureAttributeChangeDetails {
+  featureId: string
+  attributes: Record<string, string[]>
+}
+
+interface SerializedFeatureAttributeChangeSingle
+  extends SerializedFeatureAttributeChangeBase,
+    FeatureAttributeChangeDetails {}
+
+interface SerializedFeatureAttributeChangeMultiple
+  extends SerializedFeatureAttributeChangeBase {
+  changes: FeatureAttributeChangeDetails[]
+}
+
+type SerializedFeatureAttributeChange =
+  | SerializedFeatureAttributeChangeSingle
+  | SerializedFeatureAttributeChangeMultiple
+
+export class FeatureAttributeChange extends FeatureChange {
+  typeName = 'FeatureAttributeChange' as const
+  changes: FeatureAttributeChangeDetails[]
+
+  constructor(json: SerializedFeatureAttributeChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedFeatureAttributeChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ attributes, featureId }] = changes
+      return { typeName, changedIds, assembly, featureId, attributes }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes, logger } = this
+
+    const featuresForChanges: {
+      feature: Feature
+      topLevelFeature: FeatureDocument
+    }[] = []
+    // Loop the changes and check that all features are found
+    for (const change of changes) {
+      const { featureId } = change
+
+      // 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}'`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+        // throw new NotFoundException(errMsg)  -- This is causing runtime error because Exception comes from @nestjs/common!!!
+      }
+      logger.debug?.(`*** Feature found: ${JSON.stringify(topLevelFeature)}`)
+
+      const foundFeature = this.getFeatureFromId(topLevelFeature, featureId)
+      if (!foundFeature) {
+        const errMsg = 'ERROR when searching feature by featureId'
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      logger.debug?.(`*** Found feature: ${JSON.stringify(foundFeature)}`)
+      featuresForChanges.push({ feature: foundFeature, topLevelFeature })
+    }
+
+    // Let's update objects
+    for (const [idx, change] of changes.entries()) {
+      const { attributes } = change
+      const { feature, topLevelFeature } = featuresForChanges[idx]
+      feature.attributes = attributes
+      if (topLevelFeature._id.equals(feature._id)) {
+        topLevelFeature.markModified('attributes') // Mark as modified. Without this save() -method is not updating data in database
+      } else {
+        topLevelFeature.markModified('children') // Mark as modified. Without this save() -method is not updating data in database
+      }
+
+      try {
+        await topLevelFeature.save()
+      } catch (error) {
+        logger.debug?.(`*** FAILED: ${error}`)
+        throw error
+      }
+      logger.debug?.(
+        `*** Feature attributes modified (added, edited or deleted), docId: ${JSON.stringify(
+          topLevelFeature,
+        )}`,
+      )
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('applyToLocalGFF3 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}"`)
+      }
+      feature.setAttributes(
+        new Map(Object.entries(this.changes[idx].attributes)),
+      )
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes].reverse().map((oneChange) => ({
+      featureId: oneChange.featureId,
+      attributes: oneChange.attributes,
+    }))
+    return new FeatureAttributeChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'FeatureAttributeChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}
+
+export function isFeatureAttributeChange(
+  change: unknown,
+): change is FeatureAttributeChange {
+  return (
+    (change as FeatureAttributeChange).typeName === 'FeatureAttributeChange'
+  )
+}

package/src/Changes/LocationEndChange.ts

@@ -0,0 +1,175 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import {
+  ChangeOptions,
+  ClientDataStore,
+  FeatureChange,
+  LocalGFF3DataStore,
+  SerializedFeatureChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { Feature, FeatureDocument } from '@apollo-annotation/schemas'
+
+interface SerializedLocationEndChangeBase extends SerializedFeatureChange {
+  typeName: 'LocationEndChange'
+}
+
+export interface LocationEndChangeDetails {
+  featureId: string
+  oldEnd: number
+  newEnd: number
+}
+
+interface SerializedLocationEndChangeSingle
+  extends SerializedLocationEndChangeBase,
+    LocationEndChangeDetails {}
+
+interface SerializedLocationEndChangeMultiple
+  extends SerializedLocationEndChangeBase {
+  changes: LocationEndChangeDetails[]
+}
+
+type SerializedLocationEndChange =
+  | SerializedLocationEndChangeSingle
+  | SerializedLocationEndChangeMultiple
+
+export class LocationEndChange extends FeatureChange {
+  typeName = 'LocationEndChange' as const
+  changes: LocationEndChangeDetails[]
+
+  constructor(json: SerializedLocationEndChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedLocationEndChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ featureId, newEnd, oldEnd }] = changes
+      return { typeName, changedIds, assembly, featureId, oldEnd, newEnd }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes, logger } = this
+    const featuresForChanges: {
+      feature: Feature
+      topLevelFeature: FeatureDocument
+    }[] = []
+    // Let's first check that all features are found and those old values match with expected ones. We do this just to be sure that all changes can be done.
+    for (const change of changes) {
+      const { featureId, oldEnd } = change
+
+      // 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}'`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+        // throw new NotFoundException(errMsg)  -- This is causing runtime error because Exception comes from @nestjs/common!!!
+      }
+      logger.debug?.(`*** Feature found: ${JSON.stringify(topLevelFeature)}`)
+
+      const foundFeature = this.getFeatureFromId(topLevelFeature, featureId)
+      if (!foundFeature) {
+        const errMsg = 'ERROR when searching feature by featureId'
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      logger.debug?.(`*** Found feature: ${JSON.stringify(foundFeature)}`)
+      if (
+        foundFeature.discontinuousLocations &&
+        foundFeature.discontinuousLocations.length > 0
+      ) {
+        const errMsg =
+          'Must use "DiscontinuousLocationEndChange" to change a feature end that has discontinuous locations'
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      if (foundFeature.end !== oldEnd) {
+        const errMsg = `*** ERROR: Feature's current end value ${foundFeature.end} doesn't match with expected value ${oldEnd}`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      featuresForChanges.push({ feature: foundFeature, topLevelFeature })
+    }
+
+    // Let's update objects.
+    for (const [idx, change] of changes.entries()) {
+      const { newEnd } = change
+      const { feature, topLevelFeature } = featuresForChanges[idx]
+      feature.end = newEnd
+      if (topLevelFeature._id.equals(feature._id)) {
+        topLevelFeature.markModified('end') // Mark as modified. Without this save() -method is not updating data in database
+      } else {
+        topLevelFeature.markModified('children') // Mark as modified. Without this save() -method is not updating data in database
+      }
+
+      try {
+        await topLevelFeature.save()
+      } catch (error) {
+        logger.debug?.(`*** FAILED: ${error}`)
+        throw error
+      }
+      logger.debug?.(
+        `*** Object updated in Mongo. New object: ${JSON.stringify(
+          topLevelFeature,
+        )}`,
+      )
+    }
+  }
+
+  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}"`)
+      }
+      feature.setEnd(this.changes[idx].newEnd)
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger, typeName } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes].reverse().map((endChange) => ({
+      featureId: endChange.featureId,
+      oldEnd: endChange.newEnd,
+      newEnd: endChange.oldEnd,
+    }))
+    return new LocationEndChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName,
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}
+
+export function isLocationEndChange(
+  change: unknown,
+): change is LocationEndChange {
+  return (change as LocationEndChange).typeName === 'LocationEndChange'
+}

package/src/Changes/LocationStartChange.ts

@@ -0,0 +1,175 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import {
+  ChangeOptions,
+  ClientDataStore,
+  FeatureChange,
+  LocalGFF3DataStore,
+  SerializedFeatureChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { Feature, FeatureDocument } from '@apollo-annotation/schemas'
+
+interface SerializedLocationStartChangeBase extends SerializedFeatureChange {
+  typeName: 'LocationStartChange'
+}
+
+interface LocationStartChangeDetails {
+  featureId: string
+  oldStart: number
+  newStart: number
+}
+
+interface SerializedLocationStartChangeSingle
+  extends SerializedLocationStartChangeBase,
+    LocationStartChangeDetails {}
+
+interface SerializedLocationStartChangeMultiple
+  extends SerializedLocationStartChangeBase {
+  changes: LocationStartChangeDetails[]
+}
+
+type SerializedLocationStartChange =
+  | SerializedLocationStartChangeSingle
+  | SerializedLocationStartChangeMultiple
+
+export class LocationStartChange extends FeatureChange {
+  typeName = 'LocationStartChange' as const
+  changes: LocationStartChangeDetails[]
+
+  constructor(json: SerializedLocationStartChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedLocationStartChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ featureId, newStart, oldStart }] = changes
+      return { typeName, changedIds, assembly, featureId, oldStart, newStart }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { featureModel, session } = backend
+    const { changes, logger } = this
+    const featuresForChanges: {
+      feature: Feature
+      topLevelFeature: FeatureDocument
+    }[] = []
+    // Let's first check that all features are found and those old values match with expected ones. We do this just to be sure that all changes can be done.
+    for (const change of changes) {
+      const { featureId, oldStart } = change
+
+      // 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}'`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+        // throw new NotFoundException(errMsg)  -- This is causing runtime error because Exception comes from @nestjs/common!!!
+      }
+      logger.debug?.(`*** Feature found: ${JSON.stringify(topLevelFeature)}`)
+
+      const foundFeature = this.getFeatureFromId(topLevelFeature, featureId)
+      if (!foundFeature) {
+        const errMsg = 'ERROR when searching feature by featureId'
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      logger.debug?.(`*** Found feature: ${JSON.stringify(foundFeature)}`)
+      if (
+        foundFeature.discontinuousLocations &&
+        foundFeature.discontinuousLocations.length > 0
+      ) {
+        const errMsg =
+          'Must use "DiscontinuousLocationStartChange" to change a feature start that has discontinuous locations'
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      if (foundFeature.start !== oldStart) {
+        const errMsg = `*** ERROR: Feature's current start value ${foundFeature.start} doesn't match with expected value ${oldStart}`
+        logger.error(errMsg)
+        throw new Error(errMsg)
+      }
+      featuresForChanges.push({ feature: foundFeature, topLevelFeature })
+    }
+
+    // Let's update objects.
+    for (const [idx, change] of changes.entries()) {
+      const { newStart } = change
+      const { feature, topLevelFeature } = featuresForChanges[idx]
+      feature.start = newStart
+      if (topLevelFeature._id.equals(feature._id)) {
+        topLevelFeature.markModified('start') // Mark as modified. Without this save() -method is not updating data in database
+      } else {
+        topLevelFeature.markModified('children') // Mark as modified. Without this save() -method is not updating data in database
+      }
+
+      try {
+        await topLevelFeature.save()
+      } catch (error) {
+        logger.debug?.(`*** FAILED: ${error}`)
+        throw error
+      }
+      logger.debug?.(
+        `*** Object updated in Mongo. New object: ${JSON.stringify(
+          topLevelFeature,
+        )}`,
+      )
+    }
+  }
+
+  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}"`)
+      }
+      feature.setStart(this.changes[idx].newStart)
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger, typeName } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes].reverse().map((startChange) => ({
+      featureId: startChange.featureId,
+      oldStart: startChange.newStart,
+      newStart: startChange.oldStart,
+    }))
+    return new LocationStartChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName,
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}
+
+export function isLocationStartChange(
+  change: unknown,
+): change is LocationStartChange {
+  return (change as LocationStartChange).typeName === 'LocationStartChange'
+}