kuzzle 2.19.2 → 2.19.3

package/lib/core/backend/backendOpenApi.js

@@ -27,40 +27,40 @@ class BackendOpenApi extends index_1.ApplicationManager {
         super(application);
         /* eslint-disable sort-keys */
         this.definition = {
-            openapi: '3.0.0',
+            openapi: "3.0.0",
             info: {
                 title: `${application.name} API`,
                 description: `${application.name} HTTP API definition`,
                 contact: {
-                    name: 'Kuzzle team',
-                    url: 'https://kuzzle.io',
-                    email: 'support@kuzzle.io',
-                    discord: 'http://join.discord.kuzzle.io'
+                    name: "Kuzzle team",
+                    url: "https://kuzzle.io",
+                    email: "support@kuzzle.io",
+                    discord: "http://join.discord.kuzzle.io",
                 },
                 license: {
-                    name: 'Apache 2',
-                    url: 'http://opensource.org/licenses/apache2.0'
+                    name: "Apache 2",
+                    url: "http://opensource.org/licenses/apache2.0",
                 },
-                version: application.version
+                version: application.version,
             },
             externalDocs: {
-                description: 'Kuzzle API Documentation',
-                url: 'https://docs.kuzzle.io/core/2/api/'
+                description: "Kuzzle API Documentation",
+                url: "https://docs.kuzzle.io/core/2/api/",
             },
             servers: [
                 {
-                    url: 'https://{baseUrl}:{port}',
+                    url: "https://{baseUrl}:{port}",
                     description: `${application.name} Base Url`,
                     variables: {
-                        baseUrl: { default: 'localhost' },
+                        baseUrl: { default: "localhost" },
                         port: { default: 7512 },
-                    }
-                }
+                    },
+                },
             ],
             tags: [],
-            schemes: ['https', 'http'],
+            schemes: ["https", "http"],
             paths: {},
-            components: {}
+            components: {},
         };
         /* eslint-enable sort-keys */
     }

package/lib/core/backend/backendPipe.d.ts

