anear-js-api 0.3.26 → 0.3.29

package/lib/index.js

@@ -2,7 +2,8 @@
 
 const JsonApiResource = require('./models/JsonApiResource')
 const JsonApiArrayResource = require('./models/JsonApiArrayResource')
-const {AnearEvent, logger} = require('./models/AnearEvent')
+const AnearEvent = require('./models/AnearEvent')
+const logger = require('./utils/Logger')
 const AnearParticipant = require('./models/AnearParticipant')
 const AnearMessaging = require('./messaging/AnearMessaging')
 const AnearApiService = require('./api/ApiService')

package/lib/messaging/AnearMessaging.js

@@ -385,7 +385,7 @@ class AnearMessaging {
     await this.closeParticipant(
       anearEvent,
       participantId,
-      (anearEvent, participant) => anearEvent.participantClose(participant)
+      (anearEvent, participant) => anearEvent.participantExit(participant)
     )
   }
 
@@ -451,7 +451,7 @@ class AnearMessaging {
   }
 
   async participantLeaveMessagingCallback(anearEvent, message) {
-    // this can be just a temporary leave (refresh browser for example), so pause any participant timers
+    // this can be just a temporary leave (a participant refreshing their browser for example), so pause any participant timers
     const userId = message.clientId
     const participantId = message.data.id
 
@@ -460,7 +460,11 @@ class AnearMessaging {
     this.interruptParticipantTimer(participantId)
   }
 
-  async closeParticipant(anearEvent, participantId, callback) {
+  async closeParticipant(anearEvent, participantId, callback = null) {
+    // closes out a single Participant.   This is invoked when a single
+    // participant leaves an event, and the event may possibly continue,
+    // or possibly exit.  Or this may be called by the event when exiting
+    // and cleaning out any remaining participants.
     logger.debug(`closeParticipant(${participantId})`)
 
     this.destroyParticipantTimer(participantId)
@@ -471,7 +475,9 @@ class AnearMessaging {
       await this.detachParticipantPrivateChannel(anearEvent.id, participant)
 
       await this.runExclusive("closeParticipant", async () => {
-        await callback(anearEvent, participant)
+        if (callback) {
+          await callback(anearEvent, participant)
+        }
         await anearEvent.update()
       })
     }

package/lib/models/AnearEvent.js

@@ -140,8 +140,8 @@ class AnearEvent extends JsonApiResource {
     // You may implement an async spectatorRefreshEventCallback() in your AnearEvent sub-class
   }
 
-  async participantCloseEventCallback(participant) {
-    throw new Error('You must implement an async participantCloseEventCallback() in your AnearEvent sub-class');
+  async participantExitEventCallback(participant) {
+    throw new Error('You must implement an async participantExitEventCallback() in your AnearEvent sub-class');
   }
 
   async participantActionEventCallback(participant, actionEventName, message) {
@@ -221,11 +221,11 @@ class AnearEvent extends JsonApiResource {
     }
   }
 
-  async participantClose(participant) {
+  async participantExit(participant) {
+    // this informs the state machine that the participant has exited the event
+    // and removes that participant completely
+    this.anearStateMachine.sendParticipantExitEvent({ participant })
     this.participants.purge(participant)
-
-    this.anearStateMachine.sendCloseEvent({ participant })
-
     await participant.remove()
   }
 
@@ -285,15 +285,29 @@ class AnearEvent extends JsonApiResource {
   }
 
   async transitionClosed() {
-    this.cancelParticipantTimers()
+    await this.closeOutParticipants()
     await this.transitionNextNext()
   }
 
   async transitionCanceled() {
-    this.cancelParticipantTimers()
+    await this.closeOutParticipants()
     await this.transitionEvent('cancel')
   }
 
+  async closeOutParticipants() {
+    // upon exiting the event, this will clean up
+    // any participants remaining
+    return Promise.all(
+      this.participants.all.map(
+        async participant => {
+          await this.messaging.closeParticipant(this, participant.id)
+          await participant.remove()
+          this.participants.purge(participant)
+        }
+      )
+    )
+  }
+
   eventChannelName () {
     return this.getChannelName('event')
   }
@@ -327,7 +341,4 @@ class AnearEvent extends JsonApiResource {
   }
 }
 
-module.exports = {
-  AnearEvent,
-  logger
-}
+module.exports = AnearEvent

package/lib/utils/AnearXstate.js

@@ -4,8 +4,9 @@ const { createMachine, interpret, State } = require('xstate')
 const logger = require('../utils/Logger')
 
 const JoinEvent = 'JOIN'
+const ParticipantExitEvent = 'PARTICIPANT_EXIT'
 const RefreshEvent = 'REFRESH'
-const CloseEvent = 'CLOSE'
+const CloseEvent = 'EVENT_CLOSE'
 const TimeoutEvent = 'TIMEOUT'
 
 class AnearXstate {
@@ -50,6 +51,10 @@ class AnearXstate {
     this.send(CloseEvent, params)
   }
 
+  sendParticipantExitEvent(params) {
+    this.send(ParticipantExitEvent, params)
+  }
+
   sendTimeoutEvent(params) {
     this.send(TimeoutEvent, params)
   }

package/lib/utils/AnearXstateDefaults.js

@@ -35,8 +35,8 @@ const DefaultConfigFunc = (anearEvent) => {
           REFRESH: {
             target: 'refresh'
           },
-          CLOSE: {
-            target: 'close'
+          PARTICIPANT_EXIT: {
+            target: 'participant_exit'
           },
           TIMEOUT: {
             target: 'timeout'
@@ -62,10 +62,10 @@ const DefaultConfigFunc = (anearEvent) => {
           ...PromiseResolveReject
         }
       },
-      close: {
+      participant_exit: {
         invoke: {
-          id: 'close',
-          src: 'closeEventHandler',
+          id: 'participant_exit',
+          src: 'participantExitEventHandler',
           ...PromiseResolveReject
         }
       },
@@ -95,7 +95,7 @@ const DefaultOptionsFunc = anearEvent => {
     services: {
       joinEventHandler: (context, event) => anearEvent.participantEnterEventCallback(event.participant),
       refreshEventHandler: (context, event) => anearEvent.participantRefreshEventCallback(event.participant, event.remainingTimeout),
-      closeEventHandler: (context, event) => anearEvent.participantCloseEventCallback(event.participant),
+      participantExitEventHandler: (context, event) => anearEvent.participantExitEventCallback(event.participant),
       timeoutEventHandler: (context, event) => anearEvent.participantTimedOutEventCallback(event.participant),
       actionEventHandler: (context, event) => anearEvent.participantActionEventCallback(event.participant, event.type, event.payload)
     }

package/package.json

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

package/tests/AnearEvent.test.js

@@ -1,12 +1,12 @@
 "use strict"
 const { assign } = require('xstate')
-const { AnearEvent } = require('../lib/models/AnearEvent')
+const AnearEvent = require('../lib/models/AnearEvent')
 const AnearParticipant = require('../lib/models/AnearParticipant')
 const MockMessaging = require('../lib/messaging/__mocks__/AnearMessaging')
 
 const mockParticipantEnterHandler = jest.fn()
 const mockParticipantRefreshHandler = jest.fn()
-const mockParticipantCloseHandler = jest.fn()
+const mockParticipantExitHandler = jest.fn()
 const mockParticipantActionHandler = jest.fn()
 
 const TicTacToeMachineConfig = anearEvent => ({
@@ -30,8 +30,8 @@ const TicTacToeMachineConfig = anearEvent => ({
         REFRESH: {
           actions: 'refreshHandler'
         },
-        CLOSE: {
-          actions: 'closeHandler'
+        PARTICIPANT_EXIT: {
+          actions: 'participantExitHandler'
         }
       }
     },
@@ -40,8 +40,8 @@ const TicTacToeMachineConfig = anearEvent => ({
         BULLSEYE: {
           actions: 'actionHandler'
         },
-        CLOSE: {
-          actions: 'closeHandler'
+        PARTICIPANT_EXIT: {
+          actions: 'participantExitHandler'
         },
         REFRESH: {
           actions: 'refreshHandler'
@@ -59,8 +59,8 @@ const TicTacToeMachineOptions = anearEvent => ({
     refreshHandler: (context, event) => {
       anearEvent.myParticipantRefreshHandler(event.participant)
     },
-    closeHandler: (context, event) => {
-      anearEvent.myParticipantCloseHandler(event.participant)
+    participantExitHandler: (context, event) => {
+      anearEvent.myParticipantExitHandler(event.participant)
     },
     actionHandler: assign({score: (context, event) => context.score + event.payload.points}),
   }
@@ -84,8 +84,8 @@ class TestEvent extends AnearEvent {
   async myParticipantEnterHandler(...args) {
     return mockParticipantEnterHandler(...args)
   }
-  async myParticipantCloseHandler(...args) {
-    return mockParticipantCloseHandler(...args)
+  async myParticipantExitHandler(...args) {
+    return mockParticipantExitHandler(...args)
   }
   async myParticipantRefreshHandler(...args) {
     return mockParticipantRefreshHandler(...args)
@@ -110,8 +110,8 @@ class TestEventWithDefaultXState extends AnearEvent {
     return Promise.resolve()
   }
 
-  participantCloseEventCallback(participant) {
-    mockParticipantCloseHandler(participant)
+  participantExitEventCallback(participant) {
+    mockParticipantExitHandler(participant)
     return Promise.resolve()
   }
 
@@ -181,11 +181,11 @@ test('participant close with Default Xstate Config', async () => {
 
   const p1 = new TestPlayer(chatParticipant1)
 
-  await t.participantClose(p1)
+  await t.participantExit(p1)
   await t.update()
 
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p1)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledTimes(1)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p1)
+  expect(mockParticipantExitHandler).toHaveBeenCalledTimes(1)
   expect(t.participants.numActive(false)).toBe(0)
 
   await t.remove()
@@ -252,14 +252,14 @@ test('can add participants, not hosted', async () => {
   expect(t.participants.get(p2).name).toBe("bbondfl93")
   expect(p2.userType).toBe("participant")
 
-  await t.participantClose(p1)
-  await t.participantClose(p2)
+  await t.participantExit(p1)
+  await t.participantExit(p2)
   await t.update()
   await t.remove()
 
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p1)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p2)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledTimes(2)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p1)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p2)
+  expect(mockParticipantExitHandler).toHaveBeenCalledTimes(2)
   expect(t.participants.numActive(false)).toBe(0)
 })
 
@@ -291,14 +291,14 @@ test('can add participant, hosted', async () => {
   expect(t.participants.numActive(false)).toBe(1)
   expect(t.participants.get(p2).name).toBe('bbondfl93')
 
-  await t.participantClose(host)
-  await t.participantClose(p2)
+  await t.participantExit(host)
+  await t.participantExit(p2)
   await t.update()
   await t.remove()
 
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(host)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledWith(p2)
-  expect(mockParticipantCloseHandler).toHaveBeenCalledTimes(2)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(host)
+  expect(mockParticipantExitHandler).toHaveBeenCalledWith(p2)
+  expect(mockParticipantExitHandler).toHaveBeenCalledTimes(2)
   expect(t.participants.numActive(false)).toBe(0)
 })
 
@@ -327,8 +327,8 @@ test('can be retrieved back from storage with participants, not hosted', async (
   expect(rehydratedPlayer1.context.name).toBe('machvee')
   expect(rehydratedPlayer2.context.name).toBe('bbondfl93')
 
-  await rehydratedTestEvent.participantClose(rehydratedPlayer1)
-  await rehydratedTestEvent.participantClose(rehydratedPlayer2)
+  await rehydratedTestEvent.participantExit(rehydratedPlayer1)
+  await rehydratedTestEvent.participantExit(rehydratedPlayer2)
   await rehydratedTestEvent.remove()
 })
 
@@ -354,8 +354,9 @@ test('can update state machine context via Action events', async () => {
 
   expect(t.anearStateMachine.context.score).toBe(92)
 
-  await t.participantClose(p1)
-  await t.participantClose(p2)
+  await t.participantExit(p1)
+  await t.participantExit(p2)
+  await t.closeOutParticipants()
   await t.remove()
 })
 
@@ -374,7 +375,7 @@ test('can reset All ParticipantTimers', async () => {
 
   expect(resetMock).toHaveBeenCalledTimes(1)
 
-  await t.participantClose(p1)
-  await t.participantClose(p2)
+  await t.participantExit(p1)
+  await t.participantExit(p2)
   await t.remove()
 })