kuzzle 2.19.2 → 2.19.3

package/lib/core/plugin/plugin.js

@@ -19,27 +19,27 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const path = require('path');
-const fs = require('fs');
-const semver = require('semver');
+const path = require("path");
+const fs = require("fs");
+const semver = require("semver");
 
-const { PluginContext } = require('./pluginContext');
-const PrivilegedPluginContext = require('./privilegedContext');
-const kerror = require('../../kerror');
-const errorCodes = require('../../kerror/codes');
-const Manifest = require('./pluginManifest');
-const { has, isPlainObject } = require('../../util/safeObject');
+const { PluginContext } = require("./pluginContext");
+const PrivilegedPluginContext = require("./privilegedContext");
+const kerror = require("../../kerror");
+const errorCodes = require("../../kerror/codes");
+const Manifest = require("./pluginManifest");
+const { has, isPlainObject } = require("../../util/safeObject");
 
-const assertionError = kerror.wrap('plugin', 'assert');
-const runtimeError = kerror.wrap('plugin', 'runtime');
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
 
 const PLUGIN_NAME_REGEX = /^[a-z-\d]+$/;
-const HTTP_VERBS = ['get', 'head', 'post', 'put', 'delete', 'patch', 'options'];
+const HTTP_VERBS = ["get", "head", "post", "put", "delete", "patch", "options"];
 
 class Plugin {
-  constructor (
+  constructor(
     instance,
     { name, application = false, deprecationWarning = true } = {}
   ) {
@@ -50,8 +50,8 @@ class Plugin {
     this._initCalled = false;
     this._config = {};
     this._context = null;
-    this._version = instance.version || '';
-    this._name = '';
+    this._version = instance.version || "";
+    this._name = "";
     this._manifest = instance._manifest || null;
     this._deprecationWarning = deprecationWarning;
 
@@ -60,33 +60,40 @@ class Plugin {
     }
   }
 
-  init (name) {
+  init(name) {
     this.name = name;
 
     if (global.kuzzle.config.plugins[this.name]) {
-      this.config = JSON.parse(JSON.stringify(global.kuzzle.config.plugins[this.name]));
+      this.config = JSON.parse(
+        JSON.stringify(global.kuzzle.config.plugins[this.name])
+      );
     }
 
     // check plugin privileged prerequisites
     // user need to acknowledge privileged mode in plugin configuration
     if (this.config.privileged) {
-      if (! this.manifest || ! this.manifest.privileged) {
-        throw assertionError.get('privileged_not_supported', this.name);
+      if (!this.manifest || !this.manifest.privileged) {
+        throw assertionError.get("privileged_not_supported", this.name);
       }
-    }
-    else if (this.manifest && this.manifest.privileged) {
-      throw assertionError.get('privileged_not_set', this.name);
+    } else if (this.manifest && this.manifest.privileged) {
+      throw assertionError.get("privileged_not_set", this.name);
     }
 
     if (this.manifest && this.manifest.kuzzleVersion) {
-      if (! semver.satisfies(global.kuzzle.config.version, this.manifest.kuzzleVersion)) {
+      if (
+        !semver.satisfies(
+          global.kuzzle.config.version,
+          this.manifest.kuzzleVersion
+        )
+      ) {
         throw kerror.get(
-          'plugin',
-          'manifest',
-          'version_mismatch',
+          "plugin",
+          "manifest",
+          "version_mismatch",
           this.name,
           global.kuzzle.config.version,
-          this.manifest.kuzzleVersion);
+          this.manifest.kuzzleVersion
+        );
       }
     }
 
@@ -95,7 +102,7 @@ class Plugin {
       : new PluginContext(this.name);
   }
 
-  info () {
+  info() {
     /* eslint-disable sort-keys */
     if (this.application) {
       return {
@@ -115,36 +122,36 @@ class Plugin {
       pipes: [],
       routes: [],
       strategies: [],
-      version: this.version
+      version: this.version,
     };
     /* eslint-enable sort-keys */
 
-    if (has(this.instance, 'hooks')) {
+    if (has(this.instance, "hooks")) {
       description.hooks = Object.keys(this.instance.hooks);
     }
 
-    if (has(this.instance, 'pipes')) {
+    if (has(this.instance, "pipes")) {
       description.pipes = Object.keys(this.instance.pipes);
     }
 
-    if (has(this.instance, 'controllers')) {
-      description.controllers = Object
-        .keys(this.instance.controllers)
-        .map(controller => `${this.name}/${controller}`);
+    if (has(this.instance, "controllers")) {
+      description.controllers = Object.keys(this.instance.controllers).map(
+        (controller) => `${this.name}/${controller}`
+      );
     }
 
-    if (has(this.instance, 'routes')) {
+    if (has(this.instance, "routes")) {
       description.routes = this.instance.routes;
     }
 
-    if (has(this.instance, 'strategies')) {
+    if (has(this.instance, "strategies")) {
       description.strategies = Object.keys(this.instance.strategies);
     }
 
     return description;
   }
 
-  printDeprecation (message) {
+  printDeprecation(message) {
     if (this.deprecationWarning) {
       global.kuzzle.log.warn(`${this.logPrefix} ${message}`);
     }
@@ -152,66 +159,68 @@ class Plugin {
 
   // getters/setters ===========================================================
 
-  get instance () {
+  get instance() {
     return this._instance;
   }
 
-  get context () {
+  get context() {
     return this._context;
   }
 
-  get application () {
+  get application() {
     return this._application;
   }
 
-  get logPrefix () {
+  get logPrefix() {
     return `[${this.name}]`;
   }
 
-  get config () {
+  get config() {
     return this._config;
   }
-  set config (config) {
+  set config(config) {
     this._config = config;
   }
 
-  get version () {
+  get version() {
     return this._version;
   }
-  set version (version) {
+  set version(version) {
     this._version = version;
   }
 
-  get deprecationWarning () {
+  get deprecationWarning() {
     return this._deprecationWarning;
   }
-  set deprecationWarning (value) {
+  set deprecationWarning(value) {
     this._deprecationWarning = value;
   }
 
-  get name () {
+  get name() {
     return this._name;
   }
-  set name (name) {
-    if (! this.constructor.checkName(name)) {
-      this.printDeprecation('Plugin names should be in kebab-case. This behavior will be enforced in futur versions of Kuzzle.');
+  set name(name) {
+    if (!this.constructor.checkName(name)) {
+      this.printDeprecation(
+        "Plugin names should be in kebab-case. This behavior will be enforced in futur versions of Kuzzle."
+      );
     }
 
     this._name = name;
   }
 
-  get manifest () {
+  get manifest() {
     return this._manifest;
   }
-  set manifest (manifest) {
+  set manifest(manifest) {
     this._manifest = manifest;
   }
 
   // static methods ============================================================
 
-  static loadFromDirectory (pluginPath) {
-    if (! fs.statSync(pluginPath).isDirectory()) {
-      throw assertionError.get('cannot_load', pluginPath, 'Not a directory.');
+  static loadFromDirectory(pluginPath) {
+    if (!fs.statSync(pluginPath).isDirectory()) {
+      throw assertionError.get("cannot_load", pluginPath, "Not a directory.");
     }
 
     let plugin;
@@ -222,13 +231,12 @@ class Plugin {
       const pluginInstance = new PluginClass();
 
       plugin = new Plugin(pluginInstance);
-    }
-    catch (error) {
+    } catch (error) {
       if (error.message.match(/not a constructor/i)) {
-        throw assertionError.get('not_a_constructor', PluginClass.name);
+        throw assertionError.get("not_a_constructor", PluginClass.name);
       }
 
-      throw runtimeError.getFrom(error, 'unexpected_error', error.message);
+      throw runtimeError.getFrom(error, "unexpected_error", error.message);
     }
 
     // load manifest
@@ -238,8 +246,8 @@ class Plugin {
     plugin.name = plugin.manifest.name;
 
     // load plugin version if exists
-    const packageJsonPath = path.join(pluginPath, 'package.json');
-    if (fs.existsSync(packageJsonPath) && ! plugin.version) {
+    const packageJsonPath = path.join(pluginPath, "package.json");
+    if (fs.existsSync(packageJsonPath) && !plugin.version) {
       plugin.version = require(packageJsonPath).version;
     }
 
@@ -249,25 +257,27 @@ class Plugin {
         // we use the manifest name instead of the lowerCased plugin name
         // to ensure to match the plugin original name in the configuration
         const config = global.kuzzle.config[plugin.manifest.name];
-        const pluginCode = config && config._pluginCode
-          ? config._pluginCode
-          : 0x00;
+        const pluginCode =
+          config && config._pluginCode ? config._pluginCode : 0x00;
 
         errorCodes.loadPluginsErrors(plugin.manifest.raw, pluginCode);
 
-        global.kuzzle.log.info(`${plugin.logPrefix} Custom errors successfully loaded.`);
-      }
-      catch (err) {
-        if ( err.message.match(/Error configuration file/i)
-          || err instanceof SyntaxError
+        global.kuzzle.log.info(
+          `${plugin.logPrefix} Custom errors successfully loaded.`
+        );
+      } catch (err) {
+        if (
+          err.message.match(/Error configuration file/i) ||
+          err instanceof SyntaxError
         ) {
           throw kerror.getFrom(
             err,
-            'plugin',
-            'manifest',
-            'invalid_errors',
+            "plugin",
+            "manifest",
+            "invalid_errors",
             plugin.manifest.name,
-            err.message);
+            err.message
+          );
         }
 
         throw err;
@@ -275,101 +285,121 @@ class Plugin {
     }
 
     // check if the plugin exposes a "init" method
-    if (typeof plugin.instance.init !== 'function') {
-      throw assertionError.get('init_not_found', plugin.name);
+    if (typeof plugin.instance.init !== "function") {
+      throw assertionError.get("init_not_found", plugin.name);
     }
 
     return plugin;
   }
 
-  static checkName (name) {
+  static checkName(name) {
     return PLUGIN_NAME_REGEX.test(name);
   }
 
-  static checkControllerDefinition (name, definition, { application = false } = {}) {
-    if (typeof name !== 'string') {
+  static checkControllerDefinition(
+    name,
+    definition,
+    { application = false } = {}
+  ) {
+    if (typeof name !== "string") {
       throw assertionError.get(
-        'invalid_controller_definition',
-        'Controller name must be a string');
+        "invalid_controller_definition",
+        "Controller name must be a string"
+      );
     }
 
-    if (! isPlainObject(definition)) {
+    if (!isPlainObject(definition)) {
       throw assertionError.get(
-        'invalid_controller_definition',
+        "invalid_controller_definition",
         name,
-        'Controller definition must be an object');
+        "Controller definition must be an object"
+      );
     }
 
-    if (! isPlainObject(definition.actions)) {
+    if (!isPlainObject(definition.actions)) {
       throw assertionError.get(
-        'invalid_controller_definition',
+        "invalid_controller_definition",
         name,
-        'Controller definition "actions" property must be an object');
+        'Controller definition "actions" property must be an object'
+      );
     }
 
-    for (const [action, actionDefinition] of Object.entries(definition.actions)) {
+    for (const [action, actionDefinition] of Object.entries(
+      definition.actions
+    )) {
       const actionProperties = Object.keys(actionDefinition);
 
       if (actionProperties.length > 2) {
-        actionProperties.splice(actionProperties.indexOf('handler'), 1);
-        actionProperties.splice(actionProperties.indexOf('http'), 1);
+        actionProperties.splice(actionProperties.indexOf("handler"), 1);
+        actionProperties.splice(actionProperties.indexOf("http"), 1);
 
         throw assertionError.get(
-          'invalid_controller_definition',
+          "invalid_controller_definition",
           name,
-          `action "${action}" has invalid properties: ${actionProperties.join(', ')}`);
+          `action "${action}" has invalid properties: ${actionProperties.join(
+            ", "
+          )}`
+        );
       }
 
-      if (typeof action !== 'string') {
+      if (typeof action !== "string") {
         throw assertionError.get(
-          'invalid_controller_definition',
+          "invalid_controller_definition",
           name,
-          'action names must be strings');
+          "action names must be strings"
+        );
       }
 
-      if (typeof actionDefinition.handler !== 'function') {
+      if (typeof actionDefinition.handler !== "function") {
         throw assertionError.get(
-          'invalid_controller_definition',
+          "invalid_controller_definition",
           name,
-          `action "${action}" handler must be a function`);
+          `action "${action}" handler must be a function`
+        );
       }
 
       if (actionDefinition.http) {
-        if (! Array.isArray(actionDefinition.http)) {
+        if (!Array.isArray(actionDefinition.http)) {
           throw assertionError.get(
-            'invalid_controller_definition',
+            "invalid_controller_definition",
             name,
-            `action "${action}" http definition must be an array`);
+            `action "${action}" http definition must be an array`
+          );
         }
 
         for (const route of actionDefinition.http) {
-          if (typeof route.verb !== 'string' || route.verb.length === 0) {
+          if (typeof route.verb !== "string" || route.verb.length === 0) {
             throw assertionError.get(
-              'invalid_controller_definition',
+              "invalid_controller_definition",
               name,
-              `action "${action}" http "verb" property must be a non-empty string`);
+              `action "${action}" http "verb" property must be a non-empty string`
+            );
           }
 
-          if (! HTTP_VERBS.includes(route.verb.toLowerCase())) {
+          if (!HTTP_VERBS.includes(route.verb.toLowerCase())) {
             throw assertionError.get(
-              'invalid_controller_definition',
+              "invalid_controller_definition",
               name,
-              `action "${action}" http verb "${route.verb}" is not a valid http verb`);
+              `action "${action}" http verb "${route.verb}" is not a valid http verb`
+            );
           }
 
           checkHttpRouteProperties(route, action, name, application);
 
           const routeProperties = Object.keys(route);
           if (routeProperties.length > 3) {
-            routeProperties.splice(routeProperties.indexOf('url'), 1);
-            routeProperties.splice(routeProperties.indexOf('path'), 1);
-            routeProperties.splice(routeProperties.indexOf('verb'), 1);
-            routeProperties.splice(routeProperties.indexOf('openapi'), 1);
+            routeProperties.splice(routeProperties.indexOf("url"), 1);
+            routeProperties.splice(routeProperties.indexOf("path"), 1);
+            routeProperties.splice(routeProperties.indexOf("verb"), 1);
+            routeProperties.splice(routeProperties.indexOf("openapi"), 1);
 
             throw assertionError.get(
-              'invalid_controller_definition',
+              "invalid_controller_definition",
               name,
-              `action "${action}" has invalid http properties: ${routeProperties.join(', ')}`);
+              `action "${action}" has invalid http properties: ${routeProperties.join(
+                ", "
+              )}`
+            );
           }
         }
       }
@@ -377,16 +407,17 @@ class Plugin {
   }
 }
 
-function checkHttpRouteProperties (route, action, name, application) {
-  if (typeof route.path !== 'string' || route.path.length === 0) {
-    if (! application && (typeof route.url === 'string' && route.url.length > 0)) {
+function checkHttpRouteProperties(route, action, name, application) {
+  if (typeof route.path !== "string" || route.path.length === 0) {
+    if (!application && typeof route.url === "string" && route.url.length > 0) {
       return;
     }
 
     throw assertionError.get(
-      'invalid_controller_definition',
+      "invalid_controller_definition",
       name,
-      `action "${action}" http "path" property must be a non-empty string`);
+      `action "${action}" http "path" property must be a non-empty string`
+    );
   }
 }
 

package/lib/core/plugin/pluginContext.d.ts

@@ -1,10 +1,10 @@
-import { Koncorde } from '../shared/KoncordeWrapper';
-import { Client } from '@elastic/elasticsearch';
-import { JSONObject } from 'kuzzle-sdk';
-import { EmbeddedSDK } from '../shared/sdk/embeddedSdk';
-import { Mutex } from '../../util/mutex';
-import { RequestContext, RequestInput, KuzzleRequest } from '../../../index';
-import { BackendCluster } from '../backend';
+import { Koncorde } from "../shared/KoncordeWrapper";
+import { Client } from "@elastic/elasticsearch";
+import { JSONObject } from "kuzzle-sdk";
+import { EmbeddedSDK } from "../shared/sdk/embeddedSdk";
+import { Mutex } from "../../util/mutex";
+import { RequestContext, RequestInput, KuzzleRequest } from "../../../index";
+import { BackendCluster } from "../backend";
 export interface Repository {
     create(document: JSONObject, options: any): Promise<any>;
     createOrReplace(document: JSONObject, options: any): Promise<any>;