@@ -1,5 +1,5 @@
-import { EventHandler } from '../../types';
-import { ApplicationManager } from './index';
+import { EventHandler } from "../../types";
+import { ApplicationManager } from "./index";
 export declare class BackendPipe extends ApplicationManager {
     /**
      * Registers a new pipe on an event

package/lib/core/backend/backendPipe.js

@@ -46,8 +46,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendPipe = void 0;
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const assertionError = kerror.wrap('plugin', 'assert');
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
 class BackendPipe extends index_1.ApplicationManager {
     /**
      * Registers a new pipe on an event
@@ -57,10 +57,10 @@ class BackendPipe extends index_1.ApplicationManager {
      */
     register(event, handler, options = {}) {
         if (this._application.started && options.dynamic !== true) {
-            throw runtimeError.get('already_started', 'pipe.register');
+            throw runtimeError.get("already_started", "pipe.register");
         }
-        if (typeof handler !== 'function') {
-            throw assertionError.get('invalid_pipe', event);
+        if (typeof handler !== "function") {
+            throw assertionError.get("invalid_pipe", event);
         }
         if (this._application.started) {
             return global.kuzzle.pluginsManager.registerPipe(global.kuzzle.pluginsManager.application, event, handler);
@@ -72,7 +72,7 @@ class BackendPipe extends index_1.ApplicationManager {
     }
     unregister(pipeId) {
         if (!this._application.started) {
-            throw runtimeError.get('unavailable_before_start', 'pipe.unregister');
+            throw runtimeError.get("unavailable_before_start", "pipe.unregister");
         }
         global.kuzzle.pluginsManager.unregisterPipe(pipeId);
     }

package/lib/core/backend/backendPlugin.d.ts

@@ -1,6 +1,6 @@
-import { JSONObject } from '../../../index';
-import { Plugin } from '../../types';
-import { ApplicationManager } from './index';
+import { JSONObject } from "../../../index";
+import { Plugin } from "../../types";
+import { ApplicationManager } from "./index";
 export declare class BackendPlugin extends ApplicationManager {
     /**
      * Uses a plugin in this application.
@@ -24,7 +24,7 @@ export declare class BackendPlugin extends ApplicationManager {
      *
      * @param name Plugin name
      */
-    get(name: string): Plugin;
+    get<TPlugin extends Plugin>(name: string): TPlugin;
     /**
      * Lists loaded plugins
      */

package/lib/core/backend/backendPlugin.js

@@ -51,8 +51,8 @@ const inflector_1 = require("../../util/inflector");
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
 const didYouMean_1 = __importDefault(require("../../util/didYouMean"));
-const assertionError = kerror.wrap('plugin', 'assert');
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
 class BackendPlugin extends index_1.ApplicationManager {
     /**
      * Uses a plugin in this application.
@@ -68,24 +68,24 @@ class BackendPlugin extends index_1.ApplicationManager {
      */
     use(plugin, options = {}) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'plugin');
+            throw runtimeError.get("already_started", "plugin");
         }
         // Avoid plain objects
-        if ((typeof plugin.constructor !== 'function'
-            || plugin.constructor.name === 'Object')
-            && !options.name) {
-            throw assertionError.get('no_name_provided');
+        if ((typeof plugin.constructor !== "function" ||
+            plugin.constructor.name === "Object") &&
+            !options.name) {
+            throw assertionError.get("no_name_provided");
         }
-        const name = options.name
-            || inflector_1.Inflector.kebabCase(plugin.constructor.name.replace('Plugin', ''));
+        const name = options.name ||
+            inflector_1.Inflector.kebabCase(plugin.constructor.name.replace("Plugin", ""));
         if (!this._application.PluginObject.checkName(name)) {
-            throw assertionError.get('invalid_plugin_name', name);
+            throw assertionError.get("invalid_plugin_name", name);
         }
         if (this._application._plugins[name]) {
-            throw assertionError.get('name_already_exists', name);
+            throw assertionError.get("name_already_exists", name);
         }
-        if (typeof plugin.init !== 'function') {
-            throw assertionError.get('init_not_found', name);
+        if (typeof plugin.init !== "function") {
+            throw assertionError.get("init_not_found", name);
         }
         this._application._plugins[name] = { options, plugin };
     }
@@ -96,7 +96,7 @@ class BackendPlugin extends index_1.ApplicationManager {
      */
     get(name) {
         if (!this._application._plugins[name]) {
-            throw assertionError.get('plugin_not_found', name, (0, didYouMean_1.default)(name, this.list()));
+            throw assertionError.get("plugin_not_found", name, (0, didYouMean_1.default)(name, this.list()));
         }
         return this._application._plugins[name].plugin;
     }

package/lib/core/backend/backendStorage.d.ts

@@ -1,5 +1,5 @@
-import { Client } from '@elastic/elasticsearch';
-import { ApplicationManager, Backend } from './index';
+import { Client } from "@elastic/elasticsearch";
+import { ApplicationManager, Backend } from "./index";
 export declare class BackendStorage extends ApplicationManager {
     private _client;
     private _Client;

package/lib/core/backend/backendStorage.js

@@ -56,8 +56,7 @@ class BackendStorage extends index_1.ApplicationManager {
      */
     get storageClient() {
         if (!this._client) {
-            this._client = elasticsearch_1.default
-                .buildClient(this._kuzzle.config.services.storageEngine.client);
+            this._client = elasticsearch_1.default.buildClient(this._kuzzle.config.services.storageEngine.client);
         }
         return this._client;
     }

package/lib/core/backend/backendVault.d.ts

@@ -1,5 +1,5 @@
-import { JSONObject } from '../../../index';
-import { ApplicationManager } from './index';
+import { JSONObject } from "../../../index";
+import { ApplicationManager } from "./index";
 export declare class BackendVault extends ApplicationManager {
     private decrypted;
     private _secrets;

package/lib/core/backend/backendVault.js

@@ -50,7 +50,7 @@ exports.BackendVault = void 0;
 const vault_1 = __importDefault(require("../../kuzzle/vault"));
 const kerror = __importStar(require("../../kerror"));
 const index_1 = require("./index");
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const runtimeError = kerror.wrap("plugin", "runtime");
 class BackendVault extends index_1.ApplicationManager {
     constructor() {
         super(...arguments);
@@ -61,7 +61,7 @@ class BackendVault extends index_1.ApplicationManager {
      */
     set key(key) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'vault');
+            throw runtimeError.get("already_started", "vault");
         }
         this._application._vaultKey = key;
     }
@@ -70,7 +70,7 @@ class BackendVault extends index_1.ApplicationManager {
      */
     set file(file) {
         if (this._application.started) {
-            throw runtimeError.get('already_started', 'vault');
+            throw runtimeError.get("already_started", "vault");
         }
         this._application._secretsFile = file;
     }

package/lib/core/backend/index.d.ts

@@ -1,14 +1,14 @@
-export * from './applicationManager';
-export * from './backend';
-export * from './backendCluster';
-export * from './backendConfig';
-export * from './backendController';
-export * from './backendHook';
-export * from './backendImport';
-export * from './backendPipe';
-export * from './backendPlugin';
-export * from './backendStorage';
-export * from './backendVault';
-export * from './backendOpenApi';
-export * from './internalLogger';
-export * from './backendErrors';
+export * from "./applicationManager";
+export * from "./backend";
+export * from "./backendCluster";
+export * from "./backendConfig";
+export * from "./backendController";
+export * from "./backendHook";
+export * from "./backendImport";
+export * from "./backendPipe";
+export * from "./backendPlugin";
+export * from "./backendStorage";
+export * from "./backendVault";
+export * from "./backendOpenApi";
+export * from "./internalLogger";
+export * from "./backendErrors";

package/lib/core/backend/internalLogger.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationManager } from './index';
+import { ApplicationManager } from "./index";
 export declare class InternalLogger extends ApplicationManager {
     /**
      * Logs an debug message

package/lib/core/backend/internalLogger.js

@@ -31,31 +31,31 @@ class InternalLogger extends index_1.ApplicationManager {
      * Logs an debug message
      */
     debug(message) {
-        this._log('debug', message);
+        this._log("debug", message);
     }
     /**
      * Logs an info message
      */
     info(message) {
-        this._log('info', message);
+        this._log("info", message);
     }
     /**
      * Logs a warn message
      */
     warn(message) {
-        this._log('warn', message);
+        this._log("warn", message);
     }
     /**
      * Logs an error message
      */
     error(message) {
-        this._log('error', message);
+        this._log("error", message);
     }
     /**
      * Logs a verbose message
      */
     verbose(message) {
-        this._log('verbose', message);
+        this._log("verbose", message);
     }
     _log(level, message) {
         if (!this._application.started) {

package/lib/core/cache/cacheDbEnum.js

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 /**
  * @typedef {string} cacheDbEnum
@@ -32,9 +32,9 @@
  * @enum {cacheDbEnum}
  */
 const cacheDbEnum = Object.freeze({
-  INTERNAL: 'internal',
-  NONE: 'none',
-  PUBLIC: 'public',
+  INTERNAL: "internal",
+  NONE: "none",
+  PUBLIC: "public",
 });
 
 module.exports = cacheDbEnum;

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)
+    );
   }
 }