kuzzle 2.19.2 → 2.19.5

package/lib/core/cache/cacheEngine.js

@@ -19,18 +19,18 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
-const Redis = require('../../service/cache/redis');
+const Redis = require("../../service/cache/redis");
 
 class CacheEngine {
-  constructor () {
+  constructor() {
     const config = global.kuzzle.config.services;
 
-    this.public = new Redis(config.memoryStorage, 'public_adapter');
-    this.internal = new Redis(config.internalCache, 'internal_adapter');
+    this.public = new Redis(config.memoryStorage, "public_adapter");
+    this.internal = new Redis(config.internalCache, "internal_adapter");
   }
 
   /**
@@ -38,100 +38,95 @@ class CacheEngine {
    *
    * @returns {Promise}
    */
-  async init () {
-    await Bluebird.all([
-      this.public.init(),
-      this.internal.init(),
-    ]);
+  async init() {
+    await Bluebird.all([this.public.init(), this.internal.init()]);
 
     this.registerInternalEvents();
     this.registerPublicEvents();
 
-    global.kuzzle.log.info('[✔] Cache initialized');
+    global.kuzzle.log.info("[✔] Cache initialized");
   }
 
-  registerInternalEvents () {
+  registerInternalEvents() {
     /**
      * Deletes on or multiple keys
      * @param  {string|Array.<string>} keys
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:del',
-      keys => this.internal.commands.del(keys));
+    global.kuzzle.onAsk("core:cache:internal:del", (keys) =>
+      this.internal.commands.del(keys)
+    );
 
     /**
      * Asks a key to expire in the provided delay
      * @param {string} key
      * @param {number} ttl (in seconds)
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:expire',
-      (key, ttl) => this.internal.commands.expire(key, ttl));
+    global.kuzzle.onAsk("core:cache:internal:expire", (key, ttl) =>
+      this.internal.commands.expire(key, ttl)
+    );
 
     /**
      * Wipes the database clean
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:flushdb',
-      () => this.internal.commands.flushdb());
+    global.kuzzle.onAsk("core:cache:internal:flushdb", () =>
+      this.internal.commands.flushdb()
+    );
 
     /**
      * Returns basic information about the internal cache service
      * @returns {Promise.<Object>}
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:info:get',
-      () => this.internal.info());
+    global.kuzzle.onAsk("core:cache:internal:info:get", () =>
+      this.internal.info()
+    );
 
     /**
      * Fetches a single value
      * @param {string} key
      * @return {string}
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:get',
-      key => this.internal.commands.get(key));
+    global.kuzzle.onAsk("core:cache:internal:get", (key) =>
+      this.internal.commands.get(key)
+    );
 
     /**
      * Fetches multiple values in one go
      * @param  {Array.<string>} ids
      * @return {Array.<string|null>}
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:mget',
-      keys => {
-        // redis throws an error if trying to mget without arguments
-        if (keys.length === 0) {
-          return [];
-        }
+    global.kuzzle.onAsk("core:cache:internal:mget", (keys) => {
+      // redis throws an error if trying to mget without arguments
+      if (keys.length === 0) {
+        return [];
+      }
 
-        return this.internal.commands.mget(keys);
-      });
+      return this.internal.commands.mget(keys);
+    });
 
     /**
      * Makes a key persistent (disable its expiration delay, if there is one)
      * @param {string} key
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:persist',
-      (key) => this.internal.commands.persist(key));
+    global.kuzzle.onAsk("core:cache:internal:persist", (key) =>
+      this.internal.commands.persist(key)
+    );
 
     /**
      * Asks a key to expire in the provided delay
      * @param {string} key
      * @param {number} ttl (in milliseconds)
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:pexpire',
-      (key, ttl) => this.internal.commands.pexpire(key, ttl));
+    global.kuzzle.onAsk("core:cache:internal:pexpire", (key, ttl) =>
+      this.internal.commands.pexpire(key, ttl)
+    );
 
     /**
      * Fetches all keys matching the provided pattern
      * @param {string} pattern
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:searchKeys',
-      pattern => this.internal.searchKeys(pattern));
+    global.kuzzle.onAsk("core:cache:internal:searchKeys", (pattern) =>
+      this.internal.searchKeys(pattern)
+    );
 
     /**
      * Add a custom LUA script to the internal client
@@ -143,13 +138,14 @@ class CacheEngine {
      * @param {string} script
      */
     global.kuzzle.onAsk(
-      'core:cache:internal:script:define',
+      "core:cache:internal:script:define",
       (name, keys, script) => {
         return this.internal.client.defineCommand(name, {
           lua: script,
           numberOfKeys: keys,
         });
-      });
+      }
+    );
 
     /**
      * Execute a script previously defined with core:cache:internal:script:define
@@ -158,9 +154,9 @@ class CacheEngine {
      * @param {...string} args -- script arguments
      * @return {*} script result (if any)
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:script:execute',
-      (name, ...args) => this.internal.client[name](...args));
+    global.kuzzle.onAsk("core:cache:internal:script:execute", (name, ...args) =>
+      this.internal.client[name](...args)
+    );
 
     /**
      * Convenience method for easy access to options NX and PX of the "set"
@@ -177,86 +173,84 @@ class CacheEngine {
      * @param {{ttl: number, onlyIfNew: boolean}} [opts]
      * @returns {Promise.<boolean>} true if the key was set, false otherwise
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:store',
-      (key, value, opts) => this.internal.store(key, value, opts));
+    global.kuzzle.onAsk("core:cache:internal:store", (key, value, opts) =>
+      this.internal.store(key, value, opts)
+    );
 
     /**
      * Executes an arbitrary NATIVE cache command directly
      * @param {string} command
      * @param {Array} args -- command arguments
      */
-    global.kuzzle.onAsk(
-      'core:cache:internal:execute',
-      (command, ...args) => this.internal.exec(command, ...args));
+    global.kuzzle.onAsk("core:cache:internal:execute", (command, ...args) =>
+      this.internal.exec(command, ...args)
+    );
   }
 
-  registerPublicEvents () {
+  registerPublicEvents() {
     /**
      * Deletes on or multiple keys
      * @param  {string|Array.<string>} keys
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:del',
-      keys => this.public.commands.del(keys));
+    global.kuzzle.onAsk("core:cache:public:del", (keys) =>
+      this.public.commands.del(keys)
+    );
 
     /**
      * Executes an arbitrary NATIVE cache command directly
      * @param {string} command
      * @param {Array} args -- command arguments
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:execute',
-      (command, ...args) => this.public.exec(command, ...args));
+    global.kuzzle.onAsk("core:cache:public:execute", (command, ...args) =>
+      this.public.exec(command, ...args)
+    );
 
     /**
      * Asks a key to expire in the provided delay
      * @param {string} key
      * @param {number} ttl (in seconds)
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:expire',
-      (key, ttl) => this.public.commands.expire(key, ttl));
+    global.kuzzle.onAsk("core:cache:public:expire", (key, ttl) =>
+      this.public.commands.expire(key, ttl)
+    );
 
     /**
      * Wipes the database clean
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:flushdb',
-      () => this.public.commands.flushdb());
+    global.kuzzle.onAsk("core:cache:public:flushdb", () =>
+      this.public.commands.flushdb()
+    );
 
     /**
      * Returns basic information about the internal cache service
      * @returns {Promise.<Object>}
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:info:get',
-      () => this.public.info());
+    global.kuzzle.onAsk("core:cache:public:info:get", () => this.public.info());
 
     /**
      * Fetches a single value
      * @param {string} key
      * @return {string}
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:get',
-      key => this.public.commands.get(key));
+    global.kuzzle.onAsk("core:cache:public:get", (key) =>
+      this.public.commands.get(key)
+    );
 
     /**
      * Executes multiple cache commands in one go, as a single transaction
      * @param {Array} commands to execute
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:mExecute',
-      commands => this.public.mExecute(commands));
+    global.kuzzle.onAsk("core:cache:public:mExecute", (commands) =>
+      this.public.mExecute(commands)
+    );
 
     /**
      * Makes a key persistent (disable its expiration delay, if there is one)
      * @param {string} key
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:persist',
-      (key) => this.public.commands.persist(key));
+    global.kuzzle.onAsk("core:cache:public:persist", (key) =>
+      this.public.commands.persist(key)
+    );
 
     /**
      * Convenience method for easy access to options NX and PX of the "set"
@@ -273,9 +267,9 @@ class CacheEngine {
      * @param {{ttl: number, onlyIfNew: boolean}} [opts]
      * @returns {Promise.<boolean>} true if the key was set, false otherwise
      */
-    global.kuzzle.onAsk(
-      'core:cache:public:store',
-      (key, value, opts) => this.public.store(key, value, opts));
+    global.kuzzle.onAsk("core:cache:public:store", (key, value, opts) =>
+      this.public.store(key, value, opts)
+    );
   }
 }