anear-js-api 1.0.1 → 1.1.2

package/jest.config.js

@@ -1,4 +1,10 @@
 require('dotenv').config({ path: '.env.test' })
+
+// Provide sane defaults so unit tests don't depend on local machine env.
+process.env.ANEARAPP_API_KEY = process.env.ANEARAPP_API_KEY || 'test-api-key'
+process.env.ANEARAPP_API_SECRET = process.env.ANEARAPP_API_SECRET || 'test-api-secret'
+process.env.ANEARAPP_API_VERSION = process.env.ANEARAPP_API_VERSION || 'v1'
+
 module.exports = {
 }
 

package/lib/AnearService.js

@@ -7,6 +7,6 @@ const AnearService = (appEventMachineFactory, appParticipantMachineFactory = nul
   //    appEventMachineFactory = anearEvent => { returns XState Machine) }
   //    optional appParticipantMachineFactory = anearParticipant => { returns XState Machine) }
   //
-  AnearCoreServiceMachine(appEventMachineFactory, appParticipantMachineFactory)
+  return AnearCoreServiceMachine(appEventMachineFactory, appParticipantMachineFactory)
 }
 module.exports = AnearService

package/lib/api/AnearApi.js

@@ -3,8 +3,8 @@ const logger = require('../utils/Logger')
 const ApiService = require('./ApiService')
 
 class AnearApi extends ApiService {
-  constructor(apiKey, apiVersion) {
-    super(apiKey, apiVersion)
+  constructor(apiKey, apiSecret, apiVersion) {
+    super(apiKey, apiSecret, apiVersion)
   }
 
   getAccount() {
@@ -105,12 +105,13 @@ class AnearApi extends ApiService {
 
 // Instantiate and export the API immediately
 const apiKey = process.env.ANEARAPP_API_KEY
+const apiSecret = process.env.ANEARAPP_API_SECRET
 const apiVersion = process.env.ANEARAPP_API_VERSION
 
-if (!apiKey || !apiVersion) {
-  throw new Error("API_KEY and API_VERSION must be defined in environment variables")
+if (!apiKey || !apiSecret || !apiVersion) {
+  throw new Error("ANEARAPP_API_KEY, ANEARAPP_API_SECRET, and ANEARAPP_API_VERSION must be defined in environment variables")
 }
 
-const anearApiInstance = new AnearApi(apiKey, apiVersion)
+const anearApiInstance = new AnearApi(apiKey, apiSecret, apiVersion)
 
 module.exports = anearApiInstance

package/lib/api/ApiService.js

@@ -13,19 +13,81 @@ const logger = require('../utils/Logger')
 const DEFAULT_DEVELOPER_API_URL = 'https://api.anear.me/developer'
 
 class ApiService {
-  constructor(apiKey, apiVersion) {
+  constructor(apiKey, apiSecret, apiVersion) {
     const baseUrl = (process.env.ANEARAPP_API_URL || DEFAULT_DEVELOPER_API_URL).replace(/\/+$/, '')
     const versionSegment = apiVersion ? `/${apiVersion}` : ''
     this.api_base_url = `${baseUrl}${versionSegment}`
     logger.debug(`ApiService configured api_base_url=${this.api_base_url}`)
+
+    this.api_key = apiKey
+    this.api_secret = apiSecret
+    this.developer_auth = null
+    this._authPromise = null
+
     this.defaultHeaderObject = {
       'Accept': 'application/json',
-      'Content-Type': 'application/json',
-      'X-Api-Key': apiKey
+      'Content-Type': 'application/json'
     }
     this.default_headers = new fetch.Headers(this.defaultHeaderObject)
   }
 
+  async ensureDeveloperAuth() {
+    const now = Math.floor(Date.now() / 1000)
+    if (this.developer_auth && this.developer_auth.expires_at && this.developer_auth.expires_at > now) {
+      return this.developer_auth
+    }
+
+    if (this._authPromise) return this._authPromise
+
+    this._authPromise = this.loginDeveloper()
+      .finally(() => {
+        this._authPromise = null
+      })
+
+    return this._authPromise
+  }
+
+  async loginDeveloper() {
+    if (!this.api_key || !this.api_secret) {
+      throw new Error("Developer API credentials must be provided (api_key + secret)")
+    }
+
+    const payload = {
+      data: {
+        type: "sessions",
+        attributes: {
+          api_key: this.api_key,
+          secret: this.api_secret
+        }
+      }
+    }
+
+    const request = new fetch.Request(
+      `${this.api_base_url}/sessions`, {
+        method: 'POST',
+        headers: this.default_headers,
+        body: JSON.stringify(payload)
+      }
+    )
+
+    logger.debug(`HTTP ${request.method} ${request.url} (developer session)`)
+    const resp = await fetch(request)
+    logger.debug(`HTTP response status=${resp.status} url=${request.url}`)
+    const json = await this.checkStatus(resp)
+
+    this.developer_auth = {
+      auth_token: json.auth_token,
+      expires_at: json.expires_at,
+      developer_id: json.developer_id
+    }
+
+    const bearer = `Bearer ${this.developer_auth.auth_token}`
+    this.default_headers.set('Authorization', bearer)
+    // Keep the plain-object form in sync for consumers like Ably authHeaders.
+    this.defaultHeaderObject['Authorization'] = bearer
+    return this.developer_auth
+  }
+
   idParamUrlString(resource, params) {
     let idParam = ''
     if (params.id) {
@@ -103,6 +165,11 @@ class ApiService {
   }
 
   async issueRequest(request) {
+    await this.ensureDeveloperAuth()
+    // Ensure each request has the latest Authorization header
+    if (this.developer_auth && this.developer_auth.auth_token) {
+      request.headers.set('Authorization', `Bearer ${this.developer_auth.auth_token}`)
+    }
     logger.debug(`HTTP ${request.method} ${request.url}`)
     const resp = await fetch(request)
     logger.debug(`HTTP response status=${resp.status} url=${request.url}`)

package/lib/models/AnearEvent.js

@@ -158,12 +158,15 @@ class AnearEvent extends JsonApiResource {
     return this.attributes.flags.includes(flagName)
   }
 
-  allowsSpectators() {
+  spectatorsAllowed() {
     //
     // Canonical spectators decision uses the ANAPI-provided boolean when present.
     // Fallback to legacy negative flag for older payloads.
     //
-    return this.attributes['spectators-allowed']
+    const allowedDasherized = this.attributes['spectators-allowed']
+    if (typeof allowedDasherized === 'boolean') return allowedDasherized
+
+    return !this.hasFlag('no_spectators')
   }
 
   isParticipantEventCreator(participant) {

package/lib/state_machines/AnearEventMachine.js

@@ -1850,8 +1850,8 @@ const AnearEventMachineFunctions = ({
     eventSupportsSpectators: ({ context }) => {
       try {
         // True only when ANAPI has indicated spectators are allowed for this event.
-        // JSAPI AnearEvent#allowsSpectators reads the canonical spectators-allowed flag.
-        return !!(context.anearEvent && context.anearEvent.allowsSpectators && context.anearEvent.allowsSpectators())
+        // JSAPI AnearEvent#spectatorsAllowed reads the canonical spectators-allowed flag.
+        return !!(context.anearEvent && context.anearEvent.spectatorsAllowed && context.anearEvent.spectatorsAllowed())
       } catch (_e) {
         return false
       }

package/lib/state_machines/AnearParticipantMachine.js

@@ -234,7 +234,10 @@ const AnearParticipantMachineConfig = participantId => ({
                 input: ({ context, event }) => ({ context, event }),
                 onDone: [
                   { guard: 'hasActionTimeout', actions: 'updateActionTimeout', target: 'waitParticipantResponse' },
-                  { target: 'idle' }
+                  // If this display does not configure a timeout, explicitly clear any
+                  // previously-running action timeout. Otherwise, a stale actionTimeoutStart
+                  // from an older prompt can be "resumed" later and immediately fire.
+                  { actions: 'nullActionTimeout', target: 'idle' }
                 ],
                 onError: {
                   target: '#error'

package/package.json

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

package/tests/AnearEvent.test.js

@@ -29,7 +29,7 @@ describe('AnearEvent', () => {
     const mockService = { send: jest.fn() }
     anearEvent.setMachine(mockService)
     anearEvent.announceEvent()
-    expect(mockService.send).toHaveBeenCalledWith('ANNOUNCE')
+    expect(mockService.send).toHaveBeenCalledWith({ type: 'ANNOUNCE' })
   })
 
   test('can be hosted', () => {
@@ -46,8 +46,8 @@ describe('AnearEvent', () => {
     expect(anearEvent.hasFlag('no_spectators')).toBe(true)
   })
 
-  test('allowsSpectators is false when no_spectators flag is present', () => {
-    expect(anearEvent.allowsSpectators()).toBe(false)
+  test('spectatorsAllowed is false when no_spectators flag is present', () => {
+    expect(anearEvent.spectatorsAllowed()).toBe(false)
   })
 
   test('isPlayable returns true for playable states', () => {
@@ -94,32 +94,27 @@ describe('AnearEvent', () => {
 
     test('announceEvent sends ANNOUNCE', () => {
       anearEvent.announceEvent()
-      expect(mockService.send).toHaveBeenCalledWith('ANNOUNCE')
+      expect(mockService.send).toHaveBeenCalledWith({ type: 'ANNOUNCE' })
     })
 
     test('startEvent sends START', () => {
       anearEvent.startEvent()
-      expect(mockService.send).toHaveBeenCalledWith('START')
+      expect(mockService.send).toHaveBeenCalledWith({ type: 'START' })
     })
 
     test('cancelEvent sends CANCEL', () => {
       anearEvent.cancelEvent()
-      expect(mockService.send).toHaveBeenCalledWith('CANCEL')
+      expect(mockService.send).toHaveBeenCalledWith({ type: 'CANCEL' })
     })
 
     test('closeEvent sends CLOSE', () => {
       anearEvent.closeEvent()
-      expect(mockService.send).toHaveBeenCalledWith('CLOSE')
+      expect(mockService.send).toHaveBeenCalledWith({ type: 'CLOSE' })
     })
 
     test('pauseEvent sends PAUSE', () => {
       anearEvent.pauseEvent()
-      expect(mockService.send).toHaveBeenCalledWith('PAUSE')
-    })
-
-    test('resumeEvent sends RESUME', () => {
-      anearEvent.resumeEvent()
-      expect(mockService.send).toHaveBeenCalledWith('RESUME')
+      expect(mockService.send).toHaveBeenCalledWith({ type: 'PAUSE', appmContext: { context: undefined, resumeEvent: { type: 'RESUME' } } })
     })
   })
 })

package/tests/AnearParticipant.test.js

@@ -43,12 +43,12 @@ describe('AnearParticipant', () => {
   })
 
   test('isHost returns false for participants', () => {
-    expect(participant.isHost()).toBe(false)
+    expect(participant.isHost).toBe(false)
   })
 
   test('isHost returns true for hosts', () => {
     participant.attributes['user-type'] = 'host'
-    expect(participant.isHost()).toBe(true)
+    expect(participant.isHost).toBe(true)
   })
 
   test('eventId returns the correct event ID', () => {

package/tests/AnearService.test.js

@@ -12,5 +12,6 @@ const MockParticipantClass = class ParticipantMachine {}
 test('test happy path', () =>  {
   const mockEventMachineFactory = (anearEvent) => new MockAppClass(anearEvent)
   const mockParticipantMachineFactory = (anearParticipant) => new MockParticipantClass(anearParticipant)
-  AnearService(mockEventMachineFactory, mockParticipantMachineFactory)
+  const service = AnearService(mockEventMachineFactory, mockParticipantMachineFactory)
+  service.stop()
 })

package/tests/RealtimeMessaging.test.js

@@ -74,10 +74,10 @@ describe('RealtimeMessaging', () => {
       const stateChangeCallback = mockRealtimeInstance.connection.on.mock.calls[0][0]
 
       stateChangeCallback({ current: 'connected' })
-      expect(mockActor.send).toHaveBeenCalledWith('CONNECTED')
+      expect(mockActor.send).toHaveBeenCalledWith({ type: 'CONNECTED' })
 
       stateChangeCallback({ current: 'suspended' })
-      expect(mockActor.send).toHaveBeenCalledWith('SUSPENDED')
+      expect(mockActor.send).toHaveBeenCalledWith({ type: 'SUSPENDED' })
     })
   })
 
@@ -105,10 +105,10 @@ describe('RealtimeMessaging', () => {
       const stateChangeCallback = mockChannel.on.mock.calls[0][1]
 
       stateChangeCallback({ current: 'attached' })
-      expect(mockActor.send).toHaveBeenCalledWith('ATTACHED', { actor: mockActor })
+      expect(mockActor.send).toHaveBeenCalledWith({ type: 'ATTACHED', data: { channelName: 'mock-channel' } })
 
       stateChangeCallback({ current: 'failed' })
-      expect(mockActor.send).toHaveBeenCalledWith('FAILED', { actor: mockActor })
+      expect(mockActor.send).toHaveBeenCalledWith({ type: 'FAILED', data: { channelName: 'mock-channel' } })
     })
   })
 
@@ -132,7 +132,7 @@ describe('RealtimeMessaging', () => {
       const message = { data: { id: 'user-1' } }
       presenceCallback(message)
 
-      expect(mockActor.send).toHaveBeenCalledWith('PARTICIPANT_ENTER', { data: message.data })
+      expect(mockActor.send).toHaveBeenCalledWith({ type: 'PARTICIPANT_ENTER', data: message.data })
     })
   })
 
@@ -193,7 +193,7 @@ describe('RealtimeMessaging', () => {
       const messageCallback = mockChannel.subscribe.mock.calls[0][1]
       const message = { name: 'incoming-event', data: { info: 'abc' } }
       messageCallback(message)
-      expect(mockActor.send).toHaveBeenCalledWith(message.name, { data: message.data })
+      expect(mockActor.send).toHaveBeenCalledWith({ type: message.name, data: message.data })
     })
   })