anear-js-api 0.4.7 → 0.4.9

package/lib/messaging/AnearMessaging.js

@@ -137,7 +137,6 @@ class AnearMessaging {
 
     if (!eventExists) {
       const messagingInitializedCallback = async () => {
-        await anearEvent.createdEventCallback()
         await anearEvent.persist()
         // start the state machine before initializing Realtime Messaging
         // as REFRESH events come in and the state machine should be ready
@@ -214,7 +213,7 @@ class AnearMessaging {
     this.subscribePresenceEvent(
       spectatorsChannel,
       PRESENCE_ENTER,
-      async message => await this.spectatorEnterMessagingCallback(anearEvent, message)
+      async message => await this.spectatorViewMessagingCallback(anearEvent, message)
     )
 
     this.subscribePresenceEvent(
@@ -351,12 +350,11 @@ class AnearMessaging {
     })
   }
 
-  async spectatorEnterMessagingCallback(anearEvent, message) {
+  spectatorViewMessagingCallback(anearEvent, message) {
     const userId = message.clientId
+    logger.debug(`**** ENTER SPECTATOR FOR VIEWING ****  event: ${anearEvent.id}, user: ${userId}`)
 
-    logger.debug(`**** ENTER SPECTATOR ****  event: ${anearEvent.id}, user: ${userId}`)
-
-    await anearEvent.refreshSpectator()
+    anearEvent.spectatorView(userId)
   }
 
   async spectatorLeaveMessagingCallback(anearEvent, message) {
@@ -450,8 +448,8 @@ class AnearMessaging {
     logger.debug(`setupPrivatePublishingChannel(${participant.privateChannelName}) state ${privateChannel.state}`)
   }
 
-  async attachChannel(channel) {
-    return await channel.attach()
+  attachChannel(channel) {
+    return channel.attach()
   }
 
   subscribeEventMessages(channel, messageType, callback) {

package/lib/models/AnearEvent.js

@@ -3,7 +3,6 @@
 const { Mutex } = require('async-mutex')
 
 const AnearXstate = require('../utils/AnearXstate')
-const { DefaultConfigFunc, DefaultOptionsFunc } = require('../utils/AnearXstateDefaults')
 
 const JsonApiResource = require('./JsonApiResource')
 const Participants = require('../utils/Participants')
@@ -40,12 +39,12 @@ class AnearEvent extends JsonApiResource {
 
   stateMachineConfig() {
     // override in subclass with custom Xstate config
-    return DefaultConfigFunc(this)
+    return {}
   }
 
   stateMachineOptions() {
     // override in subclass with custom Xstate options
-    return DefaultOptionsFunc(this)
+    return {}
   }
 
   initStateMachine(previousState) {
@@ -65,14 +64,13 @@ class AnearEvent extends JsonApiResource {
     return this.relationships.zone.data.id
   }
 
-  async getClonedEvent() {
+  getClonedEvent() {
     // if the current event was a clone of previous event, fetch if from
     // Peristence and return
     const clonedEventData = this.relationships["cloned-event"].data
     if (!clonedEventData) return null
 
-    const clonedEvent = await this.constructor.getFromStorage(clonedEventData.id)
-    return clonedEvent
+    return this.constructor.getFromStorage(clonedEventData.id)
   }
 
   async clonedEventContext() {
@@ -124,55 +122,16 @@ class AnearEvent extends JsonApiResource {
     return !this.hasFlag("no_spectators")
   }
 
-  async spectatorCount() {
-    return await this.messaging.getSpectatorCount(this)
-  }
-
-  async createdEventCallback(participantCreator) {
-    // You may implement createdEventCallback() in your AnearEvent sub-class
-  }
-
-  async participantEnterEventCallback(participant) {
-    throw new Error('You must implement an async participantEnterEventCallback() in your AnearEvent sub-class');
-  }
-
-  async participantRefreshEventCallback(participant, remainingTimeout = null) {
-    // You may implement an async participantRefreshEventCallback() in your AnearEvent sub-class
-  }
-
-  async spectatorRefreshEventCallback() {
-    // You may implement an async spectatorRefreshEventCallback() 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) {
-    throw new Error('You must implement an async participantActionEventCallback() in your AnearEvent sub-class');
-  }
-
-  async participantTimedOutEventCallback(participant) {
-    // You may implement participantTimedOutEventCallback() in your AnearEvent sub-class'
-  }
-
-  async eventBroadcastEventCallback(message) {
-    // You may implement eventBroadcastEventCallback() in your AnearEvent sub-class'
+  spectatorCount() {
+    return this.messaging.getSpectatorCount(this)
   }
 
   isParticipantEventCreator(RParticipant) {
     return participant.userId === this.userId
   }
-  async refreshParticipant(participant) {
-    await this.participantRefreshEventCallback(participant)
-  }
-
-  async refreshSpectator() {
-    await this.spectatorRefreshEventCallback()
-  }
 
-  async publishEventParticipantsMessage(message, timeoutMsecs=0) {
-    await this.messaging.publishEventParticipantsMessage(
+  publishEventParticipantsMessage(message, timeoutMsecs=0) {
+    return this.messaging.publishEventParticipantsMessage(
       this,
       this.participants.active(),
       this.css,
@@ -193,12 +152,12 @@ class AnearEvent extends JsonApiResource {
     logger.debug(`mutex ${name} released!`)
   }
 
-  async publishEventSpectatorsMessage(message) {
-    await this.messaging.publishEventSpectatorsMessage(this, this.css, message)
+  publishEventSpectatorsMessage(message) {
+    return this.messaging.publishEventSpectatorsMessage(this, this.css, message)
   }
 
-  async publishEventPrivateMessage(participant, message, timeoutMsecs=0) {
-    await this.messaging.publishEventPrivateMessage(
+  publishEventPrivateMessage(participant, message, timeoutMsecs=0) {
+    return this.messaging.publishEventPrivateMessage(
       this,
       participant,
       PrivateDisplayMessageType,
@@ -208,8 +167,8 @@ class AnearEvent extends JsonApiResource {
     )
   }
 
-  async publishEventTransitionMessage(newState) {
-    await this.messaging.publishEventTransitionMessage(
+  publishEventTransitionMessage(newState) {
+    return this.messaging.publishEventTransitionMessage(
       this,
       newState
     )
@@ -247,16 +206,20 @@ class AnearEvent extends JsonApiResource {
     }
   }
 
-  async participantExit(participant) {
+  participantExit(participant) {
     // this informs the state machine that the participant has exited the event
     // and removes that participant completely
     this.anearStateMachine.sendParticipantExitEvent({ participant })
-    await this.participantPurge(participant)
+    return this.participantPurge(participant)
+  }
+
+  spectatorView(userId) {
+    this.anearStateMachine.sendSpectatorViewEvent({userId})
   }
 
-  async participantPurge(participant) {
+  participantPurge(participant) {
     this.participants.purge(participant)
-    await participant.remove()
+    return participant.remove()
   }
 
   participantAction(participant, actionEventName, actionPayload) {
@@ -267,10 +230,6 @@ class AnearEvent extends JsonApiResource {
     this.anearStateMachine.sendTimeoutEvent({ participant })
   }
 
-  async eventBroadcast(message) {
-    await this.eventBroadcastEventCallback(message)
-  }
-
   async transitionEvent(eventName='next') {
     //
     // Allows the app/game to transition the remote AnearEvent which can un/hide and event
@@ -302,24 +261,24 @@ class AnearEvent extends JsonApiResource {
     await this.transitionEvent('next')
   }
 
-  async transitionLive() {
-    await this.transitionNextNext()
+  transitionLive() {
+    return this.transitionNextNext()
   }
 
-  async transitionClosed() {
-    await this.transitionNextNext()
+  transitionClosed() {
+    return this.transitionNextNext()
   }
 
-  async transitionCanceled() {
-    await this.transitionEvent('cancel')
+  transitionCanceled() {
+    return this.transitionEvent('cancel')
   }
 
-  async closeOutParticipants() {
+  closeOutParticipants() {
     // upon exiting the event, this will clean up any participants remaining
     return Promise.all(
       this.participants.all.map(
-        async p => {
-          await this.messaging.closeParticipant(
+        p => {
+          return this.messaging.closeParticipant(
             this,
             p.id,
             async (anearEvent, participant) => {
@@ -331,12 +290,12 @@ class AnearEvent extends JsonApiResource {
     )
   }
 
-  async purgeParticipants() {
-    // remove participants from Participants class and from Storage
+  purgeParticipants() {
+    // remove participants and host from Participants class and from Storage
     const all = this.participants.all
     if (this.participants.host) all.push(this.participants.host)
 
-    await Promise.all(
+    return Promise.all(
       all.map(p => this.participantPurge(p))
     )
   }
@@ -366,8 +325,8 @@ class AnearEvent extends JsonApiResource {
     await this.closeMessaging()
   }
 
-  async closeMessaging () {
-    await this.messaging.detachAll(this.id)
+  closeMessaging () {
+    return this.messaging.detachAll(this.id)
   }
 
   logDebugMessage(...args) {

package/lib/utils/AnearXstate.js

@@ -3,7 +3,8 @@ const { createMachine, interpret, State } = require('xstate')
 
 const logger = require('../utils/Logger')
 
-const JoinEvent = 'JOIN'
+const JoinEvent = 'PARTICIPANT_JOIN'
+const SpectatorViewEvent = 'SPECTATOR_VIEW'
 const ParticipantExitEvent = 'PARTICIPANT_EXIT'
 const RefreshEvent = 'REFRESH'
 const CloseEvent = 'EVENT_CLOSE'
@@ -60,6 +61,10 @@ class AnearXstate {
     this.send(ParticipantExitEvent, params)
   }
 
+  sendSpectatorViewEvent(params) {
+    this.send(SpectatorViewEvent, params)
+  }
+
   sendTimeoutEvent(params) {
     this.send(TimeoutEvent, params)
   }

package/package.json

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

package/tests/AnearEvent.test.js

@@ -5,6 +5,7 @@ const AnearParticipant = require('../lib/models/AnearParticipant')
 const MockMessaging = require('../lib/messaging/__mocks__/AnearMessaging')
 
 const mockParticipantEnterHandler = jest.fn()
+const mockSpectatorViewHandler = jest.fn()
 const mockParticipantRefreshHandler = jest.fn()
 const mockParticipantExitHandler = jest.fn()
 const mockParticipantActionHandler = jest.fn()
@@ -15,15 +16,19 @@ const TicTacToeMachineConfig = anearEvent => ({
   states: {
     waitingForHost: {
       on: {
-        JOIN: {
+        PARTICIPANT_JOIN: {
           actions: 'enterHandler',
           target: 'waitingForOpponent'
+        },
+        SPECTATOR_VIEW: {
+          actions: 'viewHandler',
+          target: 'waitingForHost'
         }
       }
     },
     waitingForOpponent: {
       on: {
-        JOIN: {
+        PARTICIPANT_JOIN: {
           actions: 'enterHandler',
           target: 'gameStart'
         },
@@ -37,6 +42,9 @@ const TicTacToeMachineConfig = anearEvent => ({
     },
     gameStart: {
       on: {
+        TEST_ACTION: {
+          actions: 'testActionHandler'
+        },
         BULLSEYE: {
           actions: 'actionHandler'
         },
@@ -59,10 +67,20 @@ const TicTacToeMachineOptions = anearEvent => ({
     refreshHandler: (context, event) => {
       anearEvent.myParticipantRefreshHandler(event.participant)
     },
+    viewHandler: (context, event) => {
+      anearEvent.mySpectatorViewHandler(event.userId)
+    },
     participantExitHandler: (context, event) => {
       anearEvent.myParticipantExitHandler(event.participant)
     },
     actionHandler: assign({score: (context, event) => context.score + event.payload.points}),
+    testActionHandler: (context, event) => {
+      anearEvent.myParticipantActionHandler(
+        event.participant.id,
+        event.type,
+        event.payload
+      )
+    }
   }
 })
 
@@ -81,6 +99,9 @@ class TestEvent extends AnearEvent {
     return TicTacToeMachineOptions(this)
   }
 
+  async mySpectatorViewHandler(...args) {
+    return mockSpectatorViewHandler(...args)
+  }
   async myParticipantEnterHandler(...args) {
     return mockParticipantEnterHandler(...args)
   }
@@ -90,37 +111,12 @@ class TestEvent extends AnearEvent {
   async myParticipantRefreshHandler(...args) {
     return mockParticipantRefreshHandler(...args)
   }
-}
-
-
-class TestEventWithDefaultXState extends AnearEvent {
-  initContext() {
-    return {
-      playerScores: [83, 22]
-    }
-  }
-
-  participantEnterEventCallback(participant) {
-    mockParticipantEnterHandler(participant)
-    return Promise.resolve()
-  }
-
-  participantRefreshEventCallback(participant) {
-    mockParticipantRefreshHandler(participant)
-    return Promise.resolve()
-  }
-
-  participantExitEventCallback(participant) {
-    mockParticipantExitHandler(participant)
-    return Promise.resolve()
-  }
-
-  participantActionEventCallback(participant, actionEventName, payload) {
-    mockParticipantActionHandler(participant, actionEventName, payload)
-    return Promise.resolve()
+  async myParticipantActionHandler(...args) {
+    return mockParticipantActionHandler(...args)
   }
 }
 
+
 class TestPlayer extends AnearParticipant {
   initContext() {
     return {
@@ -148,23 +144,18 @@ const newTestEvent = (hosted = false) => {
   return t
 }
 
-const newTestEventWithDefaultXState = testEvent => {
-  const t = new TestEventWithDefaultXState(testEvent, TestPlayer, MessagingStub)
-  t.startStateMachine()
-  return t
-}
-
-test('participant enter with Default Xstate Config', async () => {
-  const t = newTestEventWithDefaultXState(chatEvent)
+test('participant enter', async () => {
+  const t = newTestEvent()
 
   const id = t.id
   expect(t.id).toBe(chatEvent.data.id)
   expect(t.relationships.user.data.type).toBe("users")
-  expect(t.anearStateMachine.currentState.value).toBe("eventActive")
-  expect(t.stateMachineContext.playerScores[0]).toBe(83)
+  expect(t.anearStateMachine.currentState.value).toBe("waitingForHost")
+  expect(t.stateMachineContext.score).toBe(90)
   const p1 = new TestPlayer(chatParticipant1, t)
 
   await t.participantEnter(p1)
+  expect(t.anearStateMachine.currentState.value).toBe("waitingForOpponent")
   await t.persist()
   await t.remove()
 
@@ -176,10 +167,25 @@ test('participant enter with Default Xstate Config', async () => {
   await p1.remove()
 })
 
-test('participant close with Default Xstate Config', async () => {
-  const t = newTestEventWithDefaultXState(chatEvent)
+test('spectator viewer', async () => {
+  const t = newTestEvent()
+  const userId = 999837834
+
+  const id = t.id
+  expect(t.anearStateMachine.currentState.value).toBe("waitingForHost")
+  await t.spectatorView(userId)
+  expect(t.anearStateMachine.currentState.value).toBe("waitingForHost")
+
+  expect(mockSpectatorViewHandler).toHaveBeenCalledTimes(1)
+  expect(mockSpectatorViewHandler).toHaveBeenCalledWith(userId)
+})
+
+
+test('participant close', async () => {
+  const t = newTestEvent()
 
   const p1 = new TestPlayer(chatParticipant1, t)
+  await t.participantEnter(p1)
 
   await t.participantExit(p1)
   await t.update()
@@ -191,29 +197,20 @@ test('participant close with Default Xstate Config', async () => {
   await t.remove()
 })
 
-test('participant refresh with Default Xstate Config', async () => {
-  const t = newTestEventWithDefaultXState(chatEvent)
+test('participant action', async () => {
+  const t = newTestEvent()
   const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
+  await t.participantEnter(p1)
+  await t.participantEnter(p2)
 
-  await t.refreshParticipant(p1)
-  await t.update()
-
-  expect(mockParticipantRefreshHandler).toHaveBeenCalledWith(p1)
-  expect(mockParticipantRefreshHandler).toHaveBeenCalledTimes(1)
-  await p1.remove()
-  await t.remove()
-})
-
-test('participant action with Default Xstate Config', async () => {
-  const t = newTestEventWithDefaultXState(chatEvent)
-  const p1 = new TestPlayer(chatParticipant1, t)
   const eventName = "TEST_ACTION"
   const payload = {x: 1, y: 99}
 
   await t.participantAction(p1, eventName, payload)
   await t.update()
 
-  expect(mockParticipantActionHandler).toHaveBeenCalledWith(p1, eventName, payload)
+  expect(mockParticipantActionHandler).toHaveBeenCalledWith(p1.id, eventName, payload)
   expect(mockParticipantActionHandler).toHaveBeenCalledTimes(1)
   await p1.remove()
   await t.remove()
@@ -279,6 +276,7 @@ test('purge all participants', async () => {
   await t.purgeParticipants()
 
   expect(t.participants.all).toHaveLength(0)
+  expect(t.participants.host).toBe(null)
 
   await t.remove()
 })

package/lib/utils/AnearXstateDefaults.js

@@ -1,108 +0,0 @@
-"use strict"
-
-// Default configuration and options funcs provide
-// a simple default state machine for an anear Event.  This is
-// so we don't mandate that app developers use xState to drive
-// their app's state transitions. Devs simply provide callbacks
-// override implementations in their AnearEvent subclass.
-// The xState context is simply the anearEvent.context
-//
-// If a developer wants an xState machine to drive the applications
-// state transitions, the developer should override stateMachineConfig()
-// and stateMachineOptions() in their AnearEvent subclass.
-//
-const DefaultConfigFunc = (anearEvent) => {
-
-  const PromiseResolveReject = {
-    onDone: {
-      target: 'eventActive'
-    },
-    onError: {
-      actions: 'logError',
-      target: 'eventActive'
-    }
-  }
-
-  return {
-    id: "defaultXstateConfig",
-    initial: 'eventActive',
-    states: {
-      eventActive: {
-        on: {
-          JOIN: {
-            target: 'join'
-          },
-          REFRESH: {
-            target: 'refresh'
-          },
-          PARTICIPANT_EXIT: {
-            target: 'participant_exit'
-          },
-          TIMEOUT: {
-            target: 'timeout'
-          },
-          '*': {
-            // default wildcard state is presumed to be a custom ACTION name
-            // embedded in a anear-action-click property in the app's HTML
-            target: 'action'
-          }
-        }
-      },
-      join: {
-        invoke: {
-          id: 'join',
-          src: 'joinEventHandler',
-          ...PromiseResolveReject
-        }
-      },
-      refresh: {
-        invoke: {
-          id: 'refresh',
-          src: 'refreshEventHandler',
-          ...PromiseResolveReject
-        }
-      },
-      participant_exit: {
-        invoke: {
-          id: 'participant_exit',
-          src: 'participantExitEventHandler',
-          ...PromiseResolveReject
-        }
-      },
-      timeout: {
-        invoke: {
-          id: 'timeout',
-          src: 'timeoutEventHandler',
-          ...PromiseResolveReject
-        }
-      },
-      action: {
-        invoke: {
-          id: 'action',
-          src: 'actionEventHandler',
-          ...PromiseResolveReject
-        }
-      }
-    }
-  }
-}
-
-const DefaultOptionsFunc = anearEvent => {
-  return {
-    actions: {
-      logError: (context, event) => logger.error(`error message: ${event.data}`)
-    },
-    services: {
-      joinEventHandler: (context, event) => anearEvent.participantEnterEventCallback(event.participant),
-      refreshEventHandler: (context, event) => anearEvent.participantRefreshEventCallback(event.participant, event.remainingTimeout),
-      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)
-    }
-  }
-}
-
-module.exports = {
-  DefaultConfigFunc,
-  DefaultOptionsFunc
-}