anear-js-api 0.3.35 → 0.3.37

package/lib/messaging/AnearMessaging.js

@@ -82,11 +82,7 @@ class AnearMessaging {
   }
 
   async getAnearEventFromStorage(eventId) {
-    return await this.AnearEventClass.getFromStorage(eventId, this.AnearParticipantClass, this)
-  }
-
-  async getAnearParticipantFromStorage(participantId, anearEvent) {
-    return await this.AnearParticipantClass.getFromStorage(participantId, anearEvent)
+    return await this.AnearEventClass.getFromStorage(eventId, this)
   }
 
   async initEventRealtimeMessaging(anearEvent) {
@@ -121,47 +117,41 @@ class AnearMessaging {
 
     try {
       const eventJson = JSON.parse(message.data)
-      const anearEvent = new this.AnearEventClass(eventJson, this.AnearParticipantClass, this)
+      const anearEvent = new this.AnearEventClass(eventJson, this)
 
       //
       // if we are getting this event create message from history after a quick restart,
       // we just return if the event already exists
       //
-      await this.loadOrPersistEventAndInitialize(anearEvent)
-
-    } catch(err) {
-      logger.error(err)
-    }
-  }
-
-  async loadOrPersistEventAndInitialize(anearEvent) {
-    const eventExists = await anearEvent.exists()
+      const eventExists = await anearEvent.exists()
+
+      logger.info(`Event ${anearEvent.id} ${eventExists ? "already exists" : "does not exist"} in Storage`)
+
+      let loadedEvent = anearEvent
+
+      if (!eventExists) {
+        await anearEvent.runExclusive(`createEventCallback ${anearEvent.id}`, async () => {
+          await anearEvent.createdEventCallback()
+          await anearEvent.persist()
+          // start the state machine before initialiing Realtime Messaging
+          // as REFRESH events come in and the state machine should be ready
+          // to handle those XState events
+          anearEvent.startStateMachine()
+          await this.initEventRealtimeMessaging(anearEvent)
+        })
+      } else {
+        loadedEvent = await this.getAnearEventFromStorage(anearEvent.id)
+        await this.initEventRealtimeMessaging(loadedEvent)
+        loadedEvent.startStateMachine()
+      }
 
-    logger.info(`Event ${anearEvent.id} ${eventExists ? "already exists" : "does not exist"} in Storage`)
+      logger.info(`New ${loadedEvent.constructor.name} Event: `, loadedEvent.toJSON())
 
-    let loadedEvent = anearEvent
+      this.anearEvents[loadedEvent.id] = loadedEvent
 
-    if (!eventExists) {
-      await anearEvent.runExclusive(`createEventCallback ${anearEvent.id}`, async () => {
-        await anearEvent.createdEventCallback()
-        await anearEvent.persist()
-        // start the state machine before initialiing Realtime Messaging
-        // as REFRESH events come in and the state machine should be ready
-        // to handle those XState events
-        anearEvent.startStateMachine()
-        await this.initEventRealtimeMessaging(anearEvent)
-      })
-    } else {
-      loadedEvent = await this.getAnearEventFromStorage(anearEvent.id)
-      await this.initEventRealtimeMessaging(loadedEvent)
-      loadedEvent.startStateMachine()
+    } catch(err) {
+      logger.error(err)
     }
-
-    logger.info(`New ${loadedEvent.constructor.name} Event: `, loadedEvent.toJSON())
-
-    this.anearEvents[loadedEvent.id] = loadedEvent
-
-    return loadedEvent
   }
 
   async reloadAnyEventsInProgress(appId) {
@@ -173,14 +163,16 @@ class AnearMessaging {
 
         for (const eventData of events) {
           const eventJson = await this.api.getEvent(eventData.id)
-          const anearEvent = new this.AnearEventClass(eventJson, this.AnearParticipantClass, this)
-          // This needs work!!
-          // loadedEvent = await this.getAnearEventFromStorage(anearEvent.id)
-          // NOTE: there should be existing presence state to read from action channel
-          // to drive this...not a reload from storage
-          // await this.refreshActiveParticipants(loadedEvent)
-          //  await this.initEventRealtimeMessaging(loadedEvent)
-          //  loadedEvent.startStateMachine()
+          const anearEvent = new this.AnearEventClass(eventJson, this)
+          await this.initEventRealtimeMessaging(anearEvent)
+
+          const attachedParticipants = this.getPresentParticipants(anearEvent)
+          // TBD: might want to change the attach and presence logic on
+          // the actions channel.   The Ably docs show subscribing to the
+          // presence events on the actions channel, and instead of using History,
+          // it does a get() to fetch all of the current members.   This behavior
+          // is useful for both event start, and event restart within this function
+          // anearEvent.startStateMachine()
           //
         }
       }
@@ -189,12 +181,6 @@ class AnearMessaging {
     }
   }
 
-  async refreshActiveParticipants(anearEvent) {
-    await this.participants.reloadFromStorage(
-      p => this.processParticipantEnter(anearEvent, p.id)
-    )
-  }
-
   async setupCreateEventChannel() {
     logger.info(`attaching to channel ${AnearCreateEventChannelName}`)
 
@@ -242,6 +228,13 @@ class AnearMessaging {
     return members.length
   }
 
+  async getPresentParticipants(anearEvent) {
+    // returns the participant presence data for each member who is present on
+    // the event's actions channel
+    const channel = this.eventChannels[anearEvent.id].actions
+    return await channel.presence.get()
+  }
+
   async setupActionsChannel(anearEvent) {
     const actionsChannel = this.getChannel(anearEvent.actionsChannelName())
 
@@ -340,7 +333,7 @@ class AnearMessaging {
       const participantJson = await this.api.getEventParticipantJson(participantId)
       const participant = new this.AnearParticipantClass(participantJson, anearEvent)
 
-      const persistedAnearParticipant = await this.getAnearParticipantFromStorage(participantId, anearEvent)
+      const persistedAnearParticipant = await this.AnearParticipantClass.getFromStorage(participantId, anearEvent)
 
       if (persistedAnearParticipant) {
         participant.context = persistedAnearParticipant.context
@@ -375,15 +368,12 @@ class AnearMessaging {
   }
 
   async participantLeaveMessagingCallback(anearEvent, message) {
-    // this can be just a temporary leave (a participant refreshing their browser for example),
-    // so pause any participant timers
+    // this can be just a temporary leave from a participant refreshing their browser.
+    // currently, no action taken
     const userId = message.clientId
     const participantId = message.data.id
-    const participant = anearEvent.participants.getById(participantId)
-
-    logger.debug(`**** LEAVE PARTICIPANT ****  participantLeaveMessagingCallback(participant: ${participant.id})`)
 
-    participant.interruptTimer()
+    logger.debug(`**** LEAVE PARTICIPANT ****  participantLeaveMessagingCallback(participant: ${participantId})`)
   }
 
   async closeParticipant(anearEvent, participantId, callback = null) {

package/lib/models/AnearEvent.js

@@ -13,11 +13,10 @@ const PrivateDisplayMessageType  = 'private_display'
 
 class AnearEvent extends JsonApiResource {
 
-  constructor(json, anearParticipantClass, messaging) {
+  constructor(json, messaging) {
     super(json)
     this.zone = this.findIncluded(this.relationships.zone)
     this.app = this.findIncluded(this.zone.relationships.app)
-    this.anearParticipantClass = anearParticipantClass
     this.messaging = messaging
     this.anearStateMachine = this.initStateMachine(json.previousState)
     this.participants = new Participants(this, json.participants)
@@ -256,10 +255,6 @@ class AnearEvent extends JsonApiResource {
     this.anearStateMachine.sendTimeoutEvent({ participant })
   }
 
-  cancelParticipantTimers() {
-    this.messaging.resetAllParticipantTimers()
-  }
-
   async eventBroadcast(message) {
     await this.eventBroadcastEventCallback(message)
   }
@@ -339,14 +334,6 @@ class AnearEvent extends JsonApiResource {
     )
   }
 
-  async reloadParticipantsFromStorage() {
-    // rehydrate the anearEvent participants and host from storage
-    const participants = await Promise.all(
-      this.participants.ids.map(pid => this.anearParticipantClass.getFromStorage(pid, this))
-    )
-    this.participants.load(participants)
-  }
-
   eventChannelName () {
     return this.getChannelName('event')
   }

package/lib/utils/Participants.js

@@ -26,7 +26,6 @@ class Participants {
 
   toJSON() {
     return {
-      // only output the active participant ids.
       ids: this.all.map(p => p.id),
       idleMsecs: this.idleMsecs,
       purgeMsecs: this.purgeMsecs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anear-js-api",
-  "version": "0.3.35",
+  "version": "0.3.37",
   "description": "Javascript Developer API for Anear Apps",
   "main": "lib/index.js",
   "scripts": {

package/tests/AnearEvent.test.js

@@ -331,11 +331,13 @@ test('can be retrieved back from storage with participants, not hosted', async (
   await testEvent.participantEnter(p2)
   await testEvent.persist()
 
-  const rehydratedTestEvent = await TestEvent.getFromStorage(testEvent.id, TestPlayer, MessagingStub)
-  await rehydratedTestEvent.reloadParticipantsFromStorage()
+  const rehydratedTestEvent = await TestEvent.getFromStorage(testEvent.id, MessagingStub)
 
   rehydratedTestEvent.startStateMachine()
 
+  await rehydratedTestEvent.participantEnter(p1)
+  await rehydratedTestEvent.participantEnter(p2)
+
   expect(rehydratedTestEvent.participants.numActive).toBe(2)
   expect(rehydratedTestEvent.id).toBe(testEvent.id)
   expect(rehydratedTestEvent.relationships['user'].data.type).toBe("users")
@@ -382,23 +384,3 @@ test('can update state machine context via Action events', async () => {
   await t.closeOutParticipants()
   await t.remove()
 })
-
-test('can reset All ParticipantTimers', async () => {
-  const t = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1, t)
-  const p2 = new TestPlayer(chatParticipant2, t)
-
-  const resetMock = jest.spyOn(MessagingStub, "resetAllParticipantTimers");
-
-  await t.participantEnter(p1)
-  await t.participantEnter(p2)
-  await t.persist()
-
-  t.cancelParticipantTimers()
-
-  expect(resetMock).toHaveBeenCalledTimes(1)
-
-  await t.participantExit(p1)
-  await t.participantExit(p2)
-  await t.remove()
-})