kuzzle 2.19.2 → 2.19.3

package/lib/model/storage/baseModel.js

@@ -19,18 +19,18 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
 class BaseModel {
-  constructor (_source = {}, _id = null) {
+  constructor(_source = {}, _id = null) {
     this.__id = null;
     this.__source = {};
 
-    Reflect.defineProperty(this, '__persisted', {
+    Reflect.defineProperty(this, "__persisted", {
       value: false,
-      writable: true
+      writable: true,
     });
 
     this._id = _id;
@@ -44,20 +44,20 @@ class BaseModel {
    *
    * @param {Model} ModelClass
    */
-  static register (ModelClass) {
+  static register(ModelClass) {
     if (this !== BaseModel) {
-      throw new Error('Incorrect usage of BaseModel.register');
+      throw new Error("Incorrect usage of BaseModel.register");
     }
 
     // Define getters and setters for Model fields
     for (const field of ModelClass.fields) {
       Reflect.defineProperty(ModelClass.prototype, field, {
-        get () {
+        get() {
           return this.__source[field];
         },
-        set (value) {
+        set(value) {
           this.__source[field] = value;
-        }
+        },
       });
     }
   }
@@ -73,23 +73,24 @@ class BaseModel {
    *
    * @returns {Promise}
    */
-  async save ({ userId = null, refresh } = {}) {
-    if (! this.__persisted) {
+  async save({ userId = null, refresh } = {}) {
+    if (!this.__persisted) {
       const { _id, _source } = await global.kuzzle.internalIndex.create(
         this.constructor.collection,
         this._source,
-        { id: this._id, refresh, userId });
+        { id: this._id, refresh, userId }
+      );
 
       this._id = _id;
       this._source = _source;
       this.__persisted = true;
-    }
-    else {
+    } else {
       await global.kuzzle.internalIndex.update(
         this.constructor.collection,
         this._id,
         this._source,
-        { refresh, userId });
+        { refresh, userId }
+      );
     }
   }
 
@@ -101,15 +102,16 @@ class BaseModel {
    *
    * @returns {Promise}
    */
-  async delete ({ refresh } = {}) {
-    if (! this.__persisted) {
+  async delete({ refresh } = {}) {
+    if (!this.__persisted) {
       return;
     }
 
     await global.kuzzle.internalIndex.delete(
       this.constructor.collection,
       this._id,
-      { refresh });
+      { refresh }
+    );
 
     await this._afterDelete();
 
@@ -121,10 +123,10 @@ class BaseModel {
    *
    * @returns {Object} { _id, _source }
    */
-  serialize () {
+  serialize() {
     return {
       _id: this._id,
-      _source: this._source
+      _source: this._source,
     };
   }
 
@@ -135,25 +137,25 @@ class BaseModel {
    *
    * @returns {Promise}
    */
-  async _afterDelete () {
+  async _afterDelete() {
     return null;
   }
 
   // Getter/Setter =============================================================
 
-  get _id () {
+  get _id() {
     return this.__id;
   }
 
-  set _id (_id) {
+  set _id(_id) {
     this.__id = _id;
   }
 
-  get _source () {
+  get _source() {
     return this.__source;
   }
 
-  set _source (_source) {
+  set _source(_source) {
     for (const key of Object.keys(_source)) {
       if (this.constructor.fields.includes(key)) {
         this.__source[key] = _source[key];
@@ -170,10 +172,8 @@ class BaseModel {
    *
    * @returns {BaseModel}
    */
-  static async load (id) {
-    const result = await global.kuzzle.internalIndex.get(
-      this.collection,
-      id);
+  static async load(id) {
+    const result = await global.kuzzle.internalIndex.get(this.collection, id);
 
     return this._instantiateFromDb(result);
   }
@@ -187,15 +187,17 @@ class BaseModel {
    *
    * @returns {Promise}
    */
-  static async deleteByQuery (query, { refresh } = {}) {
+  static async deleteByQuery(query, { refresh } = {}) {
     const { documents } = await global.kuzzle.internalIndex.deleteByQuery(
       this.collection,
-      query);
+      query
+    );
 
     await Bluebird.map(
       documents,
-      document => this._instantiateFromDb(document)._afterDelete(),
-      { concurrency: 10 }); // limits the load on storage services
+      (document) => this._instantiateFromDb(document)._afterDelete(),
+      { concurrency: 10 }
+    ); // limits the load on storage services
 
     if (refresh) {
       await global.kuzzle.internalIndex.refreshCollection(this.collection);
@@ -210,13 +212,14 @@ class BaseModel {
    *
    * @returns {BaseModel[]} - Array of instances
    */
-  static async search (searchBody, options) {
+  static async search(searchBody, options) {
     const resp = await global.kuzzle.internalIndex.search(
       this.collection,
       searchBody,
-      options);
+      options
+    );
 
-    return resp.hits.map(hit => this._instantiateFromDb(hit));
+    return resp.hits.map((hit) => this._instantiateFromDb(hit));
   }
 
   /**
@@ -226,29 +229,30 @@ class BaseModel {
    *
    * @returns {Promise}
    */
-  static truncate ({ refresh } = {}) {
+  static truncate({ refresh } = {}) {
     return this.deleteByQuery({ match_all: {} }, { refresh });
   }
 
-  static batchExecute (query, callback) {
+  static batchExecute(query, callback) {
     return global.kuzzle.internalIndex.mExecute(
       this.collection,
       query,
-      callback);
+      callback
+    );
   }
 
   /**
    * Must be overriden by children
    */
-  static get collection () {
-    throw new Error('Model.collection must be defined');
+  static get collection() {
+    throw new Error("Model.collection must be defined");
   }
 
   /**
    * Must be overriden by children
    */
-  static get fields () {
-    throw new Error('Model.fields must be defined');
+  static get fields() {
+    throw new Error("Model.fields must be defined");
   }
 
   // Static protected methods ==================================================
@@ -260,7 +264,7 @@ class BaseModel {
    *
    * @returns {BaseModel}
    */
-  static _instantiateFromDb ({ _id, _source }) {
+  static _instantiateFromDb({ _id, _source }) {
     const model = new this(_source, _id); // NOSONAR
 
     model.__persisted = true;

package/lib/service/cache/redis.js

@@ -19,15 +19,14 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { flatten, uniq } = require('lodash');
-const Bluebird = require('bluebird');
-const IORedis = require('ioredis');
-
-const kerror = require('../../kerror').wrap('services', 'cache');
-const Service = require('../service');
+const { flatten, uniq } = require("lodash");
+const Bluebird = require("bluebird");
+const IORedis = require("ioredis");
 
+const kerror = require("../../kerror").wrap("services", "cache");
+const Service = require("../service");
 
 /**
  * @class Redis
@@ -36,8 +35,8 @@ const Service = require('../service');
  * @property service
  */
 class Redis extends Service {
-  constructor (config, name) {
-    super('redis', config);
+  constructor(config, name) {
+    super("redis", config);
 
     this.connected = false;
     this.client = null;
@@ -52,30 +51,34 @@ class Redis extends Service {
    *
    * @returns {Promise}
    */
-  _initSequence () {
+  _initSequence() {
     const config = JSON.parse(JSON.stringify(this._config));
 
     // Only way to connect to AWS ELastiCache
     // https://github.com/luin/ioredis#special-note-aws-elasticache-clusters-with-tls
     if (config.overrideDnsLookup) {
-      config.clusterOptions.dnsLookup = (address, callback) => callback(null, address);
+      config.clusterOptions.dnsLookup = (address, callback) =>
+        callback(null, address);
     }
 
     if (config.nodes) {
-      this.client = this._buildClusterClient(
-        { ...config.clusterOptions, redisOptions: config.options });
-    }
-    else {
+      this.client = this._buildClusterClient({
+        ...config.clusterOptions,
+        redisOptions: config.options,
+      });
+    } else {
       this.client = this._buildClient(config.options);
     }
 
-    this.client.on('ready', () => {
+    this.client.on("ready", () => {
       this.connected = true;
     });
 
-    this.client.on('error', error => {
+    this.client.on("error", (error) => {
       if (this.connected) {
-        global.kuzzle.log.error(`Redis service seem to be down, see original error for more info:\n${error.message}`);
+        global.kuzzle.log.error(
+          `Redis service seem to be down, see original error for more info:\n${error.message}`
+        );
       }
       this.connected = false;
     });
@@ -87,12 +90,15 @@ class Redis extends Service {
     }
 
     return new Bluebird((resolve, reject) => {
-      this.client.once('ready', async () => {
-        await this.client.client('SETNAME', `${this.adapterName}/${global.kuzzle.id}`);
+      this.client.once("ready", async () => {
+        await this.client.client(
+          "SETNAME",
+          `${this.adapterName}/${global.kuzzle.id}`
+        );
         resolve();
       });
 
-      this.client.once('error', error => {
+      this.client.once("error", (error) => {
         reject(error);
       });
     });
@@ -102,13 +108,13 @@ class Redis extends Service {
    * Setup a ping interval to keep the connection alive
    * Every 60 seconds a ping is sent to Redis
    */
-  _setupKeepAlive (delay) {
-    this.client.on('ready', async () => {
+  _setupKeepAlive(delay) {
+    this.client.on("ready", async () => {
       await this._ping();
       this.pingIntervalID = setInterval(this._ping.bind(this), delay);
     });
 
-    this.client.on('error', () => {
+    this.client.on("error", () => {
       clearInterval(this.pingIntervalID);
       this.pingIntervalID = null;
     });
@@ -117,25 +123,26 @@ class Redis extends Service {
   /**
    * Ping Redis
    */
-  async _ping () {
+  async _ping() {
     try {
       await this.client.ping();
-    }
-    catch (error) {
-      global.kuzzle.log.error(`Failed to PING Redis to keep connection alive:\n${error.message}`);  
+    } catch (error) {
+      global.kuzzle.log.error(
+        `Failed to PING Redis to keep connection alive:\n${error.message}`
+      );
     }
   }
 
   /**
    * Initializes the Redis commands list, and add transformers when necessary
    */
-  setCommands () {
+  setCommands() {
     const commandsList = this.client.getBuiltinCommands();
 
     for (const command of commandsList) {
       this.commands[command] = async (...args) => {
-        if (! this.connected) {
-          throw kerror.get('notconnected');
+        if (!this.connected) {
+          throw kerror.get("notconnected");
         }
 
         return this.client[command](...args);
@@ -149,15 +156,15 @@ class Redis extends Service {
    *
    * @returns {Promise} service informations
    */
-  async info () {
+  async info() {
     const result = await this.commands.info();
-    const arr = result.replace(/\r\n/g, '\n').split('\n');
+    const arr = result.replace(/\r\n/g, "\n").split("\n");
     const info = {};
 
-    arr.forEach(item => {
+    arr.forEach((item) => {
       item = item.trim();
-      if (item.length > 0 && ! item.startsWith('#')) {
-        const keyValuePair = item.split(':');
+      if (item.length > 0 && !item.startsWith("#")) {
+        const keyValuePair = item.split(":");
         info[keyValuePair[0]] = keyValuePair[1];
       }
     });
@@ -166,7 +173,7 @@ class Redis extends Service {
       memoryPeak: info.used_memory_peak_human,
       memoryUsed: info.used_memory_human,
       mode: info.redis_mode,
-      type: 'redis',
+      type: "redis",
       version: info.redis_version,
     };
   }
@@ -181,9 +188,9 @@ class Redis extends Service {
    * @param pattern
    * @returns {Promise.<string[]>} promise resolving to an array of keys
    */
-  async searchKeys (pattern) {
+  async searchKeys(pattern) {
     if (this.client instanceof IORedis.Cluster) {
-      const keys = await Bluebird.map(this.client.nodes('master'), node => {
+      const keys = await Bluebird.map(this.client.nodes("master"), (node) => {
         return this._searchNodeKeys(node, pattern);
       });
 
@@ -198,36 +205,34 @@ class Redis extends Service {
    *
    * @returns {Promise}
    */
-  mExecute (commands) {
-    if (! Array.isArray(commands) || commands.length === 0) {
+  mExecute(commands) {
+    if (!Array.isArray(commands) || commands.length === 0) {
       return Bluebird.resolve([]);
     }
 
-    return this.client
-      .multi(commands)
-      .exec();
+    return this.client.multi(commands).exec();
   }
 
-  _searchNodeKeys (node, pattern) {
-    return new Bluebird(resolve => {
+  _searchNodeKeys(node, pattern) {
+    return new Bluebird((resolve) => {
       let keys = [];
       const stream = node.scanStream({ match: pattern });
 
-      stream.on('data', resultKeys => {
+      stream.on("data", (resultKeys) => {
         keys = keys.concat(resultKeys);
       });
 
-      stream.on('end', () => {
+      stream.on("end", () => {
         resolve(uniq(keys));
       });
     });
   }
 
-  _buildClient (options) {
+  _buildClient(options) {
     return new IORedis({ ...this._config.node, ...options });
   }
 
-  _buildClusterClient (options) {
+  _buildClusterClient(options) {
     return new IORedis.Cluster(this._config.nodes, options);
   }
 
@@ -243,20 +248,20 @@ class Redis extends Service {
    * @param  {{onlyIfNew: boolean, ttl: number}} [options]
    * @return {boolean} true if the key was set, false otherwise
    */
-  async store (key, value, { onlyIfNew = false, ttl = 0 } = {}) {
+  async store(key, value, { onlyIfNew = false, ttl = 0 } = {}) {
     const command = [key, value];
 
     if (onlyIfNew) {
-      command.push('NX');
+      command.push("NX");
     }
 
     if (ttl > 0) {
-      command.push('PX', ttl);
+      command.push("PX", ttl);
     }
 
     const result = await this.commands.set(...command);
 
-    return result === 'OK';
+    return result === "OK";
   }
 
   /**
@@ -265,7 +270,7 @@ class Redis extends Service {
    * @param  {Array} args
    * @return {Promise.<*>}
    */
-  exec (command, ...args) {
+  exec(command, ...args) {
     return this.commands[command](...args);
   }
 }

package/lib/service/service.js

@@ -19,29 +19,30 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
-const kerror = require('../kerror');
+const kerror = require("../kerror");
 
 /**
  * Services base class
  *
  */
 class Service {
-  constructor (name, config) {
+  constructor(name, config) {
     this._name = name;
     this._config = config;
-    this._initTimeout = config.initTimeout
-      || global.kuzzle.config.services.common.defaultInitTimeout;
+    this._initTimeout =
+      config.initTimeout ||
+      global.kuzzle.config.services.common.defaultInitTimeout;
   }
 
-  get config () {
+  get config() {
     return this._config;
   }
 
-  get name () {
+  get name() {
     return this._name;
   }
 
@@ -51,13 +52,12 @@ class Service {
    *
    * @returns {Promise}
    */
-  init () {
-    return Bluebird
-      .resolve(this._initSequence())
+  init() {
+    return Bluebird.resolve(this._initSequence())
       .timeout(this._initTimeout)
-      .catch(e => {
+      .catch((e) => {
         if (e instanceof Bluebird.TimeoutError) {
-          throw kerror.get('core', 'fatal', 'service_timeout', this._name);
+          throw kerror.get("core", "fatal", "service_timeout", this._name);
         }
 
         throw e;
@@ -68,16 +68,16 @@ class Service {
    * @abstract
    * @returns {Promise}
    */
-  _initSequence () {
-    throw new Error('Not implemented');
+  _initSequence() {
+    throw new Error("Not implemented");
   }
 
   /**
    * @abstract
    * @returns {Promise}
    */
-  info () {
-    throw new Error('Not implemented');
+  info() {
+    throw new Error("Not implemented");
   }
 }