anear-js-api 0.4.20 → 0.4.22

package/.env.test

@@ -0,0 +1,8 @@
+# connects with the machtest developer account
+ANEARAPP_API_KEY=a197d1e4da2bfd4bb5d85ca82553f14f4fad2c5c650c25f49c8514eb80ef4fe1
+ANEARAPP_API_VERSION=v1
+ANEARAPP_APP_ID=e64a78d8-48f5-44f7-8b89-af2d6977a8c2
+ANEARAPP_LOGGER_FILE=logs/development.log
+ANEARAPP_LOGGER_LEVEL=debug
+ANEARAPP_ABLY_LOG_LEVEL=2
+ANEARAPP_PRESENCE_TIMEOUT_SECONDS=3600

package/__mocks__/api/AnearApi.js

@@ -0,0 +1,30 @@
+"use strict"
+
+const logger = require('../../lib/utils/Logger')
+const AnearAppData = require('../../tests/fixtures/AnearAppFixture')
+
+class AnearApi {
+  constructor(apiKey, apiVersion) {
+    this.apiKey = apiKey
+    this.apiVersion = apiVersion
+  }
+
+  getAccount() {
+  }
+
+  getApp() {
+    return Promise.resolve(AnearAppData)
+  }
+
+  async transitionEvent(eventId, eventName='next') {
+    return {state: "announce"}
+  }
+
+  getEventParticipant(participantId, geoLocation) {
+    return Promise.resolve(new AnearParticipant({}, {}))
+  }
+}
+
+const anearApiInstance = new AnearApi()
+
+module.exports = anearApiInstance

package/__mocks__/utils/RealtimeMessaging.js

@@ -0,0 +1,17 @@
+"use strict"
+
+const logger = require('../../lib/utils/Logger')
+
+class RealtimeMessaging {
+  initRealtime(appId, appMachine) {
+    return this
+  }
+
+  getChannel(channelName) {
+    return {}
+  }
+}
+
+const realtimeMessagingInstance = new RealtimeMessaging()
+
+module.exports = realtimeMessagingInstance

package/jest.config.js

@@ -0,0 +1,9 @@
+require('dotenv').config({ path: '.env.test' })
+module.exports = {
+  // Jest configuration options...
+  moduleNameMapper: {
+    'AnearApi': '<rootDir>/__mocks__/api/AnearApi.js',
+    'RealtimeMessaging': '<rootDir>/__mocks__/utils/RealtimeMessaging.js'
+  }
+}
+

package/lib/AnearService.js

@@ -0,0 +1,12 @@
+const AnearCoreServiceMachine = require('./state_machines/AnearCoreServiceMachine')
+
+const AnearService = (appEventMachineFactory, appParticipantMachineFactory = null) => {
+  //
+  // developer provides appEventMachineFactory:
+  //
+  //    appEventMachineFactory = anearEvent => { returns XState Machine) }
+  //    optional appParticipantMachineFactory = anearParticipant => { returns XState Machine) }
+  //
+  AnearCoreServiceMachine(appEventMachineFactory, appParticipantMachineFactory)
+}
+module.exports = AnearService

package/lib/api/AnearApi.js

