cache/scopedCache.js

  1. import {getCache} from '../cache.js';
  2. import {reusePromiseForever} from '../reusePromises.js';
  4. /**
  5.  * A wrapper class for accessing the cache.
  6.  * Prefixes a string before each key to avoid conflicts.
  7.  */
  8. export class ScopedCache {
  9.   /**
  10.    * Create a new ScopedCache object by passing in the key prefix descired
  11.    * @param {string} keyPrefix
  12.    * @param {number} [version] Cache version, bump this to invalidate existing cache entries for a scope
  13.    * @param {object} [cacheObject=null] Manually supply a cache object to use
  14.    */
  15.   constructor(keyPrefix, version = 0, cacheObject = null) {
  16.     this.prefix = keyPrefix;
  17.     this.version = version;
  19.     this.cache = null;
  20.     this.cacheOverride = cacheObject;
  21.   }
  23.   /**
  24.    * Initialise the cache for this scope
  25.    */
  26.   async initCache() {
  27.     return await reusePromiseForever(this, this._initCache);
  28.   }
  30.   /**
  31.    * Internal cache initialisation
  32.    */
  33.   async _initCache() {
  34.     if (this.cache) {
  35.       return this.cache;
  36.     }
  38.     if (!!this.cacheOverride) {
  39.       this.cache = this.cacheOverride;
  40.     } else {
  41.       this.cache = await getCache();
  42.     }
  44.     // check and flush cache if version mismatch
  45.     const cacheVersion = await this.cache.get(this.generateScopedKey('%%version%%'));
  46.     if (cacheVersion !== undefined && cacheVersion != this.version) {
  47.       // find all cache entries with this scope, and remove them
  48.       const keys = await this.cache.getKeys(`${this.prefix}_`);
  50.       await Promise.allSettled(keys.map((key) => {
  51.         // set expire date to 1 millisecond ago (this basically deletes it)
  52.         return this.cache.set(key, {}, -1);
  53.       }));
  54.     }
  56.     // set our new cache version with a very very long ttl
  57.     await this.cache.set(this.generateScopedKey('%%version%%'), this.version, Number.MAX_SAFE_INTEGER);
  58.     this._initCachePromise = null;
  60.     return this.cache;
  61.   }
  63.   /**
  64.    * Generate a scoped key by adding our prefix to the incoming key
  65.    * @param {string} inKey
  66.    * @return {string} Scoped key
  67.    */
  68.   generateScopedKey(inKey) {
  69.     return `${this.prefix}_${inKey}`;
  70.   }
  72.   /**
  73.      * Get a cached object
  74.      * @public
  75.      * @async
  76.      * @param {string} key Unique key name for this cache entry
  77.      * @param {boolean} [getFullObject] Get the full cache entry, including expiry time, even if expired
  78.      * @param {boolean} [force=false] Force set, bypassing transaction blocks
  79.      * @return {(Object|undefined)} Returns the object in the cache, or undefined if not present
  80.      */
  81.   async get(key, getFullObject = false, force = false) {
  82.     return this.getGlobal(this.generateScopedKey(key), getFullObject, force);
  83.   }
  85.   /**
  86.      * Get a cached object from the global cache (skipping the scope prefix)
  87.      * @public
  88.      * @async
  89.      * @param {string} key Unique key name for this cache entry
  90.      * @param {boolean} [getFullObject] Get the full cache entry, including expiry time, even if expired
  91.      * @param {boolean} [force=false] Force set, bypassing transaction blocks
  92.      * @return {(Object|undefined)} Returns the object in the cache, or undefined if not present
  93.      */
  94.   async getGlobal(key, getFullObject = false, force = false) {
  95.     const cache = await this.initCache();
  96.     return cache.get(key, getFullObject, force);
  97.   }
  99.   /**
  100.      * Set a key in our cache
  101.      * @public
  102.      * @async
  103.      * @param {string} key Unique key name for this cache entry
  104.      * @param {Object} value
  105.      * @param {(Function|number)} [ttl=3600000] How long the cache entry should last in milliseconds
  106.      *  Can be a number or a function that will return a number
  107.      *  Default 1 hour
  108.      */
  109.   async set(key, value, ttl = 3600000) {
  110.     return this.setGlobal(this.generateScopedKey(key), value, ttl);
  111.   }
  113.   /**
  114.      * Set a key in our global cache, skipping the scoped prefix
  115.      * @public
  116.      * @async
  117.      * @param {string} key Unique key name for this cache entry
  118.      * @param {Object} value
  119.      * @param {(Function|number)} [ttl=3600000] How long the cache entry should last in milliseconds
  120.      *  Can be a number or a function that will return a number
  121.      *  Default 1 hour
  122.      */
  123.   async setGlobal(key, value, ttl = 3600000) {
  124.     const cache = await this.initCache();
  125.     return cache.set(key, value, ttl);
  126.   }
  128.   /**
  129.      * A helper "wrap" function that will return a cached value if present
  130.      *  This will call the supplied function to fetch it if the value isn't present in the cache
  131.      * @public
  132.      * @async
  133.      * @param {string} key Unique key name for this cache entry
  134.      * @param {function} fn Fetch function that will be called if the cache entry is not present
  135.      * @param {(function|number)} [ttl] How long the cache entry should last in milliseconds
  136.      *  Can be a number or a function that will return a number
  137.      */
  138.   async wrap(key, fn, ttl) {
  139.     return this.wrapGlobal(this.generateScopedKey(key), fn, ttl);
  140.   }
  142.   /**
  143.      * A helper "wrap" function that will return a cached value if present (in the global scope)
  144.      *  This will call the supplied function to fetch it if the value isn't present in the cache
  145.      * @public
  146.      * @async
  147.      * @param {string} key Unique key name for this cache entry
  148.      * @param {function} fn Fetch function that will be called if the cache entry is not present
  149.      * @param {(function|number)} [ttl] How long the cache entry should last in milliseconds
  150.      *  Can be a number or a function that will return a number
  151.      */
  152.   async wrapGlobal(key, fn, ttl) {
  153.     const cache = await this.initCache();
  154.     return cache.wrap(key, fn, ttl);
  155.   }
  157.   /**
  158.    * Run a series of functions in a single transaction
  159.    * @param {functions} func
  160.    * @return {promise}
  161.    */
  162.   async runTransaction(func) {
  163.     const cache = await this.initCache();
  164.     return cache.runTransaction(func, (key) => {
  165.       return this.generateScopedKey(key);
  166.     });
  167.   }
  169.   /**
  170.    * Block if we have any pending transactions
  171.    * @return {Promise}
  172.    */
  173.   async blockOnPendingTransactions() {
  174.     const cache = await this.initCache();
  175.     return cache.blockOnPendingTransactions();
  176.   }
  178.   /**
  179.    * Get an array of all the cached keys matching the supplied prefix
  180.    * @param {string} [prefix='']
  181.    * @return {array<string>}
  182.    */
  183.   async getKeys(prefix = '') {
  184.     const cache = await this.initCache();
  185.     return (await cache.getKeys(`${this.prefix}_${prefix}`)).map((x) => {
  186.       // return keys without our scoped cache prefix
  187.       return x.slice(this.prefix.length + 1);
  188.     });
  189.   }
  190. }
  192. export default ScopedCache;