kuzzle 2.16.1 → 2.16.5

package/lib/api/request/requestInput.js

@@ -19,13 +19,37 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestInput = exports.RequestResource = void 0;
 const internalError_1 = require("../../kerror/errors/internalError");
-const assertType_1 = __importDefault(require("../../util/assertType"));
+const assert = __importStar(require("../../util/assertType"));
+// private properties
+// \u200b is a zero width space, used to masquerade console.log output
+const _jwt = 'jwt\u200b';
+const _volatile = 'volatile\u200b';
+const _body = 'body\u200b';
+const _headers = 'headers\u200b';
+const _controller = 'controller\u200b';
+const _action = 'action\u200b';
 // any property not listed here will be copied into
 // RequestInput.args
 const resourceProperties = new Set([
@@ -44,7 +68,6 @@ class RequestResource {
     }
     /**
      * Document ID
-     * @deprecated
      */
     get _id() {
         return this.args._id;
@@ -54,7 +77,6 @@ class RequestResource {
     }
     /**
      * Index name
-     * @deprecated
      */
     get index() {
         return this.args.index;
@@ -64,7 +86,6 @@ class RequestResource {
     }
     /**
      * Collection name
-     * @deprecated
      */
     get collection() {
         return this.args.collection;
@@ -93,109 +114,14 @@ class RequestInput {
      * Any undefined option is set to null
      */
     constructor(data) {
-        /**
-         * Authentication token.
-         * @example
-         * // original JSON request sent to Kuzzle
-         * {
-         *   controller
-         *   action,
-         *   _id,
-         *   index,
-         *   collection,
-         *   jwt,        <== that
-         *   refresh,
-         *   foobar,
-         *   volatile,
-         *   body
-         *  }
-         */
-        this.jwt = null;
-        /**
-         * API controller name.
-         * @example
-         * // original JSON request sent to Kuzzle
-         * {
-         *   controller  <== that
-         *   action,
-         *   _id,
-         *   index,
-         *   collection,
-         *   jwt,
-         *   refresh,
-         *   foobar,
-         *   volatile,
-         *   body
-         *  }
-         */
-        this.controller = null;
-        /**
-         * API action name.
-         * @example
-         * // original JSON request sent to Kuzzle
-         * {
-         *   controller
-         *   action,      <== that
-         *   _id,
-         *   index,
-         *   collection,
-         *   jwt,
-         *   refresh,
-         *   foobar,
-         *   volatile,
-         *   body
-         *  }
-         */
-        this.action = null;
-        /**
-         * Request body.
-         * In Http it's the request body parsed.
-         * @example
-         * // original JSON request sent to Kuzzle
-         * {
-         *   controller
-         *   action,
-         *   _id,
-         *   index,
-         *   collection,
-         *   jwt,
-         *   refresh,
-         *   foobar,
-         *   volatile,
-         *   body         <== that
-         *  }
-         */
-        this.body = {};
-        /**
-         * Request headers (Http only).
-         */
-        this.headers = null;
-        /**
-         * Volatile object.
-         * @example
-         * // original JSON request sent to Kuzzle
-         * {
-         *   controller
-         *   action,
-         *   _id,
-         *   index,
-         *   collection,
-         *   jwt,
-         *   refresh,
-         *   foobar,
-         *   volatile,    <== that
-         *   body
-         *  }
-         */
-        this.volatile = null;
         if (!data || typeof data !== 'object' || Array.isArray(data)) {
             throw new internalError_1.InternalError('Input request data must be a non-null object');
         }
-        this.jwt = null;
-        this.volatile = null;
-        this.body = null;
-        this.controller = null;
-        this.action = null;
+        this[_jwt] = null;
+        this[_volatile] = null;
+        this[_body] = null;
+        this[_controller] = null;
+        this[_action] = null;
         // default value to null for former "resources" to avoid breaking
         this.args = {};
         this.resource = new RequestResource(this.args);
@@ -205,17 +131,151 @@ class RequestInput {
                 this.args[k] = data[k];
             }
         }
-        if (data.jwt) {
-            this.jwt = data.jwt;
-        }
-        if (data.volatile) {
-            this.volatile = data.volatile;
+        // @deprecated - RequestContext.connection.misc.headers should be used instead
+        // initialize `_headers` property after the population of `this.args` attribute
+        // `this.headers` can contain protocol specific headers and should be
+        // set after the Request construction
+        // `args.headers` can be an attribute coming from data itself.
+        this[_headers] = null;
+        Object.seal(this);
+        this.jwt = data.jwt;
+        this.volatile = data.volatile;
+        this.body = data.body;
+        this.controller = data.controller;
+        this.action = data.action;
+    }
+    /**
+     * Authentication token.
+     * @example
+     * // original JSON request sent to Kuzzle
+     * {
+     *   controller
+     *   action,
+     *   _id,
+     *   index,
+     *   collection,
+     *   jwt,        <== that
+     *   refresh,
+     *   foobar,
+     *   volatile,
+     *   body
+     *  }
+     */
+    get jwt() {
+        return this[_jwt];
+    }
+    set jwt(str) {
+        this[_jwt] = assert.assertString('jwt', str);
+    }
+    /**
+     * API controller name.
+     * @example
+     * // original JSON request sent to Kuzzle
+     * {
+     *   controller  <== that
+     *   action,
+     *   _id,
+     *   index,
+     *   collection,
+     *   jwt,
+     *   refresh,
+     *   foobar,
+     *   volatile,
+     *   body
+     *  }
+     */
+    get controller() {
+        return this[_controller];
+    }
+    set controller(str) {
+        // can only be set once
+        if (!this[_controller]) {
+            this[_controller] = assert.assertString('controller', str);
         }
-        if (data.body) {
-            this.body = data.body;
+    }
+    /**
+     * API action name.
+     * @example
+     * // original JSON request sent to Kuzzle
+     * {
+     *   controller
+     *   action,      <== that
+     *   _id,
+     *   index,
+     *   collection,
+     *   jwt,
+     *   refresh,
+     *   foobar,
+     *   volatile,
+     *   body
+     *  }
+     */
+    get action() {
+        return this[_action];
+    }
+    set action(str) {
+        // can only be set once
+        if (!this[_action]) {
+            this[_action] = assert.assertString('action', str);
         }
-        this.controller = assertType_1.default.assertString('controller', data.controller);
-        this.action = assertType_1.default.assertString('controller', data.action);
+    }
+    /**
+     * Request body.
+     * In Http it's the request body parsed.
+     * @example
+     * // original JSON request sent to Kuzzle
+     * {
+     *   controller
+     *   action,
+     *   _id,
+     *   index,
+     *   collection,
+     *   jwt,
+     *   refresh,
+     *   foobar,
+     *   volatile,
+     *   body         <== that
+     *  }
+     */
+    get body() {
+        return this[_body];
+    }
+    set body(obj) {
+        this[_body] = assert.assertObject('body', obj);
+    }
+    /**
+     * Request headers (Http only).
+     *
+     * @deprecated Use RequestContext.connection.misc.headers instead
+     */
+    get headers() {
+        return this[_headers];
+    }
+    set headers(obj) {
+        this[_headers] = assert.assertObject('headers', obj);
+    }
+    /**
+     * Volatile object.
+     * @example
+     * // original JSON request sent to Kuzzle
+     * {
+     *   controller
+     *   action,
+     *   _id,
+     *   index,
+     *   collection,
+     *   jwt,
+     *   refresh,
+     *   foobar,
+     *   volatile,    <== that
+     *   body
+     *  }
+     */
+    get volatile() {
+        return this[_volatile];
+    }
+    set volatile(obj) {
+        this[_volatile] = assert.assertObject('volatile', obj);
     }
 }
 exports.RequestInput = RequestInput;

package/lib/api/request/requestResponse.d.ts

@@ -1,19 +1,17 @@
 import { JSONObject } from 'kuzzle-sdk';
-import '../../../lib/types/Global';
 import { Deprecation } from '../../types';
 import { KuzzleError } from '../../kerror/errors/kuzzleError';
-import { KuzzleRequest } from './kuzzleRequest';
 export declare class Headers {
     headers: JSONObject;
     private namesMap;
-    proxy: any;
+    private proxy;
     constructor();
     /**
      * Gets a header value
      *
      * @param name Header name. Could be a string (case-insensitive) or a symbol
      */
-    getHeader(name: any): string;
+    getHeader(name: any): string | void;
     removeHeader(name: string): boolean;
     setHeader(name: string, value: string): boolean;
 }
@@ -21,22 +19,20 @@ export declare class Headers {
  * Kuzzle normalized API response
  */
 export declare class RequestResponse {
-    private request;
-    private _headers;
     /**
      * If sets to true, "result" content will not be wrapped in a Kuzzle response
      */
     raw: boolean;
-    constructor(request: KuzzleRequest);
+    constructor(request: any);
     /**
      * Get the parent request deprecations
      */
-    get deprecations(): Array<Deprecation>;
+    get deprecations(): Array<Deprecation> | void;
     /**
      * Set the parent request deprecations
      * @param {Object[]} deprecations
      */
-    set deprecations(deprecations: Array<Deprecation>);
+    set deprecations(deprecations: Array<Deprecation> | void);
     /**
      * Get the parent request status
      * @returns {number}
@@ -103,16 +99,16 @@ export declare class RequestResponse {
     /**
      * Gets a header value (case-insensitive)
      */
-    getHeader(name: string): string;
+    getHeader(name: string): string | null;
     /**
      * Deletes a header (case-insensitive)
      */
-    removeHeader(name: string): boolean;
+    removeHeader(name: string): any;
     /**
      * Sets a new array. Behaves the same as Node.js' HTTP response.setHeader
      * method (@see https://nodejs.org/api/http.html#http_response_setheader_name_value)
      */
-    setHeader(name: string, value: string): boolean;
+    setHeader(name: string, value: string): any;
     /**
      * Adds new multiple headers.
      */

package/lib/api/request/requestResponse.js

@@ -40,8 +40,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestResponse = exports.Headers = void 0;
-require("../../../lib/types/Global");
 const assert = __importStar(require("../../util/assertType"));
+// private properties
+// \u200b is a zero width space, used to masquerade console.log output
+const _request = 'request\u200b';
+const _headers = 'headers\u200b';
 class Headers {
     constructor() {
         this.namesMap = new Map();
@@ -51,10 +54,7 @@ class Headers {
             get: (target, name) => this.getHeader(name),
             set: (target, name, value) => this.setHeader(name, value),
         });
-        // eslint-disable-next-line dot-notation
-        if (global['_kuzzle'] && global.kuzzle) {
-            this.setHeader('X-Kuzzle-Node', global.kuzzle.id);
-        }
+        this.setHeader('X-Kuzzle-Node', global.kuzzle.id);
     }
     /**
      * Gets a header value
@@ -144,104 +144,98 @@ exports.Headers = Headers;
 class RequestResponse {
     constructor(request) {
         this.raw = false;
-        // Make a private property otherwise the tests are ending in recursive loop
-        Reflect.defineProperty(this, 'request', {
-            value: request,
-        });
-        this._headers = new Headers();
+        this[_request] = request;
+        this[_headers] = new Headers();
+        Object.seal(this);
     }
     /**
      * Get the parent request deprecations
      */
     get deprecations() {
-        return this.request.deprecations;
+        return this[_request].deprecations;
     }
     /**
      * Set the parent request deprecations
      * @param {Object[]} deprecations
      */
     set deprecations(deprecations) {
-        this.request.deprecations = deprecations;
+        this[_request].deprecations = deprecations;
     }
     /**
      * Get the parent request status
      * @returns {number}
      */
     get status() {
-        return this.request.status;
+        return this[_request].status;
     }
     set status(s) {
-        this.request.status = s;
+        this[_request].status = s;
     }
     /**
      * Request error
      */
     get error() {
-        return this.request.error;
+        return this[_request].error;
     }
     set error(e) {
-        this.request.setError(e);
+        this[_request].setError(e);
     }
     /**
      * Request external ID
      */
     get requestId() {
-        return this.request.id;
+        return this[_request].id;
     }
     /**
      * API controller name
      */
     get controller() {
-        return this.request.input.controller;
+        return this[_request].input.controller;
     }
     /**
      * API action name
      */
     get action() {
-        return this.request.input.action;
+        return this[_request].input.action;
     }
     /**
      * Collection name
      */
     get collection() {
-        return this.request.input.resource.collection;
+        return this[_request].input.resource.collection;
     }
     /**
      * Index name
      */
     get index() {
-        return this.request.input.resource.index;
+        return this[_request].input.resource.index;
     }
     /**
      * Volatile object
      */
     get volatile() {
-        return this.request.input.volatile;
+        return this[_request].input.volatile;
     }
     /**
      * Response headers
      */
     get headers() {
-        return this._headers.proxy;
+        return this[_headers].proxy;
     }
     /**
      * Request result
      */
     get result() {
-        return this.request.result;
+        return this[_request].result;
     }
     set result(r) {
-        this.request.setResult(r);
+        this[_request].setResult(r);
     }
     /**
      * Node identifier
      */
     get node() {
-        // eslint-disable-next-line dot-notation
-        if (global['_kuzzle'] && global.kuzzle) {
-            return global.kuzzle.id;
-        }
-        return null;
+        return global.kuzzle.id;
     }
     /**
      * Configure the response
@@ -271,20 +265,20 @@ class RequestResponse {
      * Gets a header value (case-insensitive)
      */
     getHeader(name) {
-        return this._headers.getHeader(name);
+        return this[_headers].getHeader(name);
     }
     /**
      * Deletes a header (case-insensitive)
      */
     removeHeader(name) {
-        return this._headers.removeHeader(name);
+        return this[_headers].removeHeader(name);
     }
     /**
      * Sets a new array. Behaves the same as Node.js' HTTP response.setHeader
      * method (@see https://nodejs.org/api/http.html#http_response_setheader_name_value)
      */
     setHeader(name, value) {
-        return this._headers.setHeader(name, value);
+        return this[_headers].setHeader(name, value);
     }
     /**
      * Adds new multiple headers.
@@ -307,7 +301,7 @@ class RequestResponse {
         if (this.raw === true) {
             return {
                 content: this.result,
-                headers: this._headers.headers,
+                headers: this.headers,
                 raw: true,
                 requestId: this.requestId,
                 status: this.status,
@@ -327,7 +321,7 @@ class RequestResponse {
                 status: this.status,
                 volatile: this.volatile,
             },
-            headers: this._headers.headers,
+            headers: this.headers,
             raw: false,
             requestId: this.requestId,
             status: this.status,

package/lib/core/backend/backendController.js

@@ -141,9 +141,6 @@ class BackendController extends index_1.ApplicationManager {
         this._add(controller.name, controller.definition);
     }
     _add(name, definition) {
-        // Check definition here to throw error early
-        // with the corresponding line number
-        this._application.PluginObject.checkControllerDefinition(name, definition, { application: true });
         if (this._application._controllers[name]) {
             throw assertionError.get('invalid_controller_definition', name, 'A controller with this name already exists');
         }

package/lib/core/plugin/plugin.js

@@ -264,7 +264,7 @@ class Plugin {
     return PLUGIN_NAME_REGEX.test(name);
   }
 
-  static checkControllerDefinition (name, definition, { application=false } = {}) {
+  static async checkControllerDefinition (name, definition, { application=false } = {}) {
     if (typeof name !== 'string') {
       throw assertionError.get(
         'invalid_controller_definition',
@@ -344,7 +344,7 @@ class Plugin {
           }
 
           if (route.openapi) {
-            checkOpenAPISpecification(name, action, route);
+            await checkOpenAPISpecification(name, action, route);
           }
         }
       }
@@ -365,20 +365,24 @@ function checkHttpRouteProperties (route, action, name, application) {
   }
 }
 
-function checkOpenAPISpecification (controller, action, route) {
+async function checkOpenAPISpecification (controller, action, route) {
   if (! isPlainObject(route.openapi)) {
     throw assertionError.get(
       'invalid_controller_definition',
       controller,
-      'The "openapi" property must be an object');
+      'The "openapi" property of the route definition must be an object');
   }
 
+  const routePath = route.path.charAt(0) === '/'
+    ? route.path
+    : `/_/${route.path}`;
+
   // Set :param notation to {param}
-  const formattedPath = route.path.replace(/\/:([^/]*)/g,'/{$1}');
+  const formattedPath = routePath.replace(/\/:([^/]*)/g,'/{$1}');
 
-  const { error, warning } = enforcer({
+  const { error, warning } = await enforcer({
     /* eslint-disable sort-keys */
-    openapi: '3.0.1',
+    openapi: '3.0.0',
     info: {
       title: 'Kuzzle API',
       version: require('../../../package').version
@@ -394,8 +398,14 @@ function checkOpenAPISpecification (controller, action, route) {
   if (warning) {
     global.kuzzle.log.warn(`Warning for OpenAPI specification in "${controller}:${action}", ${route.openapi} : ${warning}`);
   }
+
   if (error) {
-    throw controllerError.get('invalid_openapi_schema', controller, action, route.openapi, error);
+    throw controllerError.get(
+      'invalid_openapi_schema',
+      controller,
+      action,
+      route.openapi,
+      error);
   }
 }
 

package/lib/core/plugin/pluginsManager.js

@@ -265,9 +265,7 @@ class PluginsManager {
 
           debug('[%s] plugin started', plugin.name);
 
-          if (! plugin.application) {
-            this.loadedPlugins.push(plugin.name);
-          }
+          this.loadedPlugins.push(plugin.name);
 
           return null;
         });
@@ -680,7 +678,7 @@ class PluginsManager {
           'Native controllers cannot be overriden');
       }
 
-      Plugin.checkControllerDefinition(controller, definition);
+      await Plugin.checkControllerDefinition(controller, definition);
 
       for (const [action, actionDefinition ] of Object.entries(definition.actions)) {
         let apiController = this.controllers.get(controller);