anear-js-api 0.4.7 → 0.4.8

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) {
@@ -128,48 +127,9 @@ class AnearEvent extends JsonApiResource {
     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'
-  }
-
   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(
@@ -254,6 +214,10 @@ class AnearEvent extends JsonApiResource {
     await this.participantPurge(participant)
   }
 
+  spectatorView(userId) {
+    this.anearStateMachine.sendSpectatorViewEvent({userId})
+  }
+
   async participantPurge(participant) {
     this.participants.purge(participant)
     await participant.remove()
@@ -267,10 +231,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

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.8",
   "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()

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
-}