kuzzle 2.15.2 → 2.16.0

package/lib/api/request/requestInput.js

@@ -19,37 +19,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestInput = exports.RequestResource = void 0;
 const internalError_1 = require("../../kerror/errors/internalError");
-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';
+const assertType_1 = __importDefault(require("../../util/assertType"));
 // any property not listed here will be copied into
 // RequestInput.args
 const resourceProperties = new Set([
@@ -68,6 +44,7 @@ class RequestResource {
     }
     /**
      * Document ID
+     * @deprecated
      */
     get _id() {
         return this.args._id;
@@ -77,6 +54,7 @@ class RequestResource {
     }
     /**
      * Index name
+     * @deprecated
      */
     get index() {
         return this.args.index;
@@ -86,6 +64,7 @@ class RequestResource {
     }
     /**
      * Collection name
+     * @deprecated
      */
     get collection() {
         return this.args.collection;
@@ -114,14 +93,109 @@ 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);
@@ -131,149 +205,17 @@ class RequestInput {
                 this.args[k] = data[k];
             }
         }
-        // @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.jwt) {
+            this.jwt = data.jwt;
         }
-    }
-    /**
-     * 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);
+        if (data.volatile) {
+            this.volatile = data.volatile;
         }
-    }
-    /**
-     * 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).
-     */
-    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);
+        if (data.body) {
+            this.body = data.body;
+        }
+        this.controller = assertType_1.default.assertString('controller', data.controller);
+        this.action = assertType_1.default.assertString('controller', data.action);
     }
 }
 exports.RequestInput = RequestInput;

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

@@ -1,17 +1,19 @@
 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;
-    private proxy;
+    proxy: any;
     constructor();
     /**
      * Gets a header value
      *
      * @param name Header name. Could be a string (case-insensitive) or a symbol
      */
-    getHeader(name: any): string | void;
+    getHeader(name: any): string;
     removeHeader(name: string): boolean;
     setHeader(name: string, value: string): boolean;
 }
@@ -19,20 +21,22 @@ 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: any);
+    constructor(request: KuzzleRequest);
     /**
      * Get the parent request deprecations
      */
-    get deprecations(): Array<Deprecation> | void;
+    get deprecations(): Array<Deprecation>;
     /**
      * Set the parent request deprecations
      * @param {Object[]} deprecations
      */
-    set deprecations(deprecations: Array<Deprecation> | void);
+    set deprecations(deprecations: Array<Deprecation>);
     /**
      * Get the parent request status
      * @returns {number}
@@ -99,16 +103,16 @@ export declare class RequestResponse {
     /**
      * Gets a header value (case-insensitive)
      */
-    getHeader(name: string): string | null;
+    getHeader(name: string): string;
     /**
      * Deletes a header (case-insensitive)
      */
-    removeHeader(name: string): any;
+    removeHeader(name: string): boolean;
     /**
      * 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): any;
+    setHeader(name: string, value: string): boolean;
     /**
      * Adds new multiple headers.
      */

package/lib/api/request/requestResponse.js

@@ -40,11 +40,8 @@ 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();
@@ -54,7 +51,10 @@ class Headers {
             get: (target, name) => this.getHeader(name),
             set: (target, name, value) => this.setHeader(name, value),
         });
