@apollo-annotation/shared 0.1.11

package/README.md

@@ -0,0 +1 @@
+# apollo-shared

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@apollo-annotation/shared",
+  "version": "0.1.11",
+  "main": "./dist/index.js",
+  "scripts": {
+    "start": "tsc --build --watch",
+    "build": "yarn clean && tsc --build",
+    "clean": "rimraf dist"
+  },
+  "dependencies": {
+    "@apollo-annotation/common": "^0.1.11",
+    "@apollo-annotation/mst": "^0.1.11",
+    "@apollo-annotation/schemas": "^0.1.11",
+    "@gmod/gff": "1.2.0",
+    "@gmod/indexedfasta": "^2.0.4",
+    "@jbrowse/core": "^2.7.0",
+    "bson-objectid": "^2.0.4",
+    "generic-filehandle": "^3.0.0",
+    "jwt-decode": "^3.1.2",
+    "regenerator-runtime": "^0.13.9",
+    "socket.io-client": "^4.5.4",
+    "tslib": "^2.3.1"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^10.1.0",
+    "@nestjs/core": "^10.1.0",
+    "@types/node": "^18.14.2",
+    "@types/rimraf": "^3",
+    "mobx": "^6.6.1",
+    "mobx-state-tree": "^5.1.7",
+    "mongoose": "^6.12.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^5.1.6"
+  },
+  "peerDependencies": {
+    "@mui/material": "^5.11.14",
+    "@mui/x-data-grid": "^7.0.0",
+    "mobx": "^6.6.1",
+    "mobx-react": "^7.2.1",
+    "mobx-state-tree": "^5.1.7",
+    "prop-types": "^15.8.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rxjs": "^7.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/Changes/AddAssemblyAndFeaturesFromFileChange.ts

@@ -0,0 +1,135 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/require-await */
+
+import {
+  AssemblySpecificChange,
+  ChangeOptions,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  SerializedAssemblySpecificChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { GFF3Feature } from '@gmod/gff'
+
+export interface SerializedAddAssemblyAndFeaturesFromFileChangeBase
+  extends SerializedAssemblySpecificChange {
+  typeName: 'AddAssemblyAndFeaturesFromFileChange'
+}
+
+export interface AddAssemblyAndFeaturesFromFileChangeDetails {
+  assemblyName: string
+  fileId: string
+}
+
+export interface SerializedAddAssemblyAndFeaturesFromFileChangeSingle
+  extends SerializedAddAssemblyAndFeaturesFromFileChangeBase,
+    AddAssemblyAndFeaturesFromFileChangeDetails {}
+
+export interface SerializedAddAssemblyAndFeaturesFromFileChangeMultiple
+  extends SerializedAddAssemblyAndFeaturesFromFileChangeBase {
+  changes: AddAssemblyAndFeaturesFromFileChangeDetails[]
+}
+
+export type SerializedAddAssemblyAndFeaturesFromFileChange =
+  | SerializedAddAssemblyAndFeaturesFromFileChangeSingle
+  | SerializedAddAssemblyAndFeaturesFromFileChangeMultiple
+
+export class AddAssemblyAndFeaturesFromFileChange extends AssemblySpecificChange {
+  typeName = 'AddAssemblyAndFeaturesFromFileChange' as const
+  changes: AddAssemblyAndFeaturesFromFileChangeDetails[]
+
+  constructor(
+    json: SerializedAddAssemblyAndFeaturesFromFileChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  get notification(): string {
+    return `Assembly "${this.changes[0].assemblyName}" added successfully. To use it, please refresh the page.`
+  }
+
+  toJSON(): SerializedAddAssemblyAndFeaturesFromFileChange {
+    const { assembly, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ assemblyName, fileId }] = changes
+      return { typeName, assembly, assemblyName, fileId }
+    }
+    return { typeName, assembly, changes }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { assemblyModel, fileModel, filesService, user } = backend
+    const { assembly, changes, logger } = this
+    for (const change of changes) {
+      const { assemblyName, fileId } = change
+
+      const { FILE_UPLOAD_FOLDER } = process.env
+      if (!FILE_UPLOAD_FOLDER) {
+        throw new Error('No FILE_UPLOAD_FOLDER found in .env file')
+      }
+      // Get file checksum
+      const fileDoc = await fileModel.findById(fileId).exec()
+      if (!fileDoc) {
+        throw new Error(`File "${fileId}" not found in Mongo`)
+      }
+      logger.debug?.(`FileId "${fileId}", checksum "${fileDoc.checksum}"`)
+
+      // Check and add new assembly
+      const assemblyDoc = await assemblyModel
+        .findOne({ name: assemblyName })
+        .exec()
+      if (assemblyDoc) {
+        throw new Error(`Assembly "${assemblyName}" already exists`)
+      }
+      // Add assembly
+      const [newAssemblyDoc] = await assemblyModel.create([
+        { _id: assembly, name: assemblyName, user, status: -1 },
+      ])
+      logger.debug?.(
+        `Added new assembly "${assemblyName}", docId "${newAssemblyDoc._id}"`,
+      )
+      logger.debug?.(`File type: "${fileDoc.type}"`)
+
+      // Add refSeqs
+      // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+      await this.addRefSeqIntoDb(
+        fileDoc,
+        newAssemblyDoc._id.toString(),
+        backend,
+      )
+
+      // Loop all features
+      const featureStream = filesService.parseGFF3(
+        filesService.getFileStream(fileDoc),
+      )
+      for await (const f of featureStream) {
+        const gff3Feature = f as GFF3Feature
+        logger.verbose?.(`ENTRY=${JSON.stringify(gff3Feature)}`)
+        // Add new feature into database
+        await this.addFeatureIntoDb(gff3Feature, backend)
+      }
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async executeOnClient(_dataStore: ClientDataStore) {}
+
+  getInverse() {
+    const { assembly, changes, logger, typeName } = this
+    return new AddAssemblyAndFeaturesFromFileChange(
+      { typeName, changes, assembly },
+      { logger },
+    )
+  }
+}

package/src/Changes/AddAssemblyFromExternalChange.ts

@@ -0,0 +1,145 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  AssemblySpecificChange,
+  ChangeOptions,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  SerializedAssemblySpecificChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+import { BgzipIndexedFasta, IndexedFasta } from '@gmod/indexedfasta'
+import { RemoteFile } from 'generic-filehandle'
+
+export interface SerializedAddAssemblyFromExternalChangeBase
+  extends SerializedAssemblySpecificChange {
+  typeName: 'AddAssemblyFromExternalChange'
+}
+
+export interface AddAssemblyFromExternalChangeDetails {
+  assemblyName: string
+  externalLocation: { fa: string; fai: string; gzi?: string }
+}
+
+export interface SerializedAddAssemblyFromExternalChangeSingle
+  extends SerializedAddAssemblyFromExternalChangeBase,
+    AddAssemblyFromExternalChangeDetails {}
+
+export interface SerializedAddAssemblyFromExternalChangeMultiple
+  extends SerializedAddAssemblyFromExternalChangeBase {
+  changes: AddAssemblyFromExternalChangeDetails[]
+}
+
+export type SerializedAddAssemblyFromExternalChange =
+  | SerializedAddAssemblyFromExternalChangeSingle
+  | SerializedAddAssemblyFromExternalChangeMultiple
+
+export class AddAssemblyFromExternalChange extends AssemblySpecificChange {
+  typeName = 'AddAssemblyFromExternalChange' as const
+  changes: AddAssemblyFromExternalChangeDetails[]
+
+  constructor(
+    json: SerializedAddAssemblyFromExternalChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  get notification(): string {
+    return `Assembly "${this.changes[0].assemblyName}" added successfully. To use it, please refresh the page.`
+  }
+
+  toJSON(): SerializedAddAssemblyFromExternalChange {
+    const { assembly, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ assemblyName, externalLocation }] = changes
+      return { typeName, assembly, assemblyName, externalLocation }
+    }
+    return { typeName, assembly, changes }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { assemblyModel, refSeqModel, user } = backend
+    const { assembly, changes, logger } = this
+    const { CHUNK_SIZE } = process.env
+    const customChunkSize = CHUNK_SIZE && Number(CHUNK_SIZE)
+
+    for (const change of changes) {
+      const { assemblyName, externalLocation } = change
+      const { fa, fai, gzi } = externalLocation
+      const sequenceAdapter = gzi
+        ? new BgzipIndexedFasta({
+            fasta: new RemoteFile(fa, { fetch }),
+            fai: new RemoteFile(fai, { fetch }),
+            gzi: new RemoteFile(gzi, { fetch }),
+          })
+        : new IndexedFasta({
+            fasta: new RemoteFile(fa, { fetch }),
+            fai: new RemoteFile(fai, { fetch }),
+          })
+      const allSequenceSizes = await sequenceAdapter.getSequenceSizes()
+
+      if (!allSequenceSizes) {
+        throw new Error('No data read from indexed fasta getSequenceSizes')
+      }
+
+      const assemblyDoc = await assemblyModel
+        .findOne({ name: assemblyName })
+        .exec()
+      if (assemblyDoc) {
+        throw new Error(`Assembly "${assemblyName}" already exists`)
+      }
+      const [newAssemblyDoc] = await assemblyModel.create([
+        {
+          _id: assembly,
+          name: assemblyName,
+          user,
+          status: -1,
+          externalLocation,
+        },
+      ])
+      logger.debug?.(
+        `Added new assembly "${assemblyName}", docId "${newAssemblyDoc._id}"`,
+      )
+
+      for (const sequenceName in allSequenceSizes) {
+        const [newRefSeqDoc] = await refSeqModel.create([
+          {
+            name: sequenceName,
+            assembly: newAssemblyDoc._id,
+            length: allSequenceSizes[sequenceName],
+            ...(customChunkSize ? { chunkSize: customChunkSize } : null),
+            user,
+            status: -1,
+          },
+        ])
+        logger.debug?.(
+          `Added new refSeq "${sequenceName}", docId "${newRefSeqDoc._id}"`,
+        )
+      }
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async executeOnClient(_dataStore: ClientDataStore) {}
+
+  getInverse() {
+    const { assembly, changes, logger, typeName } = this
+    return new AddAssemblyFromExternalChange(
+      { typeName, changes, assembly },
+      { logger },
+    )
+  }
+}

package/src/Changes/AddAssemblyFromFileChange.ts

@@ -0,0 +1,125 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/require-await */
+import {
+  AssemblySpecificChange,
+  ChangeOptions,
+  ClientDataStore,
+  LocalGFF3DataStore,
+  SerializedAssemblySpecificChange,
+  ServerDataStore,
+} from '@apollo-annotation/common'
+
+export interface SerializedAddAssemblyFromFileChangeBase
+  extends SerializedAssemblySpecificChange {
+  typeName: 'AddAssemblyFromFileChange'
+}
+
+export interface AddAssemblyFromFileChangeDetails {
+  assemblyName: string
+  fileId: string
+}
+
+export interface SerializedAddAssemblyFromFileChangeSingle
+  extends SerializedAddAssemblyFromFileChangeBase,
+    AddAssemblyFromFileChangeDetails {}
+
+export interface SerializedAddAssemblyFromFileChangeMultiple
+  extends SerializedAddAssemblyFromFileChangeBase {
+  changes: AddAssemblyFromFileChangeDetails[]
+}
+
+export type SerializedAddAssemblyFromFileChange =
+  | SerializedAddAssemblyFromFileChangeSingle
+  | SerializedAddAssemblyFromFileChangeMultiple
+
+export class AddAssemblyFromFileChange extends AssemblySpecificChange {
+  typeName = 'AddAssemblyFromFileChange' as const
+  changes: AddAssemblyFromFileChangeDetails[]
+
+  constructor(
+    json: SerializedAddAssemblyFromFileChange,
+    options?: ChangeOptions,
+  ) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  get notification(): string {
+    return `Assembly "${this.changes[0].assemblyName}" added successfully. To use it, please refresh the page.`
+  }
+
+  toJSON(): SerializedAddAssemblyFromFileChange {
+    const { assembly, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ assemblyName, fileId }] = changes
+      return { typeName, assembly, assemblyName, fileId }
+    }
+    return { typeName, assembly, changes }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { assemblyModel, fileModel, user } = backend
+    const { assembly, changes, logger } = this
+
+    for (const change of changes) {
+      const { assemblyName, fileId } = change
+
+      const { FILE_UPLOAD_FOLDER } = process.env
+      if (!FILE_UPLOAD_FOLDER) {
+        throw new Error('No FILE_UPLOAD_FOLDER found in .env file')
+      }
+      // Get file checksum
+      const fileDoc = await fileModel.findById(fileId).exec()
+      if (!fileDoc) {
+        throw new Error(`File "${fileId}" not found in Mongo`)
+      }
+      logger.debug?.(`FileId "${fileId}", checksum "${fileDoc.checksum}"`)
+
+      // Check and add new assembly
+      const assemblyDoc = await assemblyModel
+        .findOne({ name: assemblyName })
+        .exec()
+      if (assemblyDoc) {
+        throw new Error(`Assembly "${assemblyName}" already exists`)
+      }
+      // Add assembly
+      const [newAssemblyDoc] = await assemblyModel.create([
+        { _id: assembly, name: assemblyName, user, status: -1 },
+      ])
+      logger.debug?.(
+        `Added new assembly "${assemblyName}", docId "${newAssemblyDoc._id}"`,
+      )
+      logger.debug?.(
+        `File type: "${fileDoc.type}", assemblyId: "${newAssemblyDoc._id}"`,
+      )
+
+      // Add refSeqs
+      // We cannot use Mongo 'session' / transaction here because Mongo has 16 MB limit for transaction
+      await this.addRefSeqIntoDb(
+        fileDoc,
+        newAssemblyDoc._id.toString(),
+        backend,
+      )
+    }
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async executeOnClient(_dataStore: ClientDataStore) {}
+
+  getInverse() {
+    const { assembly, changes, logger, typeName } = this
+    return new AddAssemblyFromFileChange(
+      { typeName, changes, assembly },
+      { logger },
+    )
+  }
+}

package/src/Changes/AddFeatureChange.ts

@@ -0,0 +1,233 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* 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 { AnnotationFeatureSnapshot } from '@apollo-annotation/mst'
+
+import { DeleteFeatureChange } from './DeleteFeatureChange'
+
+interface SerializedAddFeatureChangeBase extends SerializedFeatureChange {
+  typeName: 'AddFeatureChange'
+}
+
+export interface AddFeatureChangeDetails {
+  addedFeature: AnnotationFeatureSnapshot
+  parentFeatureId?: string // Parent feature to where feature will be added
+  copyFeature?: boolean // Are we copying or adding a new child feature
+  allIds?: string[]
+}
+
+interface SerializedAddFeatureChangeSingle
+  extends SerializedAddFeatureChangeBase,
+    AddFeatureChangeDetails {}
+
+interface SerializedAddFeatureChangeMultiple
+  extends SerializedAddFeatureChangeBase {
+  changes: AddFeatureChangeDetails[]
+}
+
+type SerializedAddFeatureChange =
+  | SerializedAddFeatureChangeSingle
+  | SerializedAddFeatureChangeMultiple
+
+export class AddFeatureChange extends FeatureChange {
+  typeName = 'AddFeatureChange' as const
+  changes: AddFeatureChangeDetails[]
+
+  constructor(json: SerializedAddFeatureChange, options?: ChangeOptions) {
+    super(json, options)
+    this.changes = 'changes' in json ? json.changes : [json]
+  }
+
+  toJSON(): SerializedAddFeatureChange {
+    const { assembly, changedIds, changes, typeName } = this
+    if (changes.length === 1) {
+      const [{ addedFeature, allIds, copyFeature, parentFeatureId }] = changes
+      return {
+        typeName,
+        changedIds,
+        assembly,
+        addedFeature,
+        parentFeatureId,
+        copyFeature,
+        allIds,
+      }
+    }
+    return { typeName, changedIds, assembly, changes }
+  }
+
+  /**
+   * Applies the required change to database
+   * @param backend - parameters from backend
+   * @returns
+   */
+  async executeOnServer(backend: ServerDataStore) {
+    const { assemblyModel, featureModel, refSeqModel, session, user } = backend
+    const { assembly, changes, logger } = this
+
+    const assemblyDoc = await assemblyModel
+      .findById(assembly)
+      .session(session)
+      .exec()
+    if (!assemblyDoc) {
+      const errMsg = `*** ERROR: Assembly with id "${assembly}" not found`
+      logger.error(errMsg)
+      throw new Error(errMsg)
+    }
+
+    let featureCnt = 0
+    logger.debug?.(`changes: ${JSON.stringify(changes)}`)
+
+    // Loop the changes
+    for (const change of changes) {
+      logger.debug?.(`change: ${JSON.stringify(change)}`)
+      const { addedFeature, allIds, copyFeature, parentFeatureId } = change
+      const { _id, refSeq } = addedFeature
+      const refSeqDoc = await refSeqModel
+        .findById(refSeq)
+        .session(session)
+        .exec()
+      if (!refSeqDoc) {
+        throw new Error(
+          `RefSeq was not found by assembly "${assembly}" and seq_id "${refSeq}" not found`,
+        )
+      }
+
+      // CopyFeature is called from CopyFeature.tsx
+      if (copyFeature) {
+        // Add into Mongo
+        const [newFeatureDoc] = await featureModel.create(
+          [{ ...addedFeature, allIds, status: -1, user }],
+          { session },
+        )
+        logger.debug?.(
+          `Copied feature, docId "${newFeatureDoc._id}" to assembly "${assembly}"`,
+        )
+        featureCnt++
+      } else {
+        addedFeature.gffId = _id // User added manually new feature so then gffId = _id
+        // Adding new child feature
+        if (parentFeatureId) {
+          const topLevelFeature = await featureModel
+            .findOne({ allIds: parentFeatureId })
+            .session(session)
+            .exec()
+          if (!topLevelFeature) {
+            throw new Error(
+              `Could not find feature with ID "${parentFeatureId}"`,
+            )
+          }
+          const parentFeature = this.getFeatureFromId(
+            topLevelFeature,
+            parentFeatureId,
+          )
+          if (!parentFeature) {
+            throw new Error(
+              `Could not find feature with ID "${parentFeatureId}" in feature "${topLevelFeature._id}"`,
+            )
+          }
+          if (!parentFeature.children) {
+            parentFeature.children = new Map()
+          }
+          if (!parentFeature.attributes?._id) {
+            let { attributes } = parentFeature
+            if (!attributes) {
+              attributes = {}
+            }
+            attributes = {
+              _id: [parentFeature._id.toString()],
+              ...JSON.parse(JSON.stringify(attributes)),
+            }
+            parentFeature.attributes = attributes
+          }
+          parentFeature.children.set(_id, {
+            allIds: [],
+            ...addedFeature,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            _id,
+          })
+          // Child features should be sorted for click and drag of gene glyphs to work properly
+          parentFeature.children = new Map(
+            [...parentFeature.children.entries()].sort(
+              (a, b) => a[1].start - b[1].start,
+            ),
+          )
+          const childIds = this.getChildFeatureIds(addedFeature)
+          topLevelFeature.allIds.push(_id, ...childIds)
+          await topLevelFeature.save()
+        } else {
+          const childIds = this.getChildFeatureIds(addedFeature)
+          const allIdsV2 = [_id, ...childIds]
+          const [newFeatureDoc] = await featureModel.create(
+            [{ allIds: allIdsV2, status: 0, ...addedFeature }],
+            { session },
+          )
+          logger.verbose?.(`Added docId "${newFeatureDoc._id}"`)
+        }
+      }
+      featureCnt++
+    }
+    logger.debug?.(`Added ${featureCnt} new feature(s) into database.`)
+  }
+
+  async executeOnLocalGFF3(_backend: LocalGFF3DataStore) {
+    throw new Error('executeOnLocalGFF3 not implemented')
+  }
+
+  async executeOnClient(dataStore: ClientDataStore) {
+    if (!dataStore) {
+      throw new Error('No data store')
+    }
+    const { assembly, changes } = this
+    for (const change of changes) {
+      const { addedFeature, parentFeatureId } = change
+      if (parentFeatureId) {
+        const parentFeature = dataStore.getFeature(parentFeatureId)
+        if (!parentFeature) {
+          throw new Error(`Could not find parent feature "${parentFeatureId}"`)
+        }
+        // create an ID for the parent feature if it does not have one
+        if (!parentFeature.attributes.get('_id')) {
+          parentFeature.setAttribute('_id', [parentFeature._id])
+        }
+        parentFeature.addChild(addedFeature)
+      } else {
+        dataStore.addFeature(assembly, addedFeature)
+      }
+    }
+  }
+
+  getInverse() {
+    const { assembly, changedIds, changes, logger } = this
+    const inverseChangedIds = [...changedIds].reverse()
+    const inverseChanges = [...changes].reverse().map((addFeatureChange) => ({
+      deletedFeature: addFeatureChange.addedFeature,
+      parentFeatureId: addFeatureChange.parentFeatureId,
+    }))
+
+    return new DeleteFeatureChange(
+      {
+        changedIds: inverseChangedIds,
+        typeName: 'DeleteFeatureChange',
+        changes: inverseChanges,
+        assembly,
+      },
+      { logger },
+    )
+  }
+}
+
+export function isAddFeatureChange(
+  change: unknown,
+): change is AddFeatureChange {
+  return (change as AddFeatureChange).typeName === 'AddFeatureChange'
+}