@@ -3,62 +3,82 @@ const logger = require('../utils/Logger')
 const ApiService = require('./ApiService')
 
 class AnearApi extends ApiService {
-
   constructor(apiKey, apiVersion) {
     super(apiKey, apiVersion)
   }
 
   getAccount() {
     logger.debug("API: GET /accounts")
-
     return this.get("accounts")
   }
 
   getEvent(eventId) {
     logger.debug(`API: GET event ${eventId}`)
-
-    return this.get("events", {id: eventId})
+    return this.get("events", { id: eventId })
   }
 
   getAppZones(appId) {
     logger.debug(`API: GET app_zones ${appId}`)
-
-    return this.get("app_zones", {id: appId})
+    return this.get("app_zones", { id: appId })
   }
 
   getApp(appId) {
     logger.debug(`API: GET app ${appId}`)
-
-    return this.get("apps", {id: appId})
+    return this.get("apps", { id: appId })
   }
 
   getZoneEvents(zoneId) {
     logger.debug(`API: GET zone_events ${zoneId}`)
-
-    return this.get("zone_events", {id: zoneId})
+    return this.get("zone_events", { id: zoneId })
   }
 
-  async transitionEvent(eventId, eventName='next') {
-    logger.debug(`API: POST transition event ${eventName}`)
-
-    const relationships = {event: eventId}
-    const json = await this.post("transitions", {event_name: eventName}, relationships)
+  async transitionEvent(eventId, newStateName) {
+    logger.debug(`API: POST transition event ${newStateName}`)
+    const relationships = { event: eventId }
+    const json = await this.post("transitions", { state: newStateName }, relationships)
     const attrs = json.data.attributes
-    logger.debug(`API: newState is ${attrs.state}`)
     return attrs
   }
 
-  getEventParticipantJson(participantId, geoLocation) {
+  getEventParticipantJson(participantId) {
     logger.debug(`API: GET event_participant ${participantId}`)
-
-    return this.get("event_participants", {id: participantId})
+    return this.get("event_participants", { id: participantId })
   }
 
   getUser(userId) {
     logger.debug(`API: GET user ${userId}`)
+    return this.get("users", { id: userId })
+  }
 
-    return this.get("users", {id: userId})
+  async getAppCssUploadUrl(appId, contentHash, fileSuffix = ".min.css") {
+    logger.debug(`API: POST get app styles upload URL for app ${appId} with suffix ${fileSuffix} and content_hash ${contentHash}`)
+    const postAttrs = { content_hash: contentHash, suffix: fileSuffix }
+    const relationships = { app: appId }
+    const json = await this.post("app_styles", postAttrs, relationships)
+    const attrs = json.data.attributes
+    logger.debug('getAppCssUploadUrl response:', attrs)
+    return attrs
+  }
+
+  async getAppImageAssetsUploadUrls(appId, files) {
+    logger.debug(`API: POST get image assets upload URLs for app ${appId}`)
+    const postAttrs = { files }
+    const relationships = { app: appId }
+    const json = await this.post("app_image_assets", postAttrs, relationships)
+    const attrs = json.data.attributes
+    logger.debug('getAppImageAssetsUploadUrls response:', attrs)
+    return attrs
   }
 }
 
-module.exports = AnearApi
+// Instantiate and export the API immediately
+const apiKey = process.env.ANEARAPP_API_KEY
+const apiVersion = process.env.ANEARAPP_API_VERSION
+
+if (!apiKey || !apiVersion) {
+  throw new Error("API_KEY and API_VERSION must be defined in environment variables")
+}
+
+const anearApiInstance = new AnearApi(apiKey, apiVersion)
+
+module.exports = anearApiInstance

package/lib/api/ApiService.js

@@ -4,7 +4,7 @@ const ErrorResponse = require('./ErrorResponse')
 const qs = require('qs')
 const fetch = require('cross-fetch')
 
-const DeveloperApiURL = 'https://api.anearapp.com/developer/'
+const DeveloperApiURL = 'https://api.anear.me/developer/'
 
 class ApiService {
   constructor(apiKey, apiVersion) {

package/lib/index.js

@@ -1,14 +1,12 @@
 'use strict';
 
+const logger = require('./utils/Logger')
 const JsonApiResource = require('./models/JsonApiResource')
 const JsonApiArrayResource = require('./models/JsonApiArrayResource')
+const AnearService = require('./AnearService')
 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')
 const Fixtures = require('../tests/fixtures')
-const MockMessaging = require('./messaging/__mocks__/AnearMessaging')
 
 module.exports = {
   JsonApiResource,
@@ -16,9 +14,7 @@ module.exports = {
   AnearEvent,
   logger,
   AnearParticipant,
-  AnearMessaging,
-  AnearApiService,
-  Fixtures,
-  MockMessaging,
+  AnearService,
+  Fixtures
 }
 

package/lib/models/AnearEvent.js

@@ -1,65 +1,57 @@
 "use strict"
-
-const { Mutex } = require('async-mutex')
-
-const AnearXstate = require('../utils/AnearXstate')
+const logger = require('../utils/Logger')
 
 const JsonApiResource = require('./JsonApiResource')
-const Participants = require('../utils/Participants')
-const logger = require('../utils/Logger')
 
-const PlayableStates = ['closing', 'closed', 'canceled']
+const UnplayableStates = ['closing', 'closed', 'canceled']
 
 class AnearEvent extends JsonApiResource {
 
-  constructor(json, messaging) {
+  constructor(json) {
     super(json)
     this.zone = this.findIncluded(this.relationships.zone)
     this.app = this.findIncluded(this.zone.relationships.app)
-    this.messaging = messaging
-    this.anearStateMachine = this.initStateMachine(json.previousState)
-    this.participants = new Participants(this, json.participants)
-    this.mutex = new Mutex()
+    this.send = () => {} // until initialized
   }
 
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      participants: this.participants.toJSON(),
-      context: this.stateMachineContext,
-      previousState: this.anearStateMachine.currentState
+  get userId() {
+    return this.relationships.user.data.id
+  }
+
+  get zoneId() {
+    return this.relationships.zone.data.id
+  }
+
+  setMachine(service) {
+    if (service) {
+      this.send = service.send.bind(service)
+    } else {
+      this.send = () => {}
     }
   }
 
-  startStateMachine() {
-    this.anearStateMachine.startService()
+  announceEvent() {
+    this.send("ANNOUNCE")
   }
 
-  stateMachineConfig() {
-    // override in subclass with custom Xstate config
-    return {}
+  startEvent() {
+    this.send("START")
   }
 
-  stateMachineOptions() {
-    // override in subclass with custom Xstate options
-    return {}
+  cancelEvent() {
+    this.send("CANCEL")
   }
 
-  initStateMachine(previousState) {
-    return new AnearXstate(
-      this.stateMachineConfig(),
-      this.stateMachineOptions(),
-      previousState,
-      this.context
-    )
+  closeEvent() {
+    this.send("CLOSE")
   }
 
-  get userId() {
-    return this.relationships.user.data.id
+  pauseEvent() {
+    this.send("PAUSE")
   }
 
-  get zoneId() {
-    return this.relationships.zone.data.id
+  resumeEvent() {
+    this.send("RESUME")
   }
 
   getClonedFromEvent() {
@@ -77,11 +69,6 @@ class AnearEvent extends JsonApiResource {
     return clonedFrom ? clonedFrom.context : null
   }
 
-  get stateMachineContext() {
-    // active XState context
-    return this.anearStateMachine.context
-  }
-
   get eventState() {
     return this.attributes.state
   }
@@ -109,243 +96,37 @@ class AnearEvent extends JsonApiResource {
     return this.attributes.flags.includes(flagName)
   }
 
-  get css() {
-    // override with a String of CSS to be sent with each publishEvent*Message
-    // this will be compressed out of the initial publishEvent*Message
-    // and will only be received by the client when the CSS changes.
-    return null;
-  }
-
   allowsSpectators() {
     return !this.hasFlag("no_spectators")
   }
 
-  spectatorCount() {
-    return this.messaging.getSpectatorCount(this)
-  }
-
-  isParticipantEventCreator(RParticipant) {
+  isParticipantEventCreator(participant) {
     return participant.userId === this.userId
   }
 
-  publishEventParticipantsMessage(message, timeoutMsecs=0) {
-    return this.messaging.publishEventParticipantsMessage(
-      this,
-      this.participants.active(),
-      this.css,
-      message,
-      timeoutMsecs
-    )
-  }
-
-  async runExclusive(name, callback) {
-    logger.debug(`waiting for ${name} mutex`)
-
-    await this.mutex.runExclusive(
-      async () => {
-        logger.debug(`mutex ${name} locked!`)
-        await callback()
-      }
-    )
-    logger.debug(`mutex ${name} released!`)
-  }
-
-  publishEventSpectatorsMessage(message, timeoutMsecs = 0) {
-    return this.messaging.publishEventSpectatorsMessage(this, this.css, message, timeoutMsecs, timeoutMsecs)
-  }
-
-  publishEventPrivateMessage(participant, message, timeoutMsecs=0) {
-    return this.messaging.publishEventPrivateMessage(
-      this,
-      participant,
-      this.css,
-      message,
-      timeoutMsecs
-    )
-  }
-
-  publishEventTransitionMessage(newState) {
-    return this.messaging.publishEventTransitionMessage(
-      this,
-      newState
-    )
-  }
-
-  async participantEnter(participant) {
-    // Called each time a participant ENTERs (attaches to) the Event's Action Channel.
-    // This could be when joining an event for the first time, rejoining, or after a browser
-    // refresh/reconnect. If the participant exists in Storage and in this.participants,
-    // its probably due to a browser refresh, and we call Refresh. Else, its either a brand
-    // new participant or an anearEvent recovery after crash, and so we invoke new participant enter
-    //
-    if (participant.exists()) { // persisted in storage?
-      if (this.participants.exists(participant)) {
-        logger.debug(`AnearEvent: participant ${participant.id} exists.  Refreshing...`)
-
-        // Likely here due to participant browser refresh
-        // get the existing participant, turn off his timer and send refresh event to StateMachine
-        const existingParticipant = this.participants.get(participant)
-        existingParticipant.interruptTimer()
-        this.anearStateMachine.sendRefreshEvent({participant: existingParticipant})
-        await existingParticipant.update()
-      } else {
-        // Likely here due to prior AnearEvent error and this is a event reload and restart
-        // add the participants record back into Participants and update persisted copy
-        this.participants.add(participant)
-        this.anearStateMachine.sendJoinEvent({ participant })
-        await participant.update()
-      }
-    } else {
-      // New Participant first-time join this AnearEvent
-      this.participants.add(participant) // add the participants record
-      this.anearStateMachine.sendJoinEvent({ participant })
-      await participant.persist()
-    }
-  }
-
-  participantExit(participant) {
-    // this informs the state machine that the participant has exited the event
-    // and removes that participant completely
-    this.anearStateMachine.sendParticipantExitEvent({ participant })
-    return this.participantPurge(participant)
-  }
-
-  spectatorView(userId) {
-    this.anearStateMachine.sendSpectatorViewEvent({userId})
-  }
-
-  participantPurge(participant) {
-    this.participants.purge(participant)
-    return participant.remove()
-  }
-
-  participantAction(participant, actionEventName, actionPayload) {
-    this.anearStateMachine.sendActionEvent(actionEventName, {participant, payload: actionPayload})
-  }
-
-  participantTimedOut(participant) {
-    this.anearStateMachine.sendTimeoutEvent({ participant })
-  }
-
-  async transitionEvent(eventName='next') {
-    //
-    // Allows the app/game to transition the remote AnearEvent which can un/hide and event
-    // and change its discoverability by mobile web users.  Apps can also determine when
-    // and how many mobile-app users can join and event.
-    //
-    // 1. send the transition event to the Anear API
-    // 2. get back the event newState from Anear API response
-    // 3. publish the new Event State to all subscribers (e.g. participants)
-    //
-    logger.debug(`AnearEvent: transitionEvent(${eventName})`)
-
-    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 !PlayableStates.includes(this.eventState)
-  }
-
-  async transitionToAnnounce() {
-    if (this.eventState === 'created') await this.transitionEvent('announce')
+    return !UnplayableStates.includes(this.eventState)
   }
 
-  async transitionNextNext() {
-    await this.transitionEvent('next')
-    await this.transitionEvent('next')
-  }
-
-  transitionLive() {
-    return this.transitionNextNext()
-  }
-
-  transitionClosed() {
-    return this.transitionNextNext()
-  }
-
-  transitionCanceled() {
-    return this.transitionEvent('cancel')
-  }
-
-  closeOutParticipants() {
-    // returns a Promise
-    // upon exiting the event, this will clean up any participants remaining
-    // by closing out their messaging channels and purging them
-    return Promise.all(
-      this.participants.all.map(
-        p => {
-          return this.messaging.closeParticipant(
-            this,
-            p.id,
-            async (anearEvent, participant) => {
-              await anearEvent.participantPurge(participant)
-            }
-          )
-        }
-      )
-    )
-  }
-
-  purgeParticipants() {
-    // returns a Promise
-    // remove participants and host from Participants class and from Storage
-    const all = this.participants.all
-    if (this.participants.host) all.push(this.participants.host)
-
-    return Promise.all(
-      all.map(p => this.participantPurge(p))
-    )
-  }
-
-  resetParticipantTimers() {
-    // turns off any active AnearParticipant timer
-    this.participants.resetAllTimers()
-  }
-
-  destroyParticipantTimers() {
-    // turns off any active and removes all other AnearParticipant timer
-    this.participants.destroyAllTimers()
-  }
-
-  eventChannelName () {
+  get eventChannelName() {
     return this.getChannelName('event')
   }
 
-  participantsChannelName () {
+  get participantsChannelName () {
     return this.getChannelName('participants')
   }
 
-  actionsChannelName () {
+  get actionsChannelName () {
     return this.getChannelName('actions')
   }
 
-  spectatorsChannelName () {
+  get spectatorsChannelName () {
     return this.getChannelName('spectators')
   }
 
   getChannelName (key) {
     return this.attributes[`${key}-channel-name`]
   }
-
-  async closeEvent() {
-    await this.closeOutParticipants()
-    await this.closeMessaging()
-  }
-
-  closeMessaging () {
-    return this.messaging.detachAll(this.id)
-  }
-
-  logDebugMessage(...args) {
-    logger.debug(...args)
-  }
-
-  logError(context, event) {
-    logger.error("XState: ERROR: ", event.data)
-  }
 }
 
 module.exports = AnearEvent