-        this.setHeader('X-Kuzzle-Node', global.kuzzle.id);
+        // eslint-disable-next-line dot-notation
+        if (global['_kuzzle'] && global.kuzzle) {
+            this.setHeader('X-Kuzzle-Node', global.kuzzle.id);
+        }
     }
     /**
      * Gets a header value
@@ -144,98 +144,104 @@ exports.Headers = Headers;
 class RequestResponse {
     constructor(request) {
         this.raw = false;
-        this[_request] = request;
-        this[_headers] = new Headers();
-        Object.seal(this);
+        // Make a private property otherwise the tests are ending in recursive loop
+        Reflect.defineProperty(this, 'request', {
+            value: request,
+        });
+        this._headers = new Headers();
     }
     /**
      * 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() {
-        return global.kuzzle.id;
+        // eslint-disable-next-line dot-notation
+        if (global['_kuzzle'] && global.kuzzle) {
+            return global.kuzzle.id;
+        }
+        return null;
     }
     /**
      * Configure the response
@@ -265,20 +271,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.
@@ -301,7 +307,7 @@ class RequestResponse {
         if (this.raw === true) {
             return {
                 content: this.result,
-                headers: this.headers,
+                headers: this._headers.headers,
                 raw: true,
                 requestId: this.requestId,
                 status: this.status,
@@ -321,7 +327,7 @@ class RequestResponse {
                 status: this.status,
                 volatile: this.volatile,
             },
-            headers: this.headers,
+            headers: this._headers.headers,
             raw: false,
             requestId: this.requestId,
             status: this.status,

package/lib/config/default.config.js

@@ -46,7 +46,7 @@ module.exports = {
        (see https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS)
    */
   http: {
-    routes: require('./httpRoutes'),
+    routes: require('./../api/httpRoutes'),
     accessControlAllowOrigin: '*',
     accessControlAllowOriginUseRegExp: false,
     accessControlAllowMethods: 'GET,POST,PUT,PATCH,DELETE,OPTIONS,HEAD',

package/lib/core/network/router.js

@@ -138,6 +138,39 @@ class Router {
         this._executeFromHttp(route.verb, request, cb);
       });
     }
+
+    /**
+     * Returns inner metrics from the router
+     * @returns {Object}
+     */
+    global.kuzzle.onAsk(
+      'core:network:router:metrics',
+      () => this.metrics());
+  }
+
+  /**
+   * Returns the metrics of the router
+   * @returns {Object}
+   */
+  metrics () {
+    const connectionsByProtocol = {};
+
+    for (const connection of this.connections.values()) {
+      const protocol = connection.connection.protocol.toLowerCase();
+      if (protocol === 'internal') {
+        continue;
+      }
+
+      if (connectionsByProtocol[protocol] === undefined) {
+        connectionsByProtocol[protocol] = 0;
+      }
+
+      connectionsByProtocol[protocol]++;
+    }
+
+    return {
+      connections: connectionsByProtocol,
+    };
   }
 
   /**

package/lib/core/plugin/pluginsManager.js

@@ -265,7 +265,9 @@ class PluginsManager {
 
           debug('[%s] plugin started', plugin.name);
 
-          this.loadedPlugins.push(plugin.name);
+          if (! plugin.application) {
+            this.loadedPlugins.push(plugin.name);
+          }
 
           return null;
         });

package/lib/core/realtime/hotelClerk.d.ts

@@ -118,6 +118,13 @@ export declare class HotelClerk {
      *
      */
     unsubscribe(connectionId: string, roomId: string, notify?: boolean): Promise<void>;
+    /**
+     * Returns inner metrics from the HotelClerk
+     */
+    metrics(): {
+        rooms: number;
+        subscriptions: number;
+    };
     /**
      * Deletes a room if no user has subscribed to it, and removes it also from the
      * real-time engine

package/lib/core/realtime/hotelClerk.js

@@ -136,6 +136,11 @@ class HotelClerk {
         global.kuzzle.onAsk('core:realtime:unsubscribe', (connectionId, roomId, notify) => {
             return this.unsubscribe(connectionId, roomId, notify);
         });
+        /**
+         * Returns inner metrics from the HotelClerk
+         * @return {{rooms: number, subscriptions: number}}
+         */
+        global.kuzzle.onAsk('core:realtime:hotelClerk:metrics', () => this.metrics());
         /**
          * Clear the hotel clerk and properly disconnect connections.
          */
@@ -410,6 +415,15 @@ class HotelClerk {
             subscription,
         });
     }
+    /**
+     * Returns inner metrics from the HotelClerk
+     */
+    metrics() {
+        return {
+            rooms: this.roomsCount,
+            subscriptions: this.subscriptions.size,
+        };
+    }
     /**
      * Deletes a room if no user has subscribed to it, and removes it also from the
      * real-time engine