kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/network/context.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,38 +19,54 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { BadRequestError, ExternalServiceError, ForbiddenError, GatewayTimeoutError, InternalError: KuzzleInternalError, KuzzleError, NotFoundError, PartialError, PluginImplementationError, PreconditionError, ServiceUnavailableError, SizeLimitError, TooManyRequestsError, UnauthorizedError, Request, RequestContext, RequestInput, } = require("../../kerror/errors");
-const ClientConnection = require("./clientConnection");
-const ProtocolBase = require("./protocols/protocol");
-const debug = require("../../util/debug")("kuzzle:network:protocols");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const errors_1 = require("../../kerror/errors");
+const request_1 = require("../../api/request");
+const debug_1 = __importDefault(require("../../util/debug"));
+const clientConnection_1 = __importDefault(require("./clientConnection"));
+const protocol_1 = __importDefault(require("./protocols/protocol"));
+const debug = (0, debug_1.default)("kuzzle:network:protocols");
+const logLevels = [
+    "silly",
+    "debug",
+    "verbose",
+    "info",
+    "warn",
+    "error",
+];
+/**
+ * The object a protocol plugin is initialized with: the constructors and the
+ * loggers it is allowed to reach, rather than the Kuzzle instance itself.
+ */
 class Context {
     constructor() {
-        this.ClientConnection = ClientConnection;
+        this.ClientConnection = clientConnection_1.default;
         this.debug = debug;
         this.errors = {
-            BadRequestError,
-            ExternalServiceError,
-            ForbiddenError,
-            GatewayTimeoutError,
-            InternalError: KuzzleInternalError,
-            KuzzleError,
-            NotFoundError,
-            PartialError,
-            PluginImplementationError,
-            PreconditionError,
-            ServiceUnavailableError,
-            SizeLimitError,
-            TooManyRequestsError,
-            UnauthorizedError,
+            BadRequestError: errors_1.BadRequestError,
+            ExternalServiceError: errors_1.ExternalServiceError,
+            ForbiddenError: errors_1.ForbiddenError,
+            GatewayTimeoutError: errors_1.GatewayTimeoutError,
+            InternalError: errors_1.InternalError,
+            KuzzleError: errors_1.KuzzleError,
+            NotFoundError: errors_1.NotFoundError,
+            PartialError: errors_1.PartialError,
+            PluginImplementationError: errors_1.PluginImplementationError,
+            PreconditionError: errors_1.PreconditionError,
+            ServiceUnavailableError: errors_1.ServiceUnavailableError,
+            SizeLimitError: errors_1.SizeLimitError,
+            TooManyRequestsError: errors_1.TooManyRequestsError,
+            UnauthorizedError: errors_1.UnauthorizedError,
         };
-        this.Protocol = ProtocolBase;
-        this.Request = Request;
-        this.RequestContext = RequestContext;
-        this.RequestInput = RequestInput;
+        this.Protocol = protocol_1.default;
+        this.Request = request_1.Request;
+        this.RequestContext = request_1.RequestContext;
+        this.RequestInput = request_1.RequestInput;
         this.log = {};
-        for (const type of ["silly", "debug", "verbose", "info", "warn", "error"]) {
-            this.log[type] = (...args) => global.kuzzle.log[type](...args);
+        for (const type of logLevels) {
+            this.log[type] = (message, ...args) => global.kuzzle.log[type](message, ...args);
         }
     }
 }

package/dist/lib/core/network/entryPoint.d.ts

@@ -1,26 +1,39 @@
-export = EntryPoint;
-declare class EntryPoint {
-    config: import("../../..").ServerConfiguration;
-    protocols: Map<any, any>;
-    _clients: Map<any, any>;
+import type { JSONObject } from "../../types/JSONObject";
+import type { KuzzleRequest } from "../../api/request";
+import { AccessLogger, type AccessLogExtra } from "./accessLogger";
+import type Protocol from "./protocols/protocol";
+import type ClientConnection from "./clientConnection";
+import type { NetworkEntryPoint } from "./networkEntryPoint";
+import type { ServerConfiguration } from "../../types";
+/**
+ * `implements NetworkEntryPoint`: that interface was declared as a stop-gap
+ * while this file was JavaScript — protocols need the contract and importing
+ * the concrete class would close a cycle. It stays, but it is now *checked*
+ * against the implementation rather than asserted about it.
+ */
+declare class EntryPoint implements NetworkEntryPoint {
+    config: ServerConfiguration;
+    protocols: Map<string, Protocol<unknown>>;
+    private readonly _clients;
     accessLogger: AccessLogger;
     isShuttingDown: boolean;
-    logger: import("../../kuzzle/Logger").Logger;
-    dispatch(event: any, data: any): void;
+    logger: ReturnType<typeof global.kuzzle.log.child>;
+    constructor();
+    dispatch(event: string, data: JSONObject): void;
     /**
      * Initializes the InternalProtocol first to allow subscriptions
      * in plugins init() method.
      *
      * @returns {Promise}
      */
-    init(): Promise<any>;
+    init(): Promise<boolean>;
     /**
      * Starts the network protocols.
      * Every protocol is listening for request after this call
      *
      * @returns {Promise}
      */
-    startListening(): Promise<any>;
+    startListening(): Promise<void>;
     /**
      * On client subscribing to a channel, dispatch the information
      * to the protocol.
@@ -29,7 +42,7 @@ declare class EntryPoint {
      * @param {string} connectionId
      */
     joinChannel(channel: string, connectionId: string): void;
-    leaveChannel(channel: any, connectionId: any): void;
+    leaveChannel(channel: string, connectionId: string): void;
     /**
      * Loads installed protocols in memory
      */
@@ -39,13 +52,13 @@ declare class EntryPoint {
      * @param {Request} request
      * @param {object} extra
      */
-    logAccess(connection: ClientConnection, request: Request, extra?: object): void;
+    logAccess(connection: ClientConnection, request: KuzzleRequest, extra?: AccessLogExtra | null): void;
     /**
      * @param {ClientConnection} connection
      * @param {Request} request
      * @param cb
      */
-    execute(connection: ClientConnection, request: Request, cb: any): void;
+    execute(connection: ClientConnection, request: KuzzleRequest, cb: (response: JSONObject) => void): void;
     /**
      *
      * @param {ClientConnection} connection
@@ -55,8 +68,17 @@ declare class EntryPoint {
      * @param {string} connectionId
      */
     removeConnection(connectionId: string): void;
-    _broadcast(data: any): void;
-    _isShuttingDownError(connection: any, request: any, cb: any): void;
-    _notify(data: any): void;
+    _broadcast(data: JSONObject): void;
+    /**
+     * The protocol a client is connected through.
+     *
+     * The three callers each guard `client?.protocol` and then read the map
+     * with it, unchecked: a connection naming a protocol this entry point does
+     * not have is what the `try` around each of them was already for, so the
+     * throw lands where the log already is.
+     */
+    private protocolOf;
+    _isShuttingDownError(connection: ClientConnection, request: KuzzleRequest, cb: (response: JSONObject) => void): void;
+    _notify(data: JSONObject): void;
 }
-import { AccessLogger } from "./accessLogger";
+export = EntryPoint;

package/dist/lib/core/network/entryPoint.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,28 +19,69 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const Bluebird = require("bluebird");
-const { RequestContext } = require("../../api/request");
-const Context = require("./context");
-const debug = require("../../util/debug")("kuzzle:network:embedded");
-const MqttProtocol = require("./protocols/mqttProtocol");
-const InternalProtocol = require("./protocols/internalProtocol");
-const HttpWsProtocol = require("./protocols/httpwsProtocol");
-const Manifest = require("./protocolManifest");
-const { removeStacktrace } = require("../../util/stackTrace");
-const kerror = require("../../kerror");
-const { AccessLogger } = require("./accessLogger");
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 };
+};
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const bluebird_1 = __importDefault(require("bluebird"));
+const request_1 = require("../../api/request");
+const kerror = __importStar(require("../../kerror"));
+const debug_1 = __importDefault(require("../../util/debug"));
+const stackTrace_1 = require("../../util/stackTrace");
+const accessLogger_1 = require("./accessLogger");
+const context_1 = __importDefault(require("./context"));
+const protocolManifest_1 = __importDefault(require("./protocolManifest"));
+const httpwsProtocol_1 = __importDefault(require("./protocols/httpwsProtocol"));
+const internalProtocol_1 = __importDefault(require("./protocols/internalProtocol"));
+const mqttProtocol_1 = __importDefault(require("./protocols/mqttProtocol"));
+/**
+ * The message of whatever was thrown. Each of the five handlers below logs a
+ * protocol's failure and carries on; `catch` answers `unknown`.
+ */
+function messageOf(thrown) {
+    return thrown instanceof Error ? thrown.message : (0, node_util_1.inspect)(thrown);
+}
+const debug = (0, debug_1.default)("kuzzle:network:embedded");
 const networkError = kerror.wrap("network", "entrypoint");
-const DEFAULT_PROTOCOLS = [HttpWsProtocol, MqttProtocol, InternalProtocol];
+const DEFAULT_PROTOCOLS = [httpwsProtocol_1.default, mqttProtocol_1.default, internalProtocol_1.default];
+/**
+ * `implements NetworkEntryPoint`: that interface was declared as a stop-gap
+ * while this file was JavaScript — protocols need the contract and importing
+ * the concrete class would close a cycle. It stays, but it is now *checked*
+ * against the implementation rather than asserted about it.
+ */
 class EntryPoint {
     constructor() {
         this.config = global.kuzzle.config.server;
         this.protocols = new Map();
         this._clients = new Map();
-        this.accessLogger = new AccessLogger();
+        this.accessLogger = new accessLogger_1.AccessLogger();
         this.isShuttingDown = false;
         this.logger = global.kuzzle.log.child("core:network:entrypoint");
     }
@@ -65,11 +107,19 @@ class EntryPoint {
      * @returns {Promise}
      */
     async init() {
+        let internal;
         for (const ProtocolClass of DEFAULT_PROTOCOLS) {
             const protocol = new ProtocolClass();
             this.protocols.set(protocol.name, protocol);
+            if (protocol instanceof internalProtocol_1.default) {
+                internal = protocol;
+            }
         }
-        return this.protocols.get("internal").init(this);
+        // The internal protocol is one of `DEFAULT_PROTOCOLS`, so it was fetched
+        // back out of the map it had just been put into, by the name it gives
+        // itself.
+        (0, node_assert_1.default)(internal !== undefined, "[network] the internal protocol is missing from the default protocols");
+        return internal.init(this);
     }
     /**
      * Starts the network protocols.
@@ -96,7 +146,7 @@ class EntryPoint {
                 }
             }));
         }
-        await Bluebird.all(initPromises);
+        await bluebird_1.default.all(initPromises);
         await this.loadMoreProtocols();
     }
     /**
@@ -109,62 +159,66 @@ class EntryPoint {
     joinChannel(channel, connectionId) {
         debug('[server] client "%s" joining channel "%s"', connectionId, channel);
         const client = this._clients.get(connectionId);
-        if (!client || !client.protocol) {
+        if (!client?.protocol) {
             return;
         }
         try {
-            this.protocols.get(client.protocol).joinChannel(channel, connectionId);
+            this.protocolOf(client).joinChannel(channel, connectionId);
         }
         catch (e) {
-            this.logger.error(`[join] protocol ${client && client.protocol} failed: ${e.message}`);
+            this.logger.error(`[join] protocol ${client.protocol} failed: ${messageOf(e)}`);
         }
     }
     leaveChannel(channel, connectionId) {
         debug('[server] connection "%s" leaving channel "%s"', connectionId, channel);
         const client = this._clients.get(connectionId);
-        if (!client || !client.protocol) {
+        if (!client?.protocol) {
             return;
         }
         try {
-            this.protocols.get(client.protocol).leaveChannel(channel, connectionId);
+            this.protocolOf(client).leaveChannel(channel, connectionId);
         }
         catch (e) {
-            this.logger.error(`[leave channel] protocol ${client && client.protocol} failed: ${e.message}`);
+            this.logger.error(`[leave channel] protocol ${client.protocol} failed: ${messageOf(e)}`);
         }
     }
     /**
      * Loads installed protocols in memory
      */
     async loadMoreProtocols() {
-        const dir = path.join(__dirname, "../../../protocols/enabled");
+        const dir = node_path_1.default.join(__dirname, "../../../protocols/enabled");
         let dirs;
         try {
-            dirs = fs.readdirSync(dir);
+            dirs = node_fs_1.default.readdirSync(dir);
         }
-        catch (e) {
+        catch {
             // ignore if there is no protocols directory
             return;
         }
         dirs = dirs
-            .map((d) => path.join(dir, d))
-            .filter((d) => fs.statSync(d).isDirectory());
-        await Bluebird.map(dirs, (protoDir) => {
+            .map((d) => node_path_1.default.join(dir, d))
+            .filter((d) => node_fs_1.default.statSync(d).isDirectory());
+        await bluebird_1.default.map(dirs, (protoDir) => {
+            // A protocol is loaded from disk at runtime: the path is only known then.
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
             const protocol = new (require(protoDir))();
-            const manifest = new Manifest(protoDir, protocol);
-            manifest.load();
+            const manifest = new protocolManifest_1.default(protoDir, protocol);
+            // `load()` answers the name it validated: the field stays nullable
+            // because it is null until this call.
+            const { name } = manifest.load();
             const initTimeout = global.kuzzle.config.services.common.defaultInitTimeout;
-            return Bluebird.resolve()
-                .then(() => protocol.init(this, new Context()))
+            return bluebird_1.default.resolve()
+                .then(() => protocol.init(this, new context_1.default()))
                 .catch((error) => {
-                this.logger.error(`Error during "${manifest.name}" protocol init:`);
+                this.logger.error(`Error during "${name}" protocol init:`);
                 throw error;
             })
-                .timeout(initTimeout, `Protocol "${manifest.name}" initialization timed out after ${initTimeout}ms. Try to increase the configuration "services.common.defaultInitTimeout".`)
+                .timeout(initTimeout, `Protocol "${name}" initialization timed out after ${initTimeout}ms. Try to increase the configuration "services.common.defaultInitTimeout".`)
                 .then(() => {
-                if (this.protocols.has(manifest.name)) {
-                    throw kerror.get("protocol", "runtime", "already_exists", manifest.name);
+                if (this.protocols.has(name)) {
+                    throw kerror.get("protocol", "runtime", "already_exists", name);
                 }
-                this.protocols.set(manifest.name, protocol);
+                this.protocols.set(name, protocol);
             });
         });
     }
@@ -200,7 +254,7 @@ class EntryPoint {
             }
             this.logAccess(connection, _res);
             const response = _res.response.toJSON();
-            cb(removeStacktrace(response));
+            cb((0, stackTrace_1.removeStacktrace)(response));
         });
     }
     /**
@@ -210,7 +264,7 @@ class EntryPoint {
     newConnection(connection) {
         this._clients.set(connection.id, connection);
         global.kuzzle.emit("connection:new", connection);
-        global.kuzzle.router.newConnection(new RequestContext({ connection }));
+        global.kuzzle.router.newConnection(new request_1.RequestContext({ connection }));
         debug("New connection created: %s (protocol: %s)", connection.id, connection.protocol);
     }
     /**
@@ -220,40 +274,57 @@ class EntryPoint {
         const connection = this._clients.get(connectionId);
         if (connection) {
             global.kuzzle.emit("connection:remove", connection);
-            global.kuzzle.router.removeConnection(new RequestContext({ connection }));
+            global.kuzzle.router.removeConnection(new request_1.RequestContext({ connection }));
             this._clients.delete(connectionId);
             debug("Removed connection: %s (protocol: %s)", connection.id, connection.protocol);
         }
     }
     // --------------------------------------------------------------------
     _broadcast(data) {
-        const sanitized = removeStacktrace(data);
+        const sanitized = (0, stackTrace_1.removeStacktrace)(data);
         debug("[server] broadcasting data through all protocols: %a", sanitized);
         for (const [name, protocol] of this.protocols.entries()) {
             try {
                 protocol.broadcast(sanitized);
             }
             catch (e) {
-                this.logger.error(`[broadcast] protocol ${name} failed: ${e.message}\n${e.stack}`);
+                this.logger.error(`[broadcast] protocol ${name} failed: ${messageOf(e)}\n${e instanceof Error ? e.stack : ""}`);
             }
         }
     }
+    /**
+     * The protocol a client is connected through.
+     *
+     * The three callers each guard `client?.protocol` and then read the map
+     * with it, unchecked: a connection naming a protocol this entry point does
+     * not have is what the `try` around each of them was already for, so the
+     * throw lands where the log already is.
+     */
+    protocolOf(client) {
+        const protocol = client.protocol === null
+            ? undefined
+            : this.protocols.get(client.protocol);
+        if (protocol === undefined) {
+            throw kerror.get("protocol", "runtime", "invalid_connection", client.protocol);
+        }
+        return protocol;
+    }
     _isShuttingDownError(connection, request, cb) {
         request.setError(networkError.get("shutting_down"));
         this.logAccess(connection, request);
-        cb(removeStacktrace(request.response.toJSON()));
+        cb((0, stackTrace_1.removeStacktrace)(request.response.toJSON()));
     }
     _notify(data) {
         debug('[server] sending notification to client with connection id "%s": %a', data.connectionId, data);
         const client = this._clients.get(data.connectionId);
-        if (!client || !client.protocol) {
+        if (!client?.protocol) {
             return;
         }
         try {
-            this.protocols.get(client.protocol).notify(removeStacktrace(data));
+            this.protocolOf(client).notify((0, stackTrace_1.removeStacktrace)(data));
         }
         catch (e) {
-            this.logger.error(`[notify] protocol ${client.protocol} failed: ${e.message}`);
+            this.logger.error(`[notify] protocol ${client.protocol} failed: ${messageOf(e)}`);
         }
     }
 }

package/dist/lib/core/network/httpRouter/index.d.ts

@@ -1,85 +1,55 @@
-export = Router;
+import type HttpMessage from "../protocols/httpMessage";
+import RoutePart from "./routePart";
+import type { RouteCallback, RouteHandlerFunction } from "./routeTypes";
 /**
- * Attach handler to routes and dispatch a HTTP
- * message to the right handler
+ * Attach handler to routes and dispatch a HTTP message to the right handler
  *
  * Handlers will be called with the following arguments:
  *   - request: received HTTP request
  *   - response: HTTP response object
  *   - data: URL query arguments and/or POST data, if any
- *
- * @class Router
  */
 declare class Router {
-    defaultHeaders: {
-        "Accept-Encoding": string;
-        "Access-Control-Allow-Headers": string;
-        "Access-Control-Allow-Methods": string;
-        "content-type": string;
-    };
-    routes: {
-        DELETE: RoutePart;
-        GET: RoutePart;
-        HEAD: RoutePart;
-        PATCH: RoutePart;
-        POST: RoutePart;
-        PUT: RoutePart;
-    };
+    defaultHeaders: Record<string, string>;
+    routes: Record<HttpVerb, RoutePart>;
+    constructor();
     /**
      * Attach a handler to a GET HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
-    get(path: string, handler: Function): void;
+    get(path: string, handler: RouteHandlerFunction): void;
     /**
      * Attach a handler to a POST HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
-    post(path: string, handler: Function): void;
+    post(path: string, handler: RouteHandlerFunction): void;
     /**
      * Attach a handler to a PUT HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
-    put(path: string, handler: Function): void;
+    put(path: string, handler: RouteHandlerFunction): void;
     /**
      * Attach a handler to a PATCH HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
-    patch(path: string, handler: Function): void;
+    patch(path: string, handler: RouteHandlerFunction): void;
     /**
      * Attach a handler to a DELETE HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
-    delete(path: string, handler: Function): void;
+    delete(path: string, handler: RouteHandlerFunction): void;
     /**
      * Attach a handler to a HEAD HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
-    head(path: string, handler: Function): void;
+    head(path: string, handler: RouteHandlerFunction): void;
     /**
      * Route an incoming HTTP message to the right handler
      *
-     * @param {HttpMessage} message - Parsed HTTP message
-     * @param {function} cb
+     * @param message - Parsed HTTP message
      */
-    route(message: HttpMessage, cb: Function): void;
+    route(message: HttpMessage, cb: RouteCallback): void;
     /**
      * Route HTTP messages using an HTTP method that is not handled by Kuzzle's
      * API, such as OPTIONS.
-     * @param  {HttpMessage} message
-     * @param {function} cb
      */
-    routeUnhandledHttpMethod(message: HttpMessage, cb: Function): void;
+    routeUnhandledHttpMethod(message: HttpMessage, cb: RouteCallback): void;
 }
-import RoutePart = require("./routePart");
+/** The HTTP verbs this router attaches handlers for. */
+declare const HTTP_VERBS: readonly ["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"];
+type HttpVerb = (typeof HTTP_VERBS)[number];
+export = Router;