anear-js-api 0.4.2 → 0.4.4

package/lib/api/AnearApi.js

@@ -42,14 +42,10 @@ class AnearApi extends ApiService {
     logger.debug(`API: POST transition event ${eventName}`)
 
     const relationships = {event: eventId}
-    try {
-      const json = await this.post("transitions", {event_name: eventName}, relationships)
-      const attrs = json.data.attributes
-      logger.info(`API: newState is ${attrs.state}`)
-      return attrs
-    } catch(err) {
-      logger.error(err)
-    }
+    const json = await this.post("transitions", {event_name: eventName}, relationships)
+    const attrs = json.data.attributes
+    logger.debug(`API: newState is ${attrs.state}`)
+    return attrs
   }
 
   async getEventParticipantJson(participantId, geoLocation) {

package/lib/messaging/AnearMessaging.js

@@ -28,6 +28,7 @@ class AnearMessaging {
     this.AnearEventClass = AnearEventClass
     this.AnearParticipantClass = AnearParticipantClass
     this.anearEvents = {}
+    this.eventChannels = {}
 
     const baseUrl          = this.api.api_base_url
     const authUrl          = `${baseUrl}/messaging_auth`
@@ -49,8 +50,6 @@ class AnearMessaging {
       }
     }
 
-    this.eventChannels = {}
-
     this.initRealtime(clientOptions)
   }
 
@@ -59,30 +58,35 @@ class AnearMessaging {
 
     this.realtime = new Ably.Realtime(clientOptions)
 
-    this.realtime.connection.on(
-      "connected",
-      async () => {
-        await this.getAppInfo(AppId)
-        logger.info("Ably connected!")
-        await this.setupCreateEventChannel()
-        await this.reloadAnyEventsInProgress(AppId)
-      }
-    )
+    const connectedCallback = async () => {
+      await this.getAppInfo(AppId)
+      logger.debug("Ably connected!")
+      await this.setupCreateEventChannel()
+      await this.reloadAnyEventsInProgress(AppId)
+    }
+
+    this.realtime.connection.on("connected", connectedCallback)
   }
 
   async getAppInfo(appId) {
+    // fetch the App info from the Anear API
     const anearApp = await this.api.getApp(appId)
-    logger.info("================")
-    logger.info(`STARTING APP ${anearApp.data.attributes['short-name']}`)
-    logger.info("================")
+
+    logger.debug("================")
+    logger.debug(`STARTING APP ${anearApp.data.attributes['short-name']}`)
+    logger.debug("================")
   }
 
   getChannel(channelName, channelParams = ChannelParams) {
     return this.realtime.channels.get(channelName, channelParams)
   }
 
