anear-js-api 0.3.30 → 0.3.32

package/lib/messaging/AnearMessaging.js

@@ -155,11 +155,11 @@ class AnearMessaging {
   }
 
   async getAnearEventFromStorage(eventId) {
-    return await this.AnearEventClass.getFromStorage(eventId, this)
+    return await this.AnearEventClass.getFromStorage(eventId, this.AnearParticipantClass, this)
   }
 
-  async getAnearParticipantFromStorage(participantId) {
-    return await this.AnearParticipantClass.getFromStorage(participantId)
+  async getAnearParticipantFromStorage(participantId, anearEvent) {
+    return await this.AnearParticipantClass.getFromStorage(participantId, anearEvent)
   }
 
   async initEventRealtimeMessaging(anearEvent) {
@@ -194,7 +194,7 @@ class AnearMessaging {
 
     try {
       const eventJson = JSON.parse(message.data)
-      const anearEvent = new this.AnearEventClass(eventJson, this)
+      const anearEvent = new this.AnearEventClass(eventJson, this.AnearParticipantClass, this)
 
       //
       // if we are getting this event create message from history after a quick restart,
@@ -246,12 +246,13 @@ class AnearMessaging {
 
         for (const eventData of events) {
           const eventJson = await this.api.getEvent(eventData.id)
-          const anearEvent = new this.AnearEventClass(eventJson, this)
-          // THIS does NOT work yet.  This is logic that restarte events in progress
-          // if the nodeJS process crahsed during play
+          const anearEvent = new this.AnearEventClass(eventJson, this.AnearParticipantClass, this)
+          // This needs work!!
+          // loadedEvent = await this.getAnearEventFromStorage(anearEvent.id)
+          // await this.refreshActiveParticipants(loadedEvent)
+          //  await this.initEventRealtimeMessaging(loadedEvent)
+          //  loadedEvent.startStateMachine()
           //
-          // const loadedEvent = await this.loadOrPersistEventAndInitialize(anearEvent)
-          // await this.refreshActiveParticipants(loadedEvent) DOES NOT WORK YET
         }
       }
     } catch (err) {
@@ -260,16 +261,8 @@ class AnearMessaging {
   }
 
   async refreshActiveParticipants(anearEvent) {
-    const allParticipants = anearEvent.participants.active
-
-    return Promise.all(
-      allParticipants.map(
-        participant => this.processParticipantEnter(
-          anearEvent,
-          participant.id,
-          participant.geoLocation
-        )
-      )
+    await this.participants.reloadFromStorage(
+      p => this.processParticipantEnter(anearEvent, p.id, p.geoLocation)
     )
   }
 
@@ -416,11 +409,11 @@ class AnearMessaging {
     //
     try {
       const participantJson = await this.api.getEventParticipantJson(participantId)
-      const participant = new this.AnearParticipantClass(participantJson)
+      const participant = new this.AnearParticipantClass(participantJson, anearEvent)
 
       participant.geoLocation = geoLocation
 
-      const persistedAnearParticipant = await this.AnearParticipantClass.getFromStorage(participantId)
+      const persistedAnearParticipant = await this.getAnearParticipantFromStorage(participantId, anearEvent)
 
       if (persistedAnearParticipant) {
         participant.context = persistedAnearParticipant.context
@@ -471,7 +464,7 @@ class AnearMessaging {
 
     this.destroyParticipantTimer(participantId)
 
-    const participant = await this.getAnearParticipantFromStorage(participantId)
+    const participant = await this.getAnearParticipantFromStorage(participantId, anearEvent)
 
     if (participant) {
       await this.detachParticipantPrivateChannel(anearEvent.id, participant)
@@ -515,7 +508,7 @@ class AnearMessaging {
     const actionJSON = JSON.parse(payload)
     const [actionEventName, actionPayload] = Object.entries(actionJSON)[0]
 
-    const participant = await this.getAnearParticipantFromStorage(participantId)
+    const participant = await this.getAnearParticipantFromStorage(participantId, anearEvent)
 
     await this.runExclusive("participantActionCallback", async () => {
       await anearEvent.participantAction(participant, actionEventName, actionPayload)

package/lib/models/AnearEvent.js

@@ -11,21 +11,21 @@ const PrivateDisplayMessageType  = 'private_display'
 
 class AnearEvent extends JsonApiResource {
 
-  constructor(json, messaging) {
+  constructor(json, anearParticipantClass, messaging) {
     super(json)
-
-    this.messaging = messaging
     this.zone = this.findIncluded(this.relationships.zone)
     this.app = this.findIncluded(this.zone.relationships.app)
-    this.participants = new Participants(json.participants)
+    this.anearParticipantClass = anearParticipantClass
+    this.messaging = messaging
     this.anearStateMachine = this.initStateMachine(json.previousState)
+    this.participants = new Participants(this, json.participants)
   }
 
   toJSON() {
     return {
       ...super.toJSON(),
-      context: this.stateMachineContext,
       participants: this.participants.toJSON(),
+      context: this.stateMachineContext,
       previousState: this.anearStateMachine.currentState
     }
   }
@@ -207,13 +207,13 @@ class AnearEvent extends JsonApiResource {
     if (this.participants.exists(participant)) {
       logger.info(`AnearEvent: participant ${participant.id} exists.  Refreshing...`)
 
-      this.participants.add(this, participant) // update the participants entry
+      this.participants.add(participant) // update the participants entry
 
       this.anearStateMachine.sendRefreshEvent({ participant })
 
       await participant.update()
     } else {
-      this.participants.add(this, participant) // add the participants entry
+      this.participants.add(participant) // add the participants entry
 
       this.anearStateMachine.sendJoinEvent({ participant })
 
@@ -301,7 +301,7 @@ class AnearEvent extends JsonApiResource {
     return Promise.all(
       this.participants.all.map(
         async p => {
-          const participant = await this.getAnearParticipantFromStorage(p.id)
+          const participant = await this.messaging.getAnearParticipantFromStorage(p.id)
           await this.messaging.closeParticipant(
             this,
             participant.id,
@@ -314,6 +314,24 @@ class AnearEvent extends JsonApiResource {
     )
   }
 
+  async purgeParticipants() {
+    // remove participants from Participants class and from Storage
+    const all = this.participants.all
+    if (this.participants.host) all.push(this.participants.host)
+
+    await Promise.all(
+      all.map(p => this.participantPurge(p))
+    )
+  }
+
+  async reloadParticipantsFromStorage() {
+    // rehydrate the anearEvent participants and host from storage
+    const participants = await Promise.all(
+      this.participants.ids.map(pid => this.anearParticipantClass.getFromStorage(pid, this))
+    )
+    this.participants.load(participants)
+  }
+
   eventChannelName () {
     return this.getChannelName('event')
   }

package/lib/models/AnearParticipant.js

@@ -3,13 +3,38 @@ const JsonApiResource = require('./JsonApiResource')
 const HostUserType = "host"
 
 class AnearParticipant extends JsonApiResource {
+  constructor(json, anearEvent) {
+    super(json)
+    this.anearEvent = anearEvent
+    this._state = json.state
+    this._timestamp = json.timestamp
+  }
+
   toJSON() {
     return {
       ...super.toJSON(),
       geoLocation: this._geoLocation || null,
+      state: this.state,
+      timestamp: this.timestamp
     }
   }
 
+  get state() {
+    return this._state
+  }
+
+  set state(s) {
+    this._state = s
+  }
+
+  get timestamp() {
+    return this._timestamp
+  }
+
+  set timestamp(t) {
+    this._timestamp = t
+  }
+
   set geoLocation(loc) {
     this._geoLocation = loc
   }
@@ -18,10 +43,6 @@ class AnearParticipant extends JsonApiResource {
     return this._geoLocation
   }
 
-  get identity() {
-    return (({ id, userId, name, avatarUrl, geoLocation}) => ({ id, userId, name, avatarUrl, geoLocation}))(this)
-  }
-
   get userId() {
     return this.relationships.user.data.id
   }

package/lib/utils/Participants.js

@@ -6,41 +6,44 @@ const IdleState   = "idle"
 const MINUTES = (60 * 1000)
 const HOURS = (60 * MINUTES)
 const DefaultIdleMsecs = (30 * MINUTES)
-const DefaultPurgeMsecs = (2 * HOURS)
-
-const DefaultSettings = {
-  participants: {},
-  host: {},
-  idleMsecs: DefaultIdleMsecs,
-  purgeMsecs: DefaultPurgeMsecs
-}
+const DefaultPurgeMsecs = (2 * HOURS) // after Idle
 
 class Participants {
 
-  constructor(json) {
-    const init = json || JSON.parse(JSON.stringify(DefaultSettings))
-    this._participants = init.participants
-    this._host = init.host
-    this.idleMsecs = init.idleMsecs // how long Active participants
-    this.purgeMsecs = init.purgeMsecs
+  constructor(anearEvent, {idleMsecs = DefaultIdleMsecs, purgeMsecs = DefaultPurgeMsecs, ids = []} = {}) {
+    this.anearEvent = anearEvent
+    this.idleMsecs = idleMsecs
+    this.purgeMsecs = purgeMsecs
+    this._participants = {}
+    for (const id of ids) {
+      // app restart logic ...
+      // seeds from ids with empty objects awaiting full
+      // anearParticipant rehydration from redis
+      this._participants[id] = {}
+    }
+    this._host = null
   }
 
   toJSON() {
     return {
-      participants: this._participants,
-      host: this._host,
+      // only output the active participant ids.
+      ids: this.all.map(p => p.id),
       idleMsecs: this.idleMsecs,
       purgeMsecs: this.purgeMsecs
     }
   }
 
+  get ids() {
+    return Object.keys(this._participants)
+  }
+
   indexedById() {
     // returns an object that has AnearParticipant.id as key
     return this._participants
   }
 
-  getById(anearParticipantId) {
-    return this._participants[anearParticipantId]
+  getById(participantId) {
+    return this._participants[participantId]
   }
 
   exists({id}) {
@@ -55,29 +58,33 @@ class Participants {
     return this._host
   }
 
+  set host(h) {
+    this._host = h
+  }
+
   get all() {
     return Object.values(this._participants).
       sort((ca, cb) => ca.timestamp - cb.timestamp)
   }
 
-  active() {
+  get active() {
     return Object.values(this._participants).filter(c => c.state === ActiveState)
   }
 
-  idle() {
+  get idle() {
     return Object.values(this._participants).filter(c => c.state === IdleState)
   }
 
   get count() {
-    return Object.keys(this._participants).length
+    return this.ids.length
   }
 
-  numActive() {
-    return this.active().length
+  get numActive() {
+    return this.active.length
   }
 
-  numIdle() {
-    return this.idle().length
+  get numIdle() {
+    return this.idle.length
   }
 
   isIdle(c, currentTimestamp) {
@@ -108,8 +115,7 @@ class Participants {
       }
     }
 
-    const keys = Object.keys(this._participants)
-    keys.forEach(
+    this.ids.forEach(
       k => {
         const c = this._participants[k]
         sweeper(c)
@@ -117,34 +123,33 @@ class Participants {
     )
   }
 
-  add(anearEvent, anearParticipant) {
-    const rec = this.participantRec(anearParticipant)
-
-    if (anearParticipant.isHost() && anearEvent.hosted) {
+  add(anearParticipant, withTimestamp = this.currentTimestamp) {
+    if (anearParticipant.isHost() && this.anearEvent.hosted) {
       // the host is not an eligible participant and isn't active nor idle
-      this._host = rec
+      this.host = anearParticipant
     } else {
-      this.markActive(anearParticipant)
+      this._participants[anearParticipant.id] = anearParticipant
+      this.markActive(anearParticipant, withTimestamp)
     }
-    return rec
+    return anearParticipant
   }
 
-  markActive(anearParticipant) {
-    // anearParticipant has shown activity in the event (e.g. Action)
-    const participant = this.get(anearParticipant)
-    if (participant) {
-      participant.timestamp = this.currentTimestamp
-      participant.state = ActiveState
-    } else {
-      this._participants[anearParticipant.id] = this.participantRec(anearParticipant)
-    }
+  markActive(anearParticipant, withTimestamp = this.currentTimestamp) {
+    anearParticipant.timestamp = withTimestamp
+    anearParticipant.state = ActiveState
   }
 
-  purge({id}) {
-    if (id === this.host.id) {
-      this._host = JSON.parse(JSON.stringify(DefaultSettings)).host
+  purge(participant) {
+    if (!participant) return
+
+    const {id} = participant
+
+    if (this.host && (id === this.host.id)) {
+      this.host = null
     } else {
-      if (this._participants[id]) delete this._participants[id]
+      if (this._participants[id]) {
+        delete this._participants[id]
+      }
     }
   }
 
@@ -152,12 +157,17 @@ class Participants {
     return new Date().getTime()
   }
 
-  participantRec(anearParticipant, state = ActiveState) {
-    return {
-      ...anearParticipant.identity,
-      state,
-      timestamp: this.currentTimestamp
-    }
+  load(anearParticipants) {
+    // used for tests only
+    anearParticipants.forEach(
+      p => {
+        if (p.isHost() && this.anearEvent.hosted) {
+          this.host = p
+        } else {
+          this._participants[p.id] = p
+        }
+      }
+    )
   }
 }
 

package/package.json

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

package/tests/AnearEvent.test.js

@@ -142,14 +142,14 @@ afterAll(async () => await TestEvent.close())
 afterEach(() => {jest.clearAllMocks()})
 
 const newTestEvent = (hosted = false) => {
-  const t = new TestEvent(chatEvent, MessagingStub)
+  const t = new TestEvent(chatEvent, TestPlayer, MessagingStub)
   t.attributes.hosted = hosted
   t.startStateMachine()
   return t
 }
 
 const newTestEventWithDefaultXState = testEvent => {
-  const t = new TestEventWithDefaultXState(testEvent, MessagingStub)
+  const t = new TestEventWithDefaultXState(testEvent, TestPlayer, MessagingStub)
   t.startStateMachine()
   return t
 }
@@ -162,7 +162,7 @@ test('participant enter with Default Xstate Config', async () => {
   expect(t.relationships.user.data.type).toBe("users")
   expect(t.anearStateMachine.currentState.value).toBe("eventActive")
   expect(t.stateMachineContext.playerScores[0]).toBe(83)
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
 
   await t.participantEnter(p1)
   await t.persist()
@@ -171,7 +171,7 @@ test('participant enter with Default Xstate Config', async () => {
   expect(p1.userType).toBe("participant")
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(1)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p1)
-  expect(t.participants.numActive(false)).toBe(1)
+  expect(t.participants.numActive).toBe(1)
 
   await p1.remove()
 })
@@ -179,21 +179,21 @@ test('participant enter with Default Xstate Config', async () => {
 test('participant close with Default Xstate Config', async () => {
   const t = newTestEventWithDefaultXState(chatEvent)
 
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
 
   await t.participantExit(p1)
   await t.update()
 
   expect(mockParticipantExitHandler).toHaveBeenCalledWith(p1)
   expect(mockParticipantExitHandler).toHaveBeenCalledTimes(1)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(t.participants.numActive).toBe(0)
 
   await t.remove()
 })
 
 test('participant refresh with Default Xstate Config', async () => {
   const t = newTestEventWithDefaultXState(chatEvent)
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
 
   await t.refreshParticipant(p1)
   await t.update()
@@ -206,7 +206,7 @@ test('participant refresh with Default Xstate Config', async () => {
 
 test('participant action with Default Xstate Config', async () => {
   const t = newTestEventWithDefaultXState(chatEvent)
-  const p1 = new TestPlayer(chatParticipant1)
+  const p1 = new TestPlayer(chatParticipant1, t)
   const eventName = "TEST_ACTION"
   const payload = {x: 1, y: 99}
 
@@ -230,8 +230,8 @@ test('can be persisted and removed repeatedly in storage', async () => {
 
 test('can add participants, not hosted', async () => {
   let t = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1)
-  const p2 = new TestPlayer(chatParticipant2)
+  const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
   const id = t.id
 
   await t.participantEnter(p1)
@@ -240,15 +240,15 @@ test('can add participants, not hosted', async () => {
   expect(p1.userType).toBe("participant")
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(1)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p1)
-  expect(t.participants.numActive(false)).toBe(1)
-  expect(t.participants.host).toStrictEqual({})
+  expect(t.participants.numActive).toBe(1)
+  expect(t.participants.host).toBe(null)
 
   await t.participantEnter(p2)
   await t.update()
 
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(2)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p2)
-  expect(t.participants.numActive(false)).toBe(2)
+  expect(t.participants.numActive).toBe(2)
   expect(t.participants.get(p2).name).toBe("bbondfl93")
   expect(p2.userType).toBe("participant")
 
@@ -260,7 +260,27 @@ test('can add participants, not hosted', async () => {
   expect(mockParticipantExitHandler).toHaveBeenCalledWith(p1)
   expect(mockParticipantExitHandler).toHaveBeenCalledWith(p2)
   expect(mockParticipantExitHandler).toHaveBeenCalledTimes(2)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(t.participants.numActive).toBe(0)
+})
+
+test('purge all participants', async () => {
+  let t = newTestEvent(true)
+  const host = new TestPlayer(chatHost, t)
+  const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
+  await t.participantEnter(host)
+  await t.participantEnter(p1)
+  await t.participantEnter(p2)
+  await t.update()
+
+  expect(t.participants.host).toBe(host)
+  expect(t.participants.ids).toStrictEqual([p1.id, p2.id])
+
+  await t.purgeParticipants()
+
+  expect(t.participants.all).toHaveLength(0)
+
+  await t.remove()
 })
 
 
@@ -268,10 +288,10 @@ test('can add participant, hosted', async () => {
   let t = newTestEvent(true)
 
   expect(t.hosted).toBe(true)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(t.participants.numActive).toBe(0)
 
-  const host = new TestPlayer(chatHost)
-  const p2 = new TestPlayer(chatParticipant2)
+  const host = new TestPlayer(chatHost, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
   const id = t.id
 
   await t.participantEnter(host)
@@ -281,14 +301,14 @@ test('can add participant, hosted', async () => {
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(1)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(host)
   expect(t.participants.host.name).toBe('foxhole_host')
-  expect(t.participants.numActive(false)).toBe(0) // event creator when hosted isn't active participant
+  expect(t.participants.numActive).toBe(0) // event creator when hosted isn't active participant
 
   await t.participantEnter(p2)
   await t.update()
 
   expect(mockParticipantEnterHandler).toHaveBeenCalledTimes(2)
   expect(mockParticipantEnterHandler).toHaveBeenCalledWith(p2)
-  expect(t.participants.numActive(false)).toBe(1)
+  expect(t.participants.numActive).toBe(1)
   expect(t.participants.get(p2).name).toBe('bbondfl93')
 
   await t.participantExit(host)
@@ -299,43 +319,46 @@ test('can add participant, hosted', async () => {
   expect(mockParticipantExitHandler).toHaveBeenCalledWith(host)
   expect(mockParticipantExitHandler).toHaveBeenCalledWith(p2)
   expect(mockParticipantExitHandler).toHaveBeenCalledTimes(2)
-  expect(t.participants.numActive(false)).toBe(0)
+  expect(t.participants.numActive).toBe(0)
 })
 
 test('can be retrieved back from storage with participants, not hosted', async () => {
   const testEvent = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1)
-  const p2 = new TestPlayer(chatParticipant2)
+  const p1 = new TestPlayer(chatParticipant1, testEvent)
+  const p2 = new TestPlayer(chatParticipant2, testEvent)
 
   await testEvent.participantEnter(p1)
   await testEvent.participantEnter(p2)
   await testEvent.persist()
 
-  const rehydratedTestEvent = await TestEvent.getFromStorage(testEvent.id, MessagingStub)
-  const rehydratedPlayer1 = await TestPlayer.getFromStorage(p1.id)
-  const rehydratedPlayer2 = await TestPlayer.getFromStorage(p2.id)
+  const rehydratedTestEvent = await TestEvent.getFromStorage(testEvent.id, TestPlayer, MessagingStub)
+  await rehydratedTestEvent.reloadParticipantsFromStorage()
 
   rehydratedTestEvent.startStateMachine()
 
-  expect(rehydratedTestEvent.participants.numActive(false)).toBe(2)
+  expect(rehydratedTestEvent.participants.numActive).toBe(2)
   expect(rehydratedTestEvent.id).toBe(testEvent.id)
   expect(rehydratedTestEvent.relationships['user'].data.type).toBe("users")
   expect(rehydratedTestEvent.relationships['zone'].data.type).toBe("zones")
   expect(rehydratedTestEvent.participantTimeout).toBe(32000)
   expect(rehydratedTestEvent.stateMachineContext.score).toBe(90)
   expect(rehydratedTestEvent.included[0].relationships.app.data.id).toBe("5b9d9838-17de-4a80-8a64-744c222ba722")
-  expect(rehydratedPlayer1.context.name).toBe('machvee')
-  expect(rehydratedPlayer2.context.name).toBe('bbondfl93')
 
-  await rehydratedTestEvent.participantExit(rehydratedPlayer1)
-  await rehydratedTestEvent.participantExit(rehydratedPlayer2)
+  const rp1 = rehydratedTestEvent.participants.getById(p1.id)
+  const rp2 = rehydratedTestEvent.participants.getById(p2.id)
+
+  expect(rehydratedTestEvent.participants.getById(rp1.id).context.name).toBe('machvee')
+  expect(rehydratedTestEvent.participants.getById(rp2.id).context.name).toBe('bbondfl93')
+
+  await rehydratedTestEvent.participantExit(rp1)
+  await rehydratedTestEvent.participantExit(rp2)
   await rehydratedTestEvent.remove()
 })
 
 test('can update state machine context via Action events', async () => {
   const t = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1)
-  const p2 = new TestPlayer(chatParticipant2)
+  const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
 
   await t.participantEnter(p1)
   await t.participantEnter(p2)
@@ -362,8 +385,8 @@ test('can update state machine context via Action events', async () => {
 
 test('can reset All ParticipantTimers', async () => {
   const t = newTestEvent(false)
-  const p1 = new TestPlayer(chatParticipant1)
-  const p2 = new TestPlayer(chatParticipant2)
+  const p1 = new TestPlayer(chatParticipant1, t)
+  const p2 = new TestPlayer(chatParticipant2, t)
 
   const resetMock = jest.spyOn(MessagingStub, "resetAllParticipantTimers");
 

package/tests/AnearParticipant.test.js

@@ -2,6 +2,8 @@ const AnearParticipant = require('../lib/models/AnearParticipant')
 
 const { AnearParticipantFixture1: player1 } =  require('./fixtures')
 
+const MockEvent = {}
+
 class TestParticipant extends AnearParticipant {
   initContext() {
     return {score: 97, responses: ['A', 'C', 'D', 'A']}
@@ -11,26 +13,29 @@ class TestParticipant extends AnearParticipant {
 afterAll(async () => await TestParticipant.close())
 
 test('constructor', () =>  {
-  const t = new TestParticipant(player1)
+  const t = new TestParticipant(player1, MockEvent)
   expect(t.id).toBe(player1.data.id)
   expect(t.relationships.user.data.type).toBe("users")
   expect(t.context.score).toBe(97)
+  expect(t.anearEvent).toBe(MockEvent)
 })
 
 test('participant can be repeatedly rehydrated and updated', async () => {
   try {
-    const participant = new TestParticipant(player1)
+    const participant = new TestParticipant(player1, MockEvent)
     await participant.persist()
 
-    let p = await TestParticipant.getFromStorage(player1.data.id)
+    let p = await TestParticipant.getFromStorage(player1.data.id, MockEvent)
 
     expect(p.context.responses).toStrictEqual(['A', 'C', 'D', 'A'])
+    expect(p.anearEvent).toBe(MockEvent)
     p.context.responses.push('B')
 
     await p.update()
 
-    p = await TestParticipant.getFromStorage(player1.data.id)
+    p = await TestParticipant.getFromStorage(player1.data.id, MockEvent)
     expect(p.context.responses[4]).toBe('B')
+    expect(p.anearEvent).toBe(MockEvent)
 
     await p.remove()
 

package/tests/Participants.test.js

@@ -5,6 +5,7 @@ const { ParticipantsFixture: participantsJSON,
         AnearParticipantFixture2: visitor2JSON,
         AnearHostFixture: hostJSON } = require('./fixtures')
 const AnearParticipant = require('../lib/models/AnearParticipant')
+const AnearParticipantJSONBuilder = require('./utils/AnearParticipantJSONBuilder')
 
 const user1Id = "e053977c-dcb6-40e0-b7b8-e3dbd70ec8fd"
 const idleId = "f1056e6c-c393-4617-8a06-67ba9d2f4b8a"
@@ -12,61 +13,80 @@ const activeId = user1Id
 const hours24 = (24 * 60 * 60 * 1000)
 const GeoLocation = {lat: 25.8348343, lng: -80.38438434}
 
-const MockHostedEvent = {hosted: true}
-const MockNonHostedEvent = {hosted: false}
-
-const newActiveParticipants = (timestamp, json = participantsJSON) => {
-  const copy = JSON.parse(JSON.stringify(json))
-  const keys = Object.keys(copy.participants)
-  keys.forEach(
-    (k,i) => {
-      const p = copy.participants[k]
-      p.timestamp = timestamp - (i*2000)
-      p.state = 'active'
+const MockHostedEvent = {hosted: true, anearParticipantClass: AnearParticipant}
+const MockNonHostedEvent = {hosted: false, anearParticipantClass: AnearParticipant}
+
+const newActiveParticipants = (timestamp, args = {}) => {
+  const copyParticipantsFixture = JSON.parse(JSON.stringify(participantsJSON))
+  const activeParticipants = Object.values(copyParticipantsFixture).filter(p => !p.isHost)
+
+  const participants = new Participants(MockHostedEvent, args)
+
+  activeParticipants.forEach(
+    (attrs, i) => {
+      const participant = new AnearParticipant(AnearParticipantJSONBuilder(attrs), MockHostedEvent)
+      participant.host = attrs.isHost
+      participants.add(participant, timestamp - (i*2000))
     }
   )
-  return new Participants(copy)
+  return participants
 }
 
-const newCurrentParticipants = (timestamp, json = participantsJSON) => {
-  const copy = JSON.parse(JSON.stringify(json))
-  const keys = Object.keys(copy.participants)
-  keys.forEach(
-    (k,i) => {
-      const p = copy.participants[k]
-      if (p.state === 'active') {
-        p.timestamp = timestamp - (i*2000)
+const newCurrentParticipants = (timestamp, anearEvent = MockHostedEvent) => {
+  const copyParticipantsFixture = JSON.parse(JSON.stringify(participantsJSON))
+  const currentParticipants= Object.values(copyParticipantsFixture).filter(p => !p.isHost)
+
+  const participants = new Participants(anearEvent)
+
+  const anearParticipants = currentParticipants.map(
+    (attrs, i) => {
+      const participant =  new AnearParticipant(AnearParticipantJSONBuilder(attrs), anearEvent)
+
+      let withTimestamp
+      if (attrs.state === 'active') {
+        withTimestamp = timestamp - (i*2000)
       } else {
-        // idle in the last 30 minutes
-        p.timestamp = timestamp - copy.idleMsecs
+        withTimestamp = timestamp - participants.idleMsecs
       }
+
+      participant.state = attrs.state
+      participant.timestamp = withTimestamp
+      participant.host = attrs.isHost
+      return participant
     }
   )
-  return new Participants(copy)
+
+  participants.load(anearParticipants)
+
+  return participants
 }
 
 const now = new Date().getTime()
 
 test('constructor with JSON provided', () =>  {
-  const p = new Participants(participantsJSON)
+  const ids = ['123', '345', '456']
+  const args = {idleMsecs: 23400, purgeMsecs: 678900, ids}
+  const p = new Participants(MockHostedEvent, args)
   expect(p).toBeDefined()
-  expect(p.idleMsecs).toBe(participantsJSON.idleMsecs)
+  expect(p.idleMsecs).toBe(args.idleMsecs)
+  expect(p.purgeMsecs).toBe(args.purgeMsecs)
+  expect(p.ids).toStrictEqual(ids)
 })
 
-test('constructor with NO JSON provided', () => {
-  const p = new Participants()
+test('constructor with NO JSON provided has default idle and purge Msecs', () => {
+  const p = new Participants(MockHostedEvent)
   expect(p).toBeDefined()
   expect(p.idleMsecs).toBe(1800000)
   expect(p.purgeMsecs).toBe(7200000)
   expect(p.all).toHaveLength(0)
 })
 
-test('constructor with null idle and purge msecs', () => {
-  const p = newActiveParticipants(now, {...participantsJSON, idleMsecs: null, purgeMsecs: null})
+test('constructor with null idle and purge msecs avoids idle purge', () => {
+  const p = newActiveParticipants(now, {idleMsecs: null, purgeMsecs: null})
   expect(p.idleMsecs).toBe(null)
   expect(p.purgeMsecs).toBe(null)
-  expect(p.idle()).toHaveLength(0)
-  expect(p.active()).toHaveLength(10)
+  expect(p.idle).toHaveLength(0)
+  expect(p.active).toHaveLength(10)
 
   const c = p.getById(idleId)
   expect(p.isIdle(c, now)).toBeFalsy()
@@ -99,23 +119,17 @@ test('getParticipant fail', () =>  {
   expect(p.get({id: "abcd"})).toBeUndefined()
 })
 
-test('host', () =>  {
-  const p = newActiveParticipants(now)
-  const host = p.host
-  expect(host.name).toBe("the_host")
-})
-
 test('getParticipant success', () =>  {
   const p = newActiveParticipants(now)
   expect(p.get({id: user1Id}).name).toBe("user1")
 })
 
 test('add() participant user', async () => {
-  const p = newCurrentParticipants(now)
-  const participant = new AnearParticipant(visitor2JSON)
+  const p = newCurrentParticipants(now, MockNonHostedEvent)
+  const participant = new AnearParticipant(visitor2JSON, MockNonHostedEvent)
   participant.geoLocation = GeoLocation
 
-  p.add(MockNonHostedEvent, participant)
+  p.add(participant)
   const part = p.get(participant)
   expect(part.name).toBe("bbondfl93")
   expect(part.avatarUrl).toBe("https://s3.amazonaws.com/anearassets/barbara_bond.png")
@@ -126,10 +140,10 @@ test('add() participant user', async () => {
 
 test('add() host user', async () => {
   const p = newCurrentParticipants(now)
-  const host = new AnearParticipant(hostJSON)
+  const host = new AnearParticipant(hostJSON, MockNonHostedEvent)
   host.geoLocation = GeoLocation
 
-  p.add(MockHostedEvent, host)
+  p.add(host)
   expect(p.get(host)).toBeUndefined()
   expect(p.host.name).toBe('foxhole_host')
   expect(p.host.avatarUrl).toBe("https://s3.amazonaws.com/anearassets/foxhole.png")
@@ -139,20 +153,24 @@ test('add() host user', async () => {
 
 test('active', () => {
   const p = newActiveParticipants(now)
-  expect(p.active()).toHaveLength(10)
+  expect(p.active).toHaveLength(10)
 })
 
 test('idle', () => {
   const p = newCurrentParticipants(now)
-  expect(p.idle()).toHaveLength(2)
+  expect(p.idle).toHaveLength(2)
 })
 
 test('toJSON', () => {
-  const p = new Participants(participantsJSON)
+  const p = newActiveParticipants(now)
   const j = p.toJSON()
-  expect(j).toHaveProperty("participants")
+  expect(j).toHaveProperty("ids")
   expect(j).toHaveProperty("idleMsecs")
   expect(j).toHaveProperty("purgeMsecs")
+  expect(j.ids.sort()).toEqual(p.ids.sort())
+  expect(j.ids.length).toBe(10)
+  expect(j.idleMsecs).toBe(1800000)
+  expect(j.purgeMsecs).toBe(7200000)
 })
 
 test('isIdle', () => {
@@ -185,22 +203,22 @@ test('purge host user-type', () => {
   const p = newActiveParticipants(now)
   const c = p.host
   p.purge(c)
-  expect(p.host).toStrictEqual({})
+  expect(p.host).toStrictEqual(null)
 })
 
 test('updateState will leave state unchanged when timeout criteria not met', () => {
   const p = newCurrentParticipants(now)
   p.updateState(now)
-  expect(p.active()).toHaveLength(8)
-  expect(p.idle()).toHaveLength(2)
-  expect(p.numActive()).toBe(8)
-  expect(p.numIdle()).toBe(2)
+  expect(p.active).toHaveLength(8)
+  expect(p.idle).toHaveLength(2)
+  expect(p.numActive).toBe(8)
+  expect(p.numIdle).toBe(2)
 })
 
 test('updateState will mark active to idle when timeout reached', () => {
   const current = now
   const p = newCurrentParticipants(current)
-  expect(p.active()).toHaveLength(8)
+  expect(p.active).toHaveLength(8)
   p.updateState(current + p.idleMsecs + 1000)
   expect(Object.values(p.all).
     filter(p => p.state === 'active')).toHaveLength(0)
@@ -209,7 +227,7 @@ test('updateState will mark active to idle when timeout reached', () => {
 test('updateState will purge idle participants', () => {
   const current = now
   const p = newCurrentParticipants(current)
-  const idlers = p.idle()
+  const idlers = p.idle
   expect(idlers).toHaveLength(2)
   p.updateState(current + p.purgeMsecs + 1000)
   idlers.forEach(c => expect(p.getById(c.id)).toBeUndefined())

package/tests/fixtures/ParticipantsFixture.js

@@ -1,7 +1,6 @@
 "use strict";
-
 module.exports = {
-  host: {
+  "aa396e6c-2193-cd17-eea6-0413eefff893": {
     id: "aa396e6c-2193-cd17-eea6-0413eefff893",
     userId: "044f4dfc-c4d0-4c58-a2fa-9e1e43913dab",
     name: "the_host",
@@ -11,108 +10,104 @@ module.exports = {
     state: "active",
     isHost: true
   },
-  participants: {
-    "e053977c-dcb6-40e0-b7b8-e3dbd70ec8fd": {
-      id: "e053977c-dcb6-40e0-b7b8-e3dbd70ec8fd",
-      userId: "09f3cbf9-0c73-44c6-b6ad-a03b3607e66a",
-      name: "user1",
-      avatarUrl: "https://s3.amazonaws.com/path1",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "0f6ab786-fcae-4e81-87ac-a3930f496d71": {
-      id: "0f6ab786-fcae-4e81-87ac-a3930f496d71",
-      userId: "819635b2-c70d-474c-a0a6-88a420744cb6",
-      name: "user2",
-      avatarUrl: "https://s3.amazonaws.com/path2",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "af9c7ff6-c8c9-4f4a-ad04-bcf86ef57d15": {
-      id: "af9c7ff6-c8c9-4f4a-ad04-bcf86ef57d15",
-      userId: "7966b0b6-1c94-4f2d-abf0-857ccf91119e",
-      name: "user3",
-      avatarUrl: "https://s3.amazonaws.com/path3",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "777b11b5-2b3b-4420-93d2-eff65127c925": {
-      id: "777b11b5-2b3b-4420-93d2-eff65127c925",
-      userId: "0efde18e-39ff-4e26-9aa5-2f7b8d61b2f7",
-      name: "user4",
-      avatarUrl: "https://s3.amazonaws.com/path4",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "6405094a-0ac4-4476-9fd8-5d2edc6cf5a1": {
-      id: "6405094a-0ac4-4476-9fd8-5d2edc6cf5a1",
-      userId: "cdcbbb6a-0a3b-4222-bcde-4a626555f44d",
-      name: "user5",
-      avatarUrl: "https://s3.amazonaws.com/path5",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "dcaabc23-b7dc-47cd-ad11-43022750dc0e": {
-      id: "dcaabc23-b7dc-47cd-ad11-43022750dc0e",
-      userId: "ad6a1e91-6460-4eea-b215-4af4de4e021e",
-      name: "user6",
-      avatarUrl: "https://s3.amazonaws.com/path6",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "78127e6c-c1b8-490d-ace6-afc798fdf4f6": {
-      id: "78127e6c-c1b8-490d-ace6-afc798fdf4f6",
-      userId: "d8584429-4651-4d63-a886-1622941f9b87",
-      name: "user7",
-      avatarUrl: "https://s3.amazonaws.com/path7",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "7166a301-aad9-4bc9-b9f7-66f56bfb16d7": {
-      id: "7166a301-aad9-4bc9-b9f7-66f56bfb16d7",
-      userId: "0fe5311c-42c4-425b-b7a4-0338dc08048f",
-      name: "user8",
-      avatarUrl: "https://s3.amazonaws.com/path8",
-      geoLocation: {},
-      timestamp: 1615649132502,
-      state: "active",
-      isHost: false
-    },
-    "1e168941-4050-4731-8c27-f2464c717c4a": {
-      id: "1e168941-4050-4731-8c27-f2464c717c4a",
-      userId: "69308515-a3af-4ce6-b687-139ef0b87e74",
-      name: "user9",
-      avatarUrl: "https://s3.amazonaws.com/path9",
-      geoLocation: {},
-      timestamp: 1615642032502,
-      state: "idle",
-      isHost: false
-    },
-    "f1056e6c-c393-4617-8a06-67ba9d2f4b8a": {
-      id: "f1056e6c-c393-4617-8a06-67ba9d2f4b8a",
-      userId: "0cc39ce5-f00f-4b81-ab8b-40e630b3a58c",
-      name: "user10",
-      avatarUrl: "https://s3.amazonaws.com/path10",
-      geoLocation: {},
-      timestamp: 1615642032502,
-      state: "idle",
-      isHost: false
-    },
+  "e053977c-dcb6-40e0-b7b8-e3dbd70ec8fd": {
+    id: "e053977c-dcb6-40e0-b7b8-e3dbd70ec8fd",
+    userId: "09f3cbf9-0c73-44c6-b6ad-a03b3607e66a",
+    name: "user1",
+    avatarUrl: "https://s3.amazonaws.com/path1",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
+  },
+  "0f6ab786-fcae-4e81-87ac-a3930f496d71": {
+    id: "0f6ab786-fcae-4e81-87ac-a3930f496d71",
+    userId: "819635b2-c70d-474c-a0a6-88a420744cb6",
+    name: "user2",
+    avatarUrl: "https://s3.amazonaws.com/path2",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
+  },
+  "af9c7ff6-c8c9-4f4a-ad04-bcf86ef57d15": {
+    id: "af9c7ff6-c8c9-4f4a-ad04-bcf86ef57d15",
+    userId: "7966b0b6-1c94-4f2d-abf0-857ccf91119e",
+    name: "user3",
+    avatarUrl: "https://s3.amazonaws.com/path3",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
+  },
+  "777b11b5-2b3b-4420-93d2-eff65127c925": {
+    id: "777b11b5-2b3b-4420-93d2-eff65127c925",
+    userId: "0efde18e-39ff-4e26-9aa5-2f7b8d61b2f7",
+    name: "user4",
+    avatarUrl: "https://s3.amazonaws.com/path4",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
+  },
+  "6405094a-0ac4-4476-9fd8-5d2edc6cf5a1": {
+    id: "6405094a-0ac4-4476-9fd8-5d2edc6cf5a1",
+    userId: "cdcbbb6a-0a3b-4222-bcde-4a626555f44d",
+    name: "user5",
+    avatarUrl: "https://s3.amazonaws.com/path5",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
   },
-  idleMsecs: 1800000,
-  purgeMsecs: 7200000
+  "dcaabc23-b7dc-47cd-ad11-43022750dc0e": {
+    id: "dcaabc23-b7dc-47cd-ad11-43022750dc0e",
+    userId: "ad6a1e91-6460-4eea-b215-4af4de4e021e",
+    name: "user6",
+    avatarUrl: "https://s3.amazonaws.com/path6",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
+  },
+  "78127e6c-c1b8-490d-ace6-afc798fdf4f6": {
+    id: "78127e6c-c1b8-490d-ace6-afc798fdf4f6",
+    userId: "d8584429-4651-4d63-a886-1622941f9b87",
+    name: "user7",
+    avatarUrl: "https://s3.amazonaws.com/path7",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
+  },
+  "7166a301-aad9-4bc9-b9f7-66f56bfb16d7": {
+    id: "7166a301-aad9-4bc9-b9f7-66f56bfb16d7",
+    userId: "0fe5311c-42c4-425b-b7a4-0338dc08048f",
+    name: "user8",
+    avatarUrl: "https://s3.amazonaws.com/path8",
+    geoLocation: {},
+    timestamp: 1615649132502,
+    state: "active",
+    isHost: false
+  },
+  "1e168941-4050-4731-8c27-f2464c717c4a": {
+    id: "1e168941-4050-4731-8c27-f2464c717c4a",
+    userId: "69308515-a3af-4ce6-b687-139ef0b87e74",
+    name: "user9",
+    avatarUrl: "https://s3.amazonaws.com/path9",
+    geoLocation: {},
+    timestamp: 1615642032502,
+    state: "idle",
+    isHost: false
+  },
+  "f1056e6c-c393-4617-8a06-67ba9d2f4b8a": {
+    id: "f1056e6c-c393-4617-8a06-67ba9d2f4b8a",
+    userId: "0cc39ce5-f00f-4b81-ab8b-40e630b3a58c",
+    name: "user10",
+    avatarUrl: "https://s3.amazonaws.com/path10",
+    geoLocation: {},
+    timestamp: 1615642032502,
+    state: "idle",
+    isHost: false
+  }
 }

package/tests/utils/AnearParticipantJSONBuilder.js

@@ -0,0 +1,66 @@
+"use strict";
+const AnearParticipantJSONBuilder = ({eventId, id, userId, name, avatarUrl}) => {
+  return {
+    data: {
+      "id": id,
+      "type": "participants",
+      "attributes": {
+        "created-at": "2019-06-22T08:41:34.257Z",
+        "name": name,
+        "user-type": "participant",
+        "private-channel-name": "anear:a:6i4GPGg7YiE81jxE65vpov:e:51nriTFWJYwiZRVfhaTmOM:private:4aih3BnWiRXLHKupFFkKHO"
+      },
+      "relationships": {
+        "event": {
+          "data": {
+            "id": eventId,
+            "type": "events"
+          }
+        },
+        "user": {
+          "data": {
+            "id": "2d08adc7-b1af-4607-2a86-b45faa03eaa7",
+          "type": "users"
+          }
+        }
+      }
+    },
+    included: [
+      {
+        "id": userId,
+        "type": "users",
+        "attributes": {
+          "name": "dave_mcvicar",
+          "created-at": "2019-06-22T08:41:33.877Z"
+        },
+        "relationships": {
+          "profile": {
+            "data": {
+              "id": "a04976a9-1c08-4bc6-b381-7f0d0637b919",
+              "type": "profiles"
+            }
+          }
+        },
+        "links": {
+          "self": `/v1/users/${userId}`
+        }
+      },
+      {
+        "id": "a04976a9-1c08-4bc6-b381-7f0d0637b919",
+        "type": "profiles",
+        "attributes": {
+          "first-name": "Dave",
+          "last-name": "McVicar",
+          "bio": "Repellendus ut neque. Est autem cupiditate. In omnis dolore.",
+          "homepage": "http://hodkiewicz.name/frankie",
+          "avatar-url": avatarUrl
+        },
+        "links": {
+          "self": "/v1/profiles/b04976a9-1c08-4bc6-b381-7f0d0637b979"
+        }
+      }
+    ]
+  }
+}
+
+module.exports = AnearParticipantJSONBuilder