anear-js-api 0.6.5 → 1.1.1

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

@@ -32,37 +32,37 @@ class AnearEvent extends JsonApiResource {
   }
 
   announceEvent() {
-    this.send("ANNOUNCE")
+    this.send({ type: "ANNOUNCE" })
   }
 
   startEvent() {
-    this.send("START")
+    this.send({ type: "START" })
   }
 
   cancelEvent() {
-    this.send("CANCEL")
+    this.send({ type: "CANCEL" })
   }
 
   closeEvent() {
-    this.send("CLOSE")
+    this.send({ type: "CLOSE" })
   }
 
   restartEvent() {
-    this.send("RESTART")
+    this.send({ type: "RESTART" })
   }
 
   pauseEvent(context, resumeEvent = { type: 'RESUME' }) {
     // Persist via AEM and acknowledge with PAUSED
-    this.send('PAUSE', { appmContext: { context, resumeEvent } })
+    this.send({ type: 'PAUSE', appmContext: { context, resumeEvent } })
   }
 
   saveEvent(context, resumeEvent = { type: 'RESUME' }) {
     // Delegate save to the AEM; AEM will persist via ANAPI and acknowledge with SAVED
-    this.send('SAVE', { appmContext: { context, resumeEvent } })
+    this.send({ type: 'SAVE', appmContext: { context, resumeEvent } })
   }
 
   bootParticipant(participantId, reason) {
-    this.send("BOOT_PARTICIPANT", { participantId, reason })
+    this.send({ type: "BOOT_PARTICIPANT", data: { participantId, reason } })
   }
 
   render(viewPath, displayType, appContext, event, timeout = null, props = {}) {
@@ -91,7 +91,8 @@ class AnearEvent extends JsonApiResource {
       Object.assign(appRenderContext.meta, props)
     }
     
-    this.send("RENDER_DISPLAY", {
+    this.send({
+      type: "RENDER_DISPLAY",
       displayEvents: [{
         viewPath,
         appRenderContext
@@ -157,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/AnearCoreServiceMachine.js

@@ -44,7 +44,7 @@
  * app developer’s AppEventMachine (AppM) and any participant machines.
  */
 
-const { assign, createMachine, interpret } = require('xstate')
+const { assign, createMachine, createActor, fromPromise } = require('xstate')
 const logger = require('../utils/Logger')
 const { version: anearJsApiVersion } = require('../../package.json')
 
@@ -63,7 +63,6 @@ const DefaultTemplatesRootDir = "./views"
 
 const AnearCoreServiceMachineContext = (appId, appEventMachineFactory, appParticipantMachineFactory) => ({
   appId,
-  coreServiceMachine: null,
   appData: null,
   appEventMachineFactory,
   appParticipantMachineFactory,
@@ -75,33 +74,19 @@ const AnearCoreServiceMachineContext = (appId, appEventMachineFactory, appPartic
   retryDelay: 0
 })
 
-const GlobalEventConfig = {
-  // This wildcard will catch done.invoke.anearEventMachine_<id>
-  'done.invoke.anearEventMachine_*': {
-  }
-}
-
 const AnearCoreServiceMachineConfig = appId => ({
   id: `AnearCoreServiceMachine_${appId}`,
-  initial: 'waitForContextUpdate',
-  on: GlobalEventConfig,
+  initial: 'fetchAppDataWithRetry',
+  context: ({ input }) => input,
   states: {
-    waitForContextUpdate: {
-      id: 'waitForContextUpdate',
-      on: {
-        UPDATE_CONTEXT: {
-          actions: ['updateContextWithMachineRef'],
-          target: 'fetchAppDataWithRetry'
-        }
-      }
-    },
     fetchAppDataWithRetry: {
-      entry: (c, e) => logger.info('anear-js-api version: ', anearJsApiVersion),
+      entry: _ => logger.info('anear-js-api version: ', anearJsApiVersion),
       initial: 'fetchAppData',
       states: {
         fetchAppData: {
           invoke: {
             src: 'fetchAppData',
+            input: ({ context }) => ({ appId: context.appId }),
             onDone: {
               actions: ['setAppData'],
               target: '#initRealtimeMessaging'
@@ -134,10 +119,11 @@ const AnearCoreServiceMachineConfig = appId => ({
     uploadNewImageAssets: {
       invoke: {
         src: 'uploadNewImageAssets',
+        input: ({ context }) => ({ appId: context.appId }),
         onDone: {
           actions: assign({
-            // event.data has imageAssetsUrl returned by src service
-            imageAssetsUrl: (_context, event) => event.data
+            // v5: `event.output` is the resolved promise value
+            imageAssetsUrl: ({ event }) => event.output
           }),
           target: 'uploadNewFontAssets'
         },
@@ -147,9 +133,10 @@ const AnearCoreServiceMachineConfig = appId => ({
     uploadNewFontAssets: {
       invoke: {
         src: 'uploadNewFontAssets',
+        input: ({ context }) => ({ appId: context.appId }),
         onDone: {
           actions: assign({
-            fontAssetsUrl: (_context, event) => event.data
+            fontAssetsUrl: ({ event }) => event.output
           }),
           target: 'minifyCssAndUpload'
         },
@@ -160,6 +147,11 @@ const AnearCoreServiceMachineConfig = appId => ({
       invoke: {
         id: 'minifyCssAndUpload',
         src: 'minifyCssAndUpload',
+        input: ({ context }) => ({
+          appId: context.appId,
+          imageAssetsUrl: context.imageAssetsUrl,
+          fontAssetsUrl: context.fontAssetsUrl
+        }),
         onDone: {
           target: 'loadAndCompilePugTemplates'
         },
@@ -176,7 +168,7 @@ const AnearCoreServiceMachineConfig = appId => ({
       // The Anear API backend will send CREATE_EVENT or LOAD_EVENT messages with the event JSON data
       // to this createEventMessages Channel when it needs to create a new instance of an
       // Event
-      entry: (context) => logger.debug(`Waiting on ${context.appData.data.attributes['short-name']} lifecycle command`),
+      entry: ({ context }) => logger.debug(`Waiting on ${context.appData.data.attributes['short-name']} lifecycle command`),
       on: {
         CREATE_EVENT: {
           actions: ['startNewEventMachine']
@@ -193,50 +185,40 @@ const AnearCoreServiceMachineConfig = appId => ({
     },
     failure: {
       id: 'failure',
-      entry: (_c, event) => logger.debug("Failure! ", event.data),
+      entry: ({ event }) => logger.debug("Failure! ", event.error),
       type: 'final'
     }
   }
 })
 
 const AnearCoreServiceMachineFunctions = {
-  services: {
-    fetchAppData: context => AnearApi.getApp(context.appId),
-    uploadNewImageAssets: context => {
-      const uploader = new ImageAssetsUploader(
-        C.ImagesDirPath,
-        context.appId
-      )
+  actors: {
+    // v5 pattern: async "services" become Promise Actors via `fromPromise`.
+    // The invoked actor receives `input` from the invoking state's `invoke.input`.
+    fetchAppData: fromPromise(({ input }) => AnearApi.getApp(input.appId)),
+    uploadNewImageAssets: fromPromise(({ input }) => {
+      const uploader = new ImageAssetsUploader(C.ImagesDirPath, input.appId)
       return uploader.uploadAssets()
-    },
-    uploadNewFontAssets: context => {
-      const uploader = new FontAssetsUploader(
-        C.FontsDirPath,
-        context.appId
-      )
+    }),
+    uploadNewFontAssets: fromPromise(({ input }) => {
+      const uploader = new FontAssetsUploader(C.FontsDirPath, input.appId)
       return uploader.uploadAssets()
-    },
-    minifyCssAndUpload: (context) => {
+    }),
+    minifyCssAndUpload: fromPromise(({ input }) => {
       const uploader = new CssUploader(
         C.CssDirPath,
-        context.imageAssetsUrl,
-        context.fontAssetsUrl,
-        context.appId
+        input.imageAssetsUrl,
+        input.fontAssetsUrl,
+        input.appId
       )
-
       return uploader.uploadCss()
-    }
+    })
   },
   actions: {
-    updateContextWithMachineRef: assign(
-      {
-        coreServiceMachine: (_, event) => event.coreServiceMachine
-      }
-    ),
-    initRealtime: context => RealtimeMessaging.initRealtime(context.appId, context.coreServiceMachine),
+    initRealtime: ({ context, self }) => RealtimeMessaging.initRealtime(context.appId, self),
     loadPugFiles: assign(
       {
-        pugTemplates: () => {
+        pugTemplates: (_args) => {
           const pugLoader = new PugLoader(DefaultTemplatesRootDir)
           const templates = pugLoader.compiledPugTemplates()
           logger.debug(`loaded pug templates ${Object.keys(templates)}`)
@@ -245,7 +227,7 @@ const AnearCoreServiceMachineFunctions = {
       }
     ),
     incrementRetryDelay: assign({
-      retryDelay: (context, _e) => {
+      retryDelay: ({ context }, _params) => {
         const retryTimesBeforeReset = 6
         const increment = 5000
         const start = increment
@@ -256,35 +238,36 @@ const AnearCoreServiceMachineFunctions = {
     }),
     setAppData: assign(
       {
-        appData: (_, event) => {
-          logger.debug(`fetched ${event.data.data.attributes["short-name"]} app data`)
-          return event.data
+        appData: ({ event }) => {
+          const output = event.output
+          logger.debug(`fetched ${output.data.attributes["short-name"]} app data`)
+          return output
         }
       }
     ),
     createEventsCreationChannel: assign(
       {
-        newEventCreationChannel: context => {
+        newEventCreationChannel: ({ context, self }) => {
           const channelName = CreateEventChannelNameTemplate(context.appId)
-          return RealtimeMessaging.getChannel(channelName, context.coreServiceMachine)
+          return RealtimeMessaging.getChannel(channelName, self)
         }
       }
     ),
-    subscribeCreateEventMessages: context => {
+    subscribeCreateEventMessages: ({ context, self }) => {
       RealtimeMessaging.subscribe(
         context.newEventCreationChannel,
-        context.coreServiceMachine,
+        self,
         'CREATE_EVENT'
       )
       RealtimeMessaging.subscribe(
         context.newEventCreationChannel,
-        context.coreServiceMachine,
+        self,
         'LOAD_EVENT'
       )
     },
     startNewEventMachine: assign(
       {
-        anearEventMachines: (context, event) => {
+        anearEventMachines: ({ context, event, self }) => {
           const eventJSON = JSON.parse(event.data)
           const anearEvent = new AnearEvent(eventJSON)
 
@@ -294,16 +277,22 @@ const AnearCoreServiceMachineFunctions = {
           }
 
           const isLoadEvent = event.type === 'LOAD_EVENT'
-          const service = AnearEventMachine(anearEvent, { ...context, rehydrate: isLoadEvent })
+          const actor = AnearEventMachine(anearEvent, {
+            ...context,
+            // AEM expects a reference back to its supervisor; in v5 we can pass `self`
+            // directly rather than storing a "coreServiceMachine" reference in context.
+            coreServiceMachine: self,
+            rehydrate: isLoadEvent
+          })
 
           return {
             ...context.anearEventMachines,
-            [anearEvent.id]: service.start()
+            [anearEvent.id]: actor.start()
           }
         }
       }
     ),
-    cleanupEventMachine: assign((context, event) => {
+    cleanupEventMachine: assign(({ context, event }) => {
       const { [event.eventId]: dropped, ...remaining } = context.anearEventMachines
       logger.debug(`ACSM ${event.eventId} is ${dropped ? "done → cleaning up" : "NOT FOUND"}`)
 
@@ -313,16 +302,16 @@ const AnearCoreServiceMachineFunctions = {
     })
   },
   delays: {
-    retry_with_backoff_delay: (context, event) => context.retryDelay
+    retry_with_backoff_delay: ({ context }) => context.retryDelay
   },
   guards: {
-    noImageAssetFilesFound: (_, event) => event.data === null
+    noImageAssetFilesFound: ({ event }) => event.output === null
   }
 }
 
 const AnearCoreServiceMachine = (appEventMachineFactory, appParticipantMachineFactory = null) => {
   const appId = process.env.ANEARAPP_APP_ID
-  const expandedConfig = {predictableActionArguments: true, ...AnearCoreServiceMachineConfig(appId)}
+  const machineConfig = AnearCoreServiceMachineConfig(appId)
 
   const anearCoreServiceMachineContext = AnearCoreServiceMachineContext(
     appId,
@@ -330,16 +319,9 @@ const AnearCoreServiceMachine = (appEventMachineFactory, appParticipantMachineFa
     appParticipantMachineFactory
   )
 
-  const coreServiceMachine = createMachine(
-    expandedConfig,
-    AnearCoreServiceMachineFunctions
-  ).withContext(anearCoreServiceMachineContext)
-
-  const coreServiceMachineStarted = interpret(coreServiceMachine).start()
-
-  coreServiceMachineStarted.send('UPDATE_CONTEXT', { coreServiceMachine: coreServiceMachineStarted })
+  const coreServiceMachine = createMachine(machineConfig, AnearCoreServiceMachineFunctions)
 
-  return coreServiceMachineStarted
+  return createActor(coreServiceMachine, { input: anearCoreServiceMachineContext }).start()
 }
 
 module.exports = AnearCoreServiceMachine