-  async getAnearEventFromStorage(eventId) {
-    return await this.AnearEventClass.getFromStorage(eventId, this)
+  getAnearEventFromStorage(eventId) {
+    return this.AnearEventClass.getFromStorage(eventId, this)
+  }
+
+  getAnearParticipantFromStorage(participantId) {
+    return this.AnearParticipantClass.getFromStorage(participantId, this)
   }
 
   async initEventRealtimeMessaging(anearEvent) {
@@ -94,14 +98,10 @@ class AnearMessaging {
 
     this.eventChannels[anearEvent.id] = {privates: {}}
 
-    try {
-      await this.setupSpectatorsChannel(anearEvent)
-      this.setupEventsChannel(anearEvent)
-      await this.setupParticipantsChannel(anearEvent)
-      await this.setupActionsChannel(anearEvent)
-    } catch(error) {
-      logger.error(`initEventRealtimeMessaging(${anearEvent.id}): `, error)
-    }
+    await this.setupSpectatorsChannel(anearEvent)
+    this.setupEventsChannel(anearEvent)
+    await this.setupParticipantsChannel(anearEvent)
+    await this.setupActionsChannel(anearEvent)
 
     logger.debug(`initEventRealtimeMessaging(${anearEvent.id}) is complete`)
 
@@ -113,76 +113,75 @@ class AnearMessaging {
     // create the AnearEvent subclass, persist it in storage, and
     // initialize its realtime messaging
     //
-    logger.info(`createEventMessagingCallback(${message.name})`)
-
-    try {
-      const eventJson = JSON.parse(message.data)
-      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
-      //
-      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.debug(`createEventMessagingCallback(${message.name})`)
+
+    const eventJson = JSON.parse(message.data)
+    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
+    //
+    const eventExists = await anearEvent.exists()
 
-      logger.info(`New ${loadedEvent.constructor.name} Event: `, loadedEvent.toJSON())
+    logger.debug(
+      `Event ${anearEvent.id} ${eventExists ? "already exists" : "does not exist"} in Storage`
+    )
 
-      this.anearEvents[loadedEvent.id] = loadedEvent
+    let loadedEvent = anearEvent
+
+    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
+        // to handle those XState events
+        anearEvent.startStateMachine()
+        await this.initEventRealtimeMessaging(anearEvent)
+      }
 
-    } catch(err) {
-      logger.error(err)
+      await anearEvent.runExclusive(
+        `createEventCallback ${anearEvent.id}`,
+        messagingInitializedCallback
+      )
+    } else {
+      loadedEvent = await this.getAnearEventFromStorage(anearEvent.id)
+      await this.initEventRealtimeMessaging(loadedEvent)
+      loadedEvent.startStateMachine()
     }
+
+    logger.debug(`New ${loadedEvent.constructor.name} Event: `, loadedEvent.toJSON())
+
+    this.anearEvents[loadedEvent.id] = loadedEvent
   }
 
   async reloadAnyEventsInProgress(appId) {
-    try {
-      const anearApp = await this.api.getAppZones(appId)
-      for (const zone of anearApp.data.relationships.zones.data) {
-        const zoneEvents = await this.api.getZoneEvents(zone.id)
-        const events = zoneEvents.data.relationships.events.data
-
-        for (const eventData of events) {
-          const eventJson = await this.api.getEvent(eventData.id)
-          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()
-          //
-        }
+    const anearApp = await this.api.getAppZones(appId)
+
+    for (const zone of anearApp.data.relationships.zones.data) {
+      const zoneEvents = await this.api.getZoneEvents(zone.id)
+      const events = zoneEvents.data.relationships.events.data
+
+      for (const eventData of events) {
+        const eventJson = await this.api.getEvent(eventData.id)
+        const anearEvent = new this.AnearEventClass(eventJson, this)
+        await this.initEventRealtimeMessaging(anearEvent)
+
+        const attachedParticipants = await 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()
+        //
       }
-    } catch (err) {
-      logger.error(err)
     }
   }
 
   async setupCreateEventChannel() {
-    logger.info(`attaching to channel ${AnearCreateEventChannelName}`)
+    logger.debug(`attaching to channel ${AnearCreateEventChannelName}`)
 
     const createEventsChannel = this.getChannel(AnearCreateEventChannelName)
 
@@ -228,11 +227,11 @@ class AnearMessaging {
     return members.length
   }
 
-  async getPresentParticipants(anearEvent) {
+  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()
+    return channel.presence.get() // returns Promise
   }
 
   async setupActionsChannel(anearEvent) {
@@ -329,29 +328,22 @@ class AnearMessaging {
     // check if the participant is already in storage, and if so, instantiate, else
     // instantiate from API response
     //
-    try {
-      const participantJson = await this.api.getEventParticipantJson(participantId)
-      const participant = new this.AnearParticipantClass(participantJson, anearEvent)
+    const participantJson = await this.api.getEventParticipantJson(participantId)
+    const participant = new this.AnearParticipantClass(participantJson, anearEvent)
 
-      const persistedAnearParticipant = await this.AnearParticipantClass.getFromStorage(participantId, anearEvent)
+    const persistedAnearParticipant = await this.AnearParticipantClass.getFromStorage(participantId, anearEvent)
 
-      if (persistedAnearParticipant) {
-        participant.context = persistedAnearParticipant.context
-      }
+    if (persistedAnearParticipant) {
+      participant.context = persistedAnearParticipant.context
+    }
 
-      await anearEvent.runExclusive(`participantEnterCallback ${participant.id}`, async () => {
-        participant.geoLocation = geoLocation
+    await anearEvent.runExclusive(`participantEnterCallback ${participant.id}`, async () => {
+      participant.geoLocation = geoLocation
 
-        await this.setupPrivatePublishingChannel(participant)
-        await anearEvent.participantEnter(participant)
-        await anearEvent.update()
-      })
-    } catch(error) {
-      // participant not found or is not currently marked active at the API service
-      // don't allow participation.  FIX: we need to publish to the private channel
-      // with an error message type.
-      logger.error(`processParticipanEnter(${anearEvent.id}, ${participantId}) error: `, error)
-    }
+      await this.setupPrivatePublishingChannel(participant)
+      await anearEvent.participantEnter(participant)
+      await anearEvent.update()
+    })
   }
 
   async spectatorEnterMessagingCallback(anearEvent, message) {
@@ -454,11 +446,7 @@ class AnearMessaging {
   }
 
   async attachChannel(channel) {
-    try {
-      return await channel.attach()
-    } catch(err) {
-      this.logErrorInfo(err)
-    }
+    return await channel.attach()
   }
 
   subscribeEventMessages(channel, messageType, callback) {
@@ -471,22 +459,18 @@ class AnearMessaging {
   }
 
   async subscribePresenceEventWithHistory(channel, action, callback) {
-    logger.info(`subscribePresenceEvents(${action}) for channel ${channel.name}`)
+    logger.debug(`subscribePresenceEvents(${action}) for channel ${channel.name}`)
 
     this.subscribePresenceEvent(channel, action, callback)
 
-    try {
-      const history = await channel.presence.history({limit: 25})
+    const history = await channel.presence.history({limit: 25})
 
-      history.items.filter(message => message.action === action).forEach(
-        async message => {
-          logger.info(`presence history ${action} event received`, message)
-          await callback(message)
-        }
-      )
-    } catch(err) {
-      logger.error('Unable to get presence history; err = ' + err.message)
-    }
+    history.items.filter(message => message.action === action).forEach(
+      async message => {
+        logger.debug(`presence history ${action} event received`, message)
+        await callback(message)
+      }
+    )
   }
 
   async publishEventSpectatorsMessage(anearEvent, css, message, messageType = PublicDisplayMessageType) {
@@ -592,14 +576,10 @@ class AnearMessaging {
   }
 
   async publishChannelMessage(channel, messageType, payload) {
-    try {
-      await channel.publish(
-        messageType,
-        payload
-      )
-    } catch(err) {
-      this.logErrorInfo(err)
-    }
+    await channel.publish(
+      messageType,
+      payload
+    )
   }
 
   async detachAll(eventId) {
@@ -621,17 +601,13 @@ class AnearMessaging {
   async detachChannel (channel) {
     if (!channel || channel.state !== 'attached') return
 
-    try {
-      await channel.detach(this.logErrorInfo)
-      logger.info(`channel ${channel.name} detached`)
-    } catch(err) {
-      this.logErrorInfo(err)
-    }
+    await channel.detach(this.logErrorInfo)
+    logger.debug(`channel ${channel.name} detached`)
   }
 
   logErrorInfo(errInfo) {
     if (errInfo) {
-      logger.error(`Ably ERROR (${errInfo.code}):  ${errInfo.message}`)
+      logger.error("Ably ERROR:", errInfo)
     }
   }
 }

package/lib/models/AnearEvent.js

@@ -11,6 +11,8 @@ const logger = require('../utils/Logger')
 
 const PrivateDisplayMessageType  = 'private_display'
 
+const PlayableStates = ['closing', 'closed', 'canceled']
+
 class AnearEvent extends JsonApiResource {
 
   constructor(json, messaging) {
@@ -64,7 +66,7 @@ class AnearEvent extends JsonApiResource {
   }
 
   async getClonedEvent() {
-    // if the current event was a clone of previous event, try to fetch if from
+    // 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
@@ -221,13 +223,13 @@ class AnearEvent extends JsonApiResource {
     if (this.participants.exists(participant)) {
       logger.info(`AnearEvent: participant ${participant.id} exists.  Refreshing...`)
 
-      this.participants.add(participant) // update the participants entry
+      this.participants.add(participant) // update the participants record
 
       this.anearStateMachine.sendRefreshEvent({ participant })
 
       await participant.update()
     } else {
-      this.participants.add(participant) // add the participants entry
+      this.participants.add(participant) // add the participants record
 
       this.anearStateMachine.sendJoinEvent({ participant })
 
@@ -271,18 +273,14 @@ class AnearEvent extends JsonApiResource {
     //
     logger.debug(`AnearEvent: transitionEvent(${eventName})`)
 
-    try {
-      const responseAttributes = await this.messaging.api.transitionEvent(this.id, eventName)
-      const newState = responseAttributes.state
-      this.attributes.state = newState
-      await this.messaging.publishEventTransitionMessage(this, newState)
-    } catch(err) {
-      logger.error(`AnearEvent: transitionEvent error: ${err}`)
-    }
+    const responseAttributes = await this.messaging.api.transitionEvent(this.id, eventName)
+    const newState = responseAttributes.state
+    this.attributes.state = newState
+    await this.messaging.publishEventTransitionMessage(this, newState)
   }
 
   isPlayable() {
-    return !['closing', 'closed', 'canceled'].includes(this.eventState)
+    return !PlayableStates.includes(this.eventState)
   }
 
   async transitionToAnnounce() {
@@ -311,10 +309,9 @@ class AnearEvent extends JsonApiResource {
     return Promise.all(
       this.participants.all.map(
         async p => {
-          const participant = await this.messaging.getAnearParticipantFromStorage(p.id)
           await this.messaging.closeParticipant(
             this,
-            participant.id,
+            p.id,
             async (anearEvent, participant) => {
               await anearEvent.participantPurge(participant)
             }

package/lib/utils/AnearXstate.js

@@ -11,7 +11,12 @@ const TimeoutEvent = 'TIMEOUT'
 
 class AnearXstate {
   constructor(machineConfig, machineOptions, previousState, anearEventContext) {
-    this.machine = createMachine(machineConfig, machineOptions).withContext(anearEventContext)
+    const config = {predictableActionArguments: true, ...machineConfig}
+
+    this.machine = createMachine(
+      config,
+      machineOptions
+    ).withContext(anearEventContext)
 
     this._currentState = previousState ? State.create(previousState) : this.machine.initialState
     this._currentContext = anearEventContext

package/package.json

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