Broadcast check result changes

packages/apollo-collaboration-server/src/changes/changes.service.ts

@@ -26,6 +26,7 @@ import {
   UserDocument,
 } from 'apollo-schemas'
 import {
+  ChangeMessage,
   DecodedJWT,
   makeUserSessionId,
   validationRegistry,
@@ -34,7 +35,6 @@ import { FilterQuery, Model } from 'mongoose'
 
 import { CountersService } from '../counters/counters.service'
 import { FilesService } from '../files/files.service'
-import { ChangeMessage } from '../messages/entities/message.entity'
 import { MessagesGateway } from '../messages/messages.gateway'
 import { PluginsService } from '../plugins/plugins.service'
 import { FindChangeDto } from './dto/find-change.dto'

packages/apollo-collaboration-server/src/checks/checks.controller.ts

@@ -1,10 +1,12 @@
 import { Controller, Get, Logger, Param, Query } from '@nestjs/common'
 
 import { FeatureRangeSearchDto } from '../entity/gff3Object.dto'
+import { Public } from '../utils/jwt-auth.guard'
 import { Role } from '../utils/role/role.enum'
 import { Validations } from '../utils/validation/validatation.decorator'
 import { ChecksService } from './checks.service'
 
+@Public()
 @Controller('checks')
 export class ChecksController {
   constructor(private readonly checksService: ChecksService) {}

packages/apollo-collaboration-server/src/checks/checks.module.ts

@@ -1,29 +1,93 @@
 import { Module } from '@nestjs/common'
 import { MongooseModule, getConnectionToken } from '@nestjs/mongoose'
+import { CheckResultSnapshot } from 'apollo-mst'
 import {
   Check,
   CheckResult,
+  CheckResultDocument,
   CheckResultSchema,
   CheckSchema,
 } from 'apollo-schemas'
+import { CheckResultUpdate } from 'apollo-shared'
 import idValidator from 'mongoose-id-validator'
 
+import { MessagesGateway } from '../messages/messages.gateway'
+import { MessagesModule } from '../messages/messages.module'
 import { RefSeqsModule } from '../refSeqs/refSeqs.module'
 import { ChecksController } from './checks.controller'
 import { ChecksService } from './checks.service'
 
 @Module({
   providers: [ChecksService],
   imports: [
+    MessagesModule,
     RefSeqsModule,
     MongooseModule.forFeatureAsync([
       {
         name: CheckResult.name,
-        useFactory: (connection) => {
+        useFactory: (connection, messagesGateway: MessagesGateway) => {
           CheckResultSchema.plugin(idValidator, { connection })
+          const broadcast = async (
+            doc: CheckResultDocument | CheckResultSnapshot,
+          ) => {
+            const message: CheckResultUpdate = {
+              channel: 'COMMON',
+              userName: 'none',
+              userSessionId: 'none',
+              checkResult: 'toJSON' in doc ? doc.toJSON() : doc,
+            }
+            await messagesGateway.create(message.channel, message)
+          }
+          const broadcastDeletion = async (doc: CheckResultDocument) => {
+            const message: CheckResultUpdate = {
+              channel: 'COMMON',
+              userName: 'none',
+              userSessionId: 'none',
+              checkResult: doc.toJSON(),
+              deleted: true,
+            }
+            await messagesGateway.create(message.channel, message)
+          }
+          CheckResultSchema.post('save', broadcast)
+          CheckResultSchema.post('updateOne', broadcast)
+          CheckResultSchema.post('remove', broadcastDeletion)
+          CheckResultSchema.post('deleteOne', broadcastDeletion)
+          CheckResultSchema.pre('findOneAndUpdate', async function () {
+            const checkResults = await this.model.find<CheckResultDocument>(
+              this.getQuery(),
+            )
+            for (const checkResult of checkResults) {
+              await broadcast(checkResult)
+            }
+          })
+          CheckResultSchema.pre(
+            'insertMany',
+            async function (_result, checkResults) {
+              for (const checkResult of checkResults) {
+                await broadcast(checkResult)
+              }
+            },
+          )
+          CheckResultSchema.pre('findOneAndDelete', async function () {
+            const checkResults = await this.model.find<CheckResultDocument>(
+              this.getQuery(),
+            )
+            for (const checkResult of checkResults) {
+              await broadcastDeletion(checkResult)
+            }
+          })
+          CheckResultSchema.pre('deleteMany', async function () {
+            const checkResults = await this.model.find<CheckResultDocument>(
+              this.getQuery(),
+            )
+            for (const checkResult of checkResults) {
+              await broadcastDeletion(checkResult)
+            }
+          })
           return CheckResultSchema
         },
-        inject: [getConnectionToken()],
+        imports: [MessagesModule],
+        inject: [getConnectionToken(), MessagesGateway],
       },
       { name: Check.name, useFactory: () => CheckSchema },
     ]),

packages/apollo-collaboration-server/src/checks/checks.service.ts

@@ -190,14 +190,10 @@ export class ChecksService {
       })
       .exec()
   }
-  // async checkFeature(doc: FeatureDocument) {
-  //   const featureModel = doc.$model<Model<FeatureDocument>>(Feature.name)
-  //   this.logger.debug(`Feature Model: ${featureModel}`)
-  //   const features = await featureModel.find().exec()
-  //   this.logger.log(features[0])
-  //   const refSeqModel = doc.$model(RefSeq.name)
-  //   this.logger.debug(`RefSeq Model: ${refSeqModel}`)
-  //   const refSeqs = await refSeqModel.find().exec()
-  //   this.logger.log(refSeqs[0])
-  // }
+
+  update(id: string, updatedCheckReport: CheckDocument) {
+    return this.checkResultModel
+      .findByIdAndUpdate(id, updatedCheckReport)
+      .exec()
+  }
 }

packages/apollo-collaboration-server/src/users/users.service.ts

@@ -2,13 +2,14 @@ import { Injectable, Logger } from '@nestjs/common'
 import { ConfigService } from '@nestjs/config'
 import { InjectModel } from '@nestjs/mongoose'
 import { UserDocument, User as UserSchema } from 'apollo-schemas'
-import { DecodedJWT, makeUserSessionId } from 'apollo-shared'
-import { Model } from 'mongoose'
-
 import {
+  DecodedJWT,
   RequestUserInformationMessage,
   UserLocationMessage,
-} from '../messages/entities/message.entity'
+  makeUserSessionId,
+} from 'apollo-shared'
+import { Model } from 'mongoose'
+
 import { MessagesGateway } from '../messages/messages.gateway'
 import { GUEST_USER_EMAIL, GUEST_USER_NAME } from '../utils/constants'
 import { Role } from '../utils/role/role.enum'
@@ -101,7 +102,7 @@ export class UsersService {
    * @param userLocation - user's location information
    * @param token - user's token, email will be decoded from the token
    */
-  broadcastLocation(userLocation: UserLocationDto[], user: DecodedJWT) {
+  broadcastLocation(userLocations: UserLocationDto[], user: DecodedJWT) {
     const broadcast = this.configService.get('BROADCAST_USER_LOCATION', {
       infer: true,
     })
@@ -113,7 +114,11 @@ export class UsersService {
     const { email, username: userName } = user
     const userSessionId = makeUserSessionId(user)
     const msg: UserLocationMessage = {
-      locations: userLocation,
+      locations: userLocations.map((location) => ({
+        ...location,
+        start: Number(location.start),
+        end: Number(location.end),
+      })),
       channel,
       userName,
       userSessionId,

packages/apollo-collaboration-server/src/messages/entities/message.entity.ts → packages/apollo-shared/src/Messages.ts

@@ -1,4 +1,5 @@
 import { SerializedChange } from 'apollo-common'
+import { CheckResultSnapshot } from 'apollo-mst'
 
 interface BaseMessage {
   channel: string
@@ -10,12 +11,16 @@ 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: string
-  end: string
+  start: number
+  end: number
 }
 
 export interface UserLocationMessage extends BaseMessage {

packages/apollo-shared/src/index.ts

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

packages/jbrowse-plugin-apollo/src/ApolloInternetAccount/model.ts

@@ -9,7 +9,15 @@ import {
 } from '@jbrowse/core/util'
 import type AuthenticationPlugin from '@jbrowse/plugin-authentication'
 import { Change } from 'apollo-common'
-import { getDecodedToken, makeUserSessionId } from 'apollo-shared'
+import {
+  ChangeMessage,
+  CheckResultUpdate,
+  RequestUserInformationMessage,
+  UserLocation,
+  UserLocationMessage,
+  getDecodedToken,
+  makeUserSessionId,
+} from 'apollo-shared'
 import { autorun } from 'mobx'
 import { Instance, flow, getRoot, types } from 'mobx-state-tree'
 import { io } from 'socket.io-client'
@@ -35,13 +43,6 @@ type AuthType = 'google' | 'microsoft' | 'guest'
 
 type Role = 'admin' | 'user' | 'readOnly'
 
-export interface UserLocation {
-  assemblyId: string
-  refSeq: string
-  start: number
-  end: number
-}
-
 const inWebWorker = typeof sessionStorage === 'undefined'
 
 const stateModelFactory = (
@@ -151,25 +152,36 @@ const stateModelFactory = (
           throw new Error('No Token found')
         }
         const { socket } = self
-        const { changeManager } = (session as ApolloSessionModel)
-          .apolloDataStore
-        socket.on('COMMON', (message) => {
+        const { addCheckResult, changeManager, deleteCheckResult } = (
+          session as ApolloSessionModel
+        ).apolloDataStore
+        socket.on('connect', async () => {
+          await this.getMissingChanges()
+        })
+        socket.on('connect_error', () => {
+          notify('Could not connect to the Apollo server.', 'error')
+        })
+        socket.on('COMMON', (message: ChangeMessage | CheckResultUpdate) => {
+          if ('checkResult' in message) {
+            if (message.deleted) {
+              deleteCheckResult(message.checkResult._id.toString())
+            } else {
+              addCheckResult(message.checkResult)
+            }
+            return
+          }
           // Save server last change sequence into session storage
-          sessionStorage.setItem('LastChangeSequence', message.changeSequence)
-          if (message.userToken === token) {
+          sessionStorage.setItem(
+            'LastChangeSequence',
+            String(message.changeSequence),
+          )
+          if (message.userSessionId === token) {
             return // we did this change, no need to apply it again
           }
           const change = Change.fromJSON(message.changeInfo)
           void changeManager?.submit(change, { submitToBackend: false })
         })
-        socket.on('reconnect', async () => {
-          notify('You are re-connected to the Apollo server.', 'success')
-          await this.getMissingChanges()
-        })
-        socket.on('disconnect', () => {
-          notify('You are disconnected from the Apollo server.', 'error')
-        })
-        socket.on('USER_LOCATION', (message) => {
+        socket.on('USER_LOCATION', (message: UserLocationMessage) => {
           const { channel, locations, userName, userSessionId } = message
           const user = getDecodedToken(token)
           const localSessionId = makeUserSessionId(user)
@@ -182,17 +194,20 @@ const stateModelFactory = (
             session.addOrUpdateCollaborator(collaborator)
           }
         })
-        socket.on('REQUEST_INFORMATION', (message) => {
-          const { channel, reqType, userToken } = message
-          if (channel === 'REQUEST_INFORMATION' && userToken !== token) {
-            switch (reqType) {
-              case 'CURRENT_LOCATION': {
-                session.broadcastLocations()
-                break
+        socket.on(
+          'REQUEST_INFORMATION',
+          (message: RequestUserInformationMessage) => {
+            const { channel, reqType, userSessionId } = message
+            if (channel === 'REQUEST_INFORMATION' && userSessionId !== token) {
+              switch (reqType) {
+                case 'CURRENT_LOCATION': {
+                  session.broadcastLocations()
+                  break
+                }
               }
             }
-          }
-        })
+          },
+        )
       },
       updateLastChangeSequenceNumber: flow(
         function* updateLastChangeSequenceNumber() {

packages/jbrowse-plugin-apollo/src/BackendDrivers/CollaborationServerDriver.ts

@@ -1,9 +1,9 @@
 import { getConf } from '@jbrowse/core/configuration'
 import { BaseInternetAccountModel } from '@jbrowse/core/pluggableElementTypes'
 import { Region, getSession } from '@jbrowse/core/util'
-import { AssemblySpecificChange, Change, SerializedChange } from 'apollo-common'
+import { AssemblySpecificChange, Change } from 'apollo-common'
 import { AnnotationFeatureSnapshot, CheckResultSnapshot } from 'apollo-mst'
-import { ValidationResultSet } from 'apollo-shared'
+import { ChangeMessage, ValidationResultSet } from 'apollo-shared'
 import { Socket } from 'socket.io-client'
 
 import { ChangeManager, SubmitOpts } from '../ChangeManager'
@@ -117,35 +117,17 @@ export class CollaborationServerDriver extends BackendDriver {
     const token = internetAccount.retrieveToken()
     const channel = `${assembly}-${refSeq}`
     const changeManager = new ChangeManager(this.clientStore)
-    const session = getSession(this.clientStore)
-    const { notify } = session
 
     if (!socket.hasListeners(channel)) {
-      socket.on(
-        channel,
-        async (message: {
-          changeSequence: string
-          userToken: string
-          channel: string
-          changeInfo: SerializedChange
-          userName: string
-        }) => {
-          // Save server last change sequence into session storage
-          internetAccount.setLastChangeSequenceNumber(
-            Number(message.changeSequence),
-          )
-          if (message.userToken !== token && message.channel === channel) {
-            const change = Change.fromJSON(message.changeInfo)
-            await changeManager.submit(change, { submitToBackend: false })
-          }
-        },
-      )
-      socket.on('reconnect', () => {
-        notify('You are re-connected to the Apollo server.', 'success')
-        internetAccount.getMissingChanges()
-      })
-      socket.on('disconnect', () => {
-        notify('You are disconnected from the Apollo server.', 'error')
+      socket.on(channel, async (message: ChangeMessage) => {
+        // Save server last change sequence into session storage
+        internetAccount.setLastChangeSequenceNumber(
+          Number(message.changeSequence),
+        )
+        if (message.userSessionId !== token && message.channel === channel) {
+          const change = Change.fromJSON(message.changeInfo)
+          await changeManager.submit(change, { submitToBackend: false })
+        }
       })
     }
   }

packages/jbrowse-plugin-apollo/src/session/ClientDataStore.ts

@@ -107,6 +107,9 @@ export function clientDataStoreFactory(
           }
         }
       },
+      deleteCheckResult(checkResultId: string) {
+        self.checkResults.delete(checkResultId)
+      },
     }))
     .volatile((self) => ({
       changeManager: new ChangeManager(self as unknown as ClientDataStoreType),