Implement caching only where it's safe to do so

Signed-off-by: Axel Boberg <[email protected]>

api/classes/Cache.js

@@ -11,6 +11,18 @@ const InvalidArgumentError = require('../error/InvalidArgumentError')
  *              of data
  */
 class Cache {
+  /**
+   * A map containing the cache's index,
+   * mapping keys to cache entries
+   *
+   * @typedef {{
+   *  status: 'pending' | undefined,
+   *  promise: Promise | undefined,
+   *  value: any
+   * }} Entry
+   *
+   * @type { Map.<String, Entry> }
+   */
   #index = new Map()
   #maxEntries
 
@@ -60,21 +72,20 @@ class Cache {
     }
 
     if (this.#index.has(key)) {
-      const value = this.#index.get(key)
+      const entry = this.#index.get(key)
 
       /*
       If there is a pending promise for the value,
       return that rather than starting a new request
       */
       if (
-        value &&
-        typeof value === 'object' &&
-        value.__status === 'pending' &&
-        value.__promise
+        entry &&
+        entry.status === 'pending' &&
+        entry.promise
       ) {
-        return value.__promise
+        return entry.promise
       }
-      return this.#index.get(key)
+      return this.#index.get(key)?.value
     }
 
     /*
@@ -90,11 +101,11 @@ class Cache {
     })
 
     this.#prepareIndexForInsertion()
-    this.#index.set(key, { __status: 'pending', __promise: promise })
+    this.#index.set(key, { status: 'pending', promise })
 
     try {
       const value = await provider()
-      this.#index.set(key, value)
+      this.#index.set(key, { value })
       resolve(value)
     } catch (e) {
       reject(e)

api/events.js

@@ -251,3 +251,14 @@ function removeAllIntercepts (callee) {
   }
 }
 exports.removeAllIntercepts = removeAllIntercepts
+
+/**
+ * Check if there is a registered
+ * remote handler for an event
+ * @param { String } event
+ * @returns { Boolean }
+ */
+function hasRemoteHandler (event) {
+  return remoteHandlers.has(event)
+}
+exports.hasRemoteHandler = hasRemoteHandler

api/items.js

@@ -14,13 +14,19 @@ const objectPath = require('object-path')
 const state = require('./state')
 const types = require('./types')
 const client = require('./client')
+const events = require('./events')
 const random = require('./random')
 const commands = require('./commands')
 const variables = require('./variables')
 
 const MissingArgumentError = require('./error/MissingArgumentError')
 const InvalidArgumentError = require('./error/InvalidArgumentError')
 
+const Cache = require('./classes/Cache')
+
+const CACHE_MAX_ENTRIES = 10
+const cache = new Cache(CACHE_MAX_ENTRIES)
+
 /**
  * Create a new id for an item
  * that is unique and doesn't
@@ -95,6 +101,20 @@ exports.applyItem = applyItem
  * @returns { Promise.<Item> }
  */
 function getItem (id) {
+  /*
+  Use caching if it's safe to do so
+
+  The cache key must depend on the local state revision
+  in order to not get out of date, and that will only
+  get updated if the client is listening for the
+  'state.change' event
+  */
+  if (
+    events.hasRemoteHandler('state.change') &&
+    state.getLocalRevision() !== 0
+  ) {
+    return cache.cache(`${id}::${state.getLocalRevision()}`, () => commands.executeCommand('items.getItem', id))
+  }
   return commands.executeCommand('items.getItem', id)
 }
 exports.getItem = getItem

api/state.js

@@ -7,6 +7,11 @@ const merge = require('../shared/merge')
 const commands = require('./commands')
 const events = require('./events')
 
+const Cache = require('./classes/Cache')
+
+const CACHE_MAX_ENTRIES = 10
+const cache = new Cache(CACHE_MAX_ENTRIES)
+
 /**
  * Keep a local
  * copy of the state
@@ -31,6 +36,15 @@ let state
  */
 let revision = 0
 
+/**
+ * Get the local revision
+ * @returns { Number }
+ */
+function getLocalRevision () {
+  return revision
+}
+exports.getLocalRevision = getLocalRevision
+
 /**
  * Get the full remote state
  * @returns { Promise.<any> }
@@ -117,13 +131,20 @@ exports.apply = apply
  * @returns { Promise.<State> }
  */
 async function get (path) {
-  const newState = await getRemoteState(path)
   if (!path) {
+    const newState = await getRemoteState()
     revision = newState._revision
     state = newState
     return state
   } else {
-    return newState
+    /*
+    If we can expect the revision to be updated,
+    use the caching layer to bundle calls together
+    */
+    if (events.hasRemoteHandler('state.change') && revision !== 0) {
+      return cache.cache(`${path}::${revision}`, () => getRemoteState(path))
+    }
+    return getRemoteState(path)
   }
 }
 exports.get = get