kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/network/protocols/internalProtocol.d.ts

@@ -1,4 +1,11 @@
-export = InternalProtocol;
+import type { JSONObject } from "../../../types/JSONObject";
+import ClientConnection from "../clientConnection";
+import type { NetworkEntryPoint } from "../networkEntryPoint";
+import Protocol from "./protocol";
+interface InternalMessage {
+    channels: string[];
+    payload: JSONObject;
+}
 /**
  * Internal protocol to use SDK realtime subscription from plugins.
  *
@@ -8,20 +15,24 @@ export = InternalProtocol;
  *  - 'core:network:internal:message'
  */
 declare class InternalProtocol extends Protocol {
-    constructor();
     connection: ClientConnection;
-    /**
-     * List of channel IDs
-     * @type {Set<string>}
-     */
+    /** List of channel IDs */
     channels: Set<string>;
-    init(entryPoint: any): Promise<void>;
-    joinChannel(channel: any, connectionId: any): void;
-    leaveChannel(channel: any, connectionId: any): void;
-    disconnect(connectionId: any): void;
-    broadcast(data: any): void;
-    notify(data: any): void;
-    _send(data: any): void;
+    constructor();
+    init(entryPoint: NetworkEntryPoint): Promise<boolean>;
+    /** @deprecated pass the name to the constructor and call `init(entryPoint)` */
+    init(name: null, entryPoint: NetworkEntryPoint): Promise<boolean>;
+    joinChannel(channel: string, connectionId: string): {
+        channel: string;
+        connectionId: string;
+    };
+    leaveChannel(channel: string, connectionId: string): {
+        channel: string;
+        connectionId: string;
+    };
+    disconnect(connectionId: string): void;
+    broadcast(data: InternalMessage): void;
+    notify(data: InternalMessage): void;
+    _send(data: InternalMessage): void;
 }
-import Protocol = require("./protocol");
-import ClientConnection = require("../clientConnection");
+export = InternalProtocol;

package/dist/lib/core/network/protocols/internalProtocol.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,10 +19,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const Protocol = require("./protocol");
-const ClientConnection = require("../clientConnection");
-const debug = require("../../../util/debug")("kuzzle:network:protocols:internal");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const debug_1 = __importDefault(require("../../../util/debug"));
+const clientConnection_1 = __importDefault(require("../clientConnection"));
+const protocol_1 = __importDefault(require("./protocol"));
+const debug = (0, debug_1.default)("kuzzle:network:protocols:internal");
 /**
  * Internal protocol to use SDK realtime subscription from plugins.
  *
@@ -30,34 +34,31 @@ const debug = require("../../../util/debug")("kuzzle:network:protocols:internal"
  * Messages to the embedded SDK are dispatched with the following event:
  *  - 'core:network:internal:message'
  */
-class InternalProtocol extends Protocol {
+class InternalProtocol extends protocol_1.default {
     constructor() {
         super("internal");
-        this.connection = new ClientConnection(this.name, ["127.0.0.1"]);
-        /**
-         * List of channel IDs
-         * @type {Set<string>}
-         */
+        this.connection = new clientConnection_1.default(this.name, ["127.0.0.1"]);
         this.channels = new Set();
     }
-    async init(entryPoint) {
-        await super.init(null, entryPoint);
+    async init(...args) {
+        await super.init(protocol_1.default.entryPointOf(args));
         debug("initializing InternalProtocol");
         this.entryPoint.newConnection(this.connection);
         /**
          * Returns the internal connection ID used by the protocol.
-         *
-         * @returns {string} connectionId
          */
         global.kuzzle.onAsk("core:network:internal:connectionId:get", () => this.connection.id);
+        return true;
     }
     joinChannel(channel, connectionId) {
         debug("joinChannel: %s", channel, connectionId);
         this.channels.add(channel);
+        return { channel, connectionId };
     }
     leaveChannel(channel, connectionId) {
         debug("leaveChannel: %s", channel, connectionId);
         this.channels.delete(channel);
+        return { channel, connectionId };
     }
     disconnect(connectionId) {
         debug("disconnect: %s", connectionId);
@@ -72,8 +73,8 @@ class InternalProtocol extends Protocol {
         this._send(data);
     }
     _send(data) {
-        for (let i = 0; i < data.channels.length; i++) {
-            const message = { ...data.payload, room: data.channels[i] };
+        for (const channel of data.channels) {
+            const message = { ...data.payload, room: channel };
             global.kuzzle.emit("core:network:internal:message", message);
         }
     }

package/dist/lib/core/network/protocols/mqttProtocol.d.ts

@@ -1,39 +1,63 @@
 /// <reference types="node" />
-export = MqttProtocol;
-/**
- * @class MqttProtocol
- */
-declare class MqttProtocol extends Protocol {
-    constructor();
-    aedes: any;
+import * as net from "node:net";
+import type { AedesPublishPacket, Client, PublishPacket, Subscription } from "aedes";
+import Aedes from "aedes";
+import type { JSONObject } from "../../../types/JSONObject";
+import ClientConnection from "../clientConnection";
+import type { NetworkEntryPoint } from "../networkEntryPoint";
+import Protocol from "./protocol";
+/** `server.protocols.mqtt` in the Kuzzle configuration */
+interface MqttConfig {
+    enabled?: boolean;
+    allowPubSub: boolean;
+    developmentMode: boolean;
+    disconnectDelay: number;
+    requestTopic: string;
+    responseTopic: string;
+    server: {
+        port: number;
+    };
+}
+interface MqttNotification {
+    channels: string[];
+    connectionId?: string;
+    payload: JSONObject;
+}
+declare class MqttProtocol extends Protocol<MqttConfig> {
+    aedes: Aedes;
     server: net.Server;
-    connections: Map<any, any>;
-    connectionsById: Map<any, any>;
-    logger: import("../../../kuzzle/Logger").Logger;
-    publishCallback: (error: any) => void;
-    init(entryPoint: any): Promise<boolean>;
-    broadcast(data: any): void;
-    disconnect(connectionId: any, message?: string): void;
-    joinChannel(): void;
-    leaveChannel(): void;
-    notify(data: any): void;
+    connections: Map<Client, ClientConnection>;
+    connectionsById: Map<string, Client>;
+    publishCallback: (error?: Error) => void;
+    private readonly logger;
+    constructor();
+    init(entryPoint: NetworkEntryPoint): Promise<boolean>;
+    /** @deprecated pass the name to the constructor and call `init(entryPoint)` */
+    init(name: null, entryPoint: NetworkEntryPoint): Promise<boolean>;
+    broadcast(data: MqttNotification): void;
     /**
-     * @param {Client} client
+     * @param message - **unused.** aedes' `close()` takes a callback and nothing
+     *   else, so this never reached the client; #2723 removed the call that
+     *   pretended to pass it. Kept in the signature because `disconnect` is
+     *   reached by name from the entry point and by protocol plugins.
+     *   ADR-0001, TD-41 (#2728).
      */
+    disconnect(connectionId: string, message?: string): void;
+    joinChannel(channel: string, connectionId: string): {
+        channel: string;
+        connectionId: string;
+    };
+    leaveChannel(channel: string, connectionId: string): {
+        channel: string;
+        connectionId: string;
+    };
+    notify(data: MqttNotification): void;
     onConnection(client: Client): void;
-    /**
-     * @param {Client} client
-     */
     onDisconnection(client: Client): void;
-    /**
-     * @param packet
-     * @param client
-     */
-    onMessage(packet: any, client: any): void;
-    _respond(client: any, response: any): void;
-    _respondError(client: any, error: any): void;
-    _authorizePublish(client: any, packet: any, callback: any): void;
-    _authorizeSubscribe(client: any, sub: any, callback: any): void;
+    onMessage(packet: AedesPublishPacket, client: Client | null): void;
+    _respond(client: Client, response: JSONObject): void;
+    _respondError(client: Client, error: Error): void;
+    _authorizePublish(client: Client | null, packet: PublishPacket, callback: (error?: Error | null) => void): void;
+    _authorizeSubscribe(client: Client, sub: Subscription, callback: (error: Error | null, subscription?: Subscription | null) => void): void;
 }
-import Protocol = require("./protocol");
-import net = require("net");
+export = MqttProtocol;

package/dist/lib/core/network/protocols/mqttProtocol.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,41 +19,70 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const net = require("net");
-const Aedes = require("aedes");
-const ClientConnection = require("../clientConnection");
-const Protocol = require("./protocol");
-const { Request } = require("../../../api/request");
-const { removeStacktrace } = require("../../../util/stackTrace");
-const kerror = require("../../../kerror").wrap("network", "mqtt");
-const debug = require("../../../util/debug")("kuzzle:network:protocols:mqtt");
-/**
- * @class MqttProtocol
- */
-class MqttProtocol extends Protocol {
+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 net = __importStar(require("node:net"));
+const node_util_1 = require("node:util");
+const aedes_1 = __importDefault(require("aedes"));
+const request_1 = require("../../../api/request");
+const kerror_1 = require("../../../kerror");
+const debug_1 = __importDefault(require("../../../util/debug"));
+const stackTrace_1 = require("../../../util/stackTrace");
+const clientConnection_1 = __importDefault(require("../clientConnection"));
+const protocol_1 = __importDefault(require("./protocol"));
+const kerror = (0, kerror_1.wrap)("network", "mqtt");
+const debug = (0, debug_1.default)("kuzzle:network:protocols:mqtt");
+class MqttProtocol extends protocol_1.default {
     constructor() {
         super("mqtt");
+        this.logger = global.kuzzle.log.child("core:network:protocols:mqtt");
         // eslint-disable-next-line new-cap
-        this.aedes = new Aedes();
+        this.aedes = new aedes_1.default();
         this.server = net.createServer(this.aedes.handle);
         this.connections = new Map();
         this.connectionsById = new Map();
-        this.logger = global.kuzzle.log.child("core:network:protocols:mqtt");
         // needs to be bound to this object's context
-        this.publishCallback = function pubcb(error) {
+        this.publishCallback = (error) => {
             if (error) {
                 this.logger.info(`[MQTT] Publishing message failed: ${error}`);
             }
         };
     }
-    async init(entryPoint) {
-        await super.init(null, entryPoint);
+    async init(...args) {
+        await super.init(protocol_1.default.entryPointOf(args));
         if (this.config.enabled === false) {
             return false;
         }
         debug("initializing MQTT Server with config: %a", this.config);
-        this.config = Object.assign({
+        // The defaults in their own object: written as literal keys before the
+        // spread, every one of them is a property the compiler can see being
+        // overwritten on the next line (TS2783), which is exactly the intent but
+        // not something worth restating six times.
+        const defaults = {
             allowPubSub: false,
             developmentMode: false,
             disconnectDelay: 250,
@@ -61,7 +91,8 @@ class MqttProtocol extends Protocol {
             server: {
                 port: 1883,
             },
-        }, this.config);
+        };
+        this.config = { ...defaults, ...this.config };
         /*
          * To avoid ill-use of our topics, we need to configure authorizations:
          * "requestTopic": should be publish-only, so no one but this plugin can
@@ -86,43 +117,56 @@ class MqttProtocol extends Protocol {
             this.aedes.publish({ payload, topic: channel }, this.publishCallback);
         }
     }
-    disconnect(connectionId, message = "Connection closed by remote host") {
+    /**
+     * @param message - **unused.** aedes' `close()` takes a callback and nothing
+     *   else, so this never reached the client; #2723 removed the call that
+     *   pretended to pass it. Kept in the signature because `disconnect` is
+     *   reached by name from the entry point and by protocol plugins.
+     *   ADR-0001, TD-41 (#2728).
+     */
+    disconnect(connectionId, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    message = "Connection closed by remote host") {
         debug("disconnect: connection id: %s, message %s", connectionId, message);
         const client = this.connectionsById.get(connectionId);
         if (client) {
-            client.close(undefined, message);
+            // aedes' close() takes a callback and nothing else: `message` has never
+            // reached the client
+            client.close();
         }
     }
-    joinChannel() {
+    joinChannel(channel, connectionId) {
         // do nothing
+        return { channel, connectionId };
     }
-    leaveChannel() {
+    leaveChannel(channel, connectionId) {
         // do nothing
+        return { channel, connectionId };
     }
     notify(data) {
         debug("notify %a", data);
-        const client = this.connectionsById.get(data.connectionId);
+        const client = data.connectionId === undefined
+            ? undefined
+            : this.connectionsById.get(data.connectionId);
         if (!client) {
             return;
         }
         const payload = Buffer.from(JSON.stringify(data.payload));
-        data.channels.forEach((topic) => {
+        for (const topic of data.channels) {
             client.publish({ payload, topic }, this.publishCallback);
-        });
+        }
     }
-    /**
-     * @param {Client} client
-     */
     onConnection(client) {
         debug("onConnection: %s", client.id);
-        const connection = new ClientConnection(this.name, [client.conn.remoteAddress], {});
+        // A socket with no remote address is one that closed between the
+        // connection event and this line; the empty string is what
+        // `ClientConnection` was already given for it.
+        const remoteAddress = client.conn.remoteAddress ?? "";
+        const connection = new clientConnection_1.default(this.name, [remoteAddress], {});
         this.entryPoint.newConnection(connection);
         this.connections.set(client, connection);
         this.connectionsById.set(connection.id, client);
     }
-    /**
-     * @param {Client} client
-     */
     onDisconnection(client) {
         debug("onDisconnection %s", client.id);
         if (this.connections.has(client)) {
@@ -136,12 +180,12 @@ class MqttProtocol extends Protocol {
             }, this.config.disconnectDelay);
         }
     }
-    /**
-     * @param packet
-     * @param client
-     */
     onMessage(packet, client) {
-        if (packet.topic !== this.config.requestTopic ||
+        // `client` is null for a publish aedes made itself — a will message, or
+        // one the broker originated. There is nobody to answer, which is what
+        // the two `_respond` calls below need.
+        if (client === null ||
+            packet.topic !== this.config.requestTopic ||
             packet.payload === null ||
             client.id === null) {
             return;
@@ -155,11 +199,11 @@ class MqttProtocol extends Protocol {
         try {
             const payload = JSON.parse(packet.payload.toString());
             debug("onMessage payload: %o", payload);
-            const request = new Request(payload, { connection });
+            const request = new request_1.Request(payload, { connection });
             this.entryPoint.execute(connection, request, (response) => this._respond(client, response));
         }
         catch (error) {
-            this._respondError(client, error);
+            this._respondError(client, error instanceof Error ? error : new Error((0, node_util_1.inspect)(error)));
         }
     }
     _respond(client, response) {
@@ -178,13 +222,16 @@ class MqttProtocol extends Protocol {
     }
     _respondError(client, error) {
         const connection = this.connections.get(client);
-        const errReq = new Request({}, {
+        const errReq = new request_1.Request({}, {
             connection,
             error: kerror.getFrom(error, "unexpected_error", error.message),
         });
-        this._respond(client, removeStacktrace(errReq.response.toJSON()));
+        this._respond(client, (0, stackTrace_1.removeStacktrace)(errReq.response.toJSON()));
     }
-    _authorizePublish(client, packet, callback) {
+    _authorizePublish(
+    // Aedes' own signature: it authorises broker-originated publishes too,
+    // and this method reads nothing off the client.
+    client, packet, callback) {
         const topic = packet.topic.toString();
         if (this.config.allowPubSub) {
             if (topic === this.config.responseTopic) {

package/dist/lib/core/network/protocols/protocol.d.ts

@@ -1,26 +1,90 @@
-export = Protocol;
-declare class Protocol {
-    constructor(name: any);
-    maxRequestSize: number;
-    entryPoint: any;
-    name: any;
-    config: {};
+import type { NetworkEntryPoint } from "../networkEntryPoint";
+/**
+ * @typeParam TConfig - the shape of `server.protocols.<name>` in the Kuzzle
+ *                      configuration, which is what `init` copies into
+ *                      `this.config`
+ */
+declare class Protocol<TConfig = Record<string, unknown>> {
+    private _maxRequestSize;
+    private _entryPoint;
+    name: string;
+    config: TConfig;
     initCalled: boolean;
     /**
-     * @param {string} name - Protocol name (used for accessor) @deprecated
-     * @param {EmbeddedEntryPoint} entryPoint
+     * The entry point that owns this protocol, and the request size limit it
+     * published. Both are set by `init` and read by everything a protocol does
+     * afterwards — a handler cannot run before the server it is registered on
+     * has been created.
+     *
+     * Declaring them nullable and reading them anyway is what the subclasses
+     * did: 20 unchecked dereferences across the three of them, each one taking
+     * on trust what `init` establishes. These two accessors say it once, where
+     * it can actually fail.
+     */
+    get entryPoint(): NetworkEntryPoint;
+    get maxRequestSize(): number;
+    set maxRequestSize(size: number);
+    /**
+     * Normalises the two `init` call shapes into the entry point they both
+     * carry. Every subclass overriding `init` has to accept both shapes too —
+     * a subclass that only took the live one would not honour the contract its
+     * base class publishes, and `init(null, entryPoint)` on it would throw —
+     * so the normalisation lives here rather than being written out four times.
      *
-     * @returns {Promise<boolean>}
+     * The old shape puts the entry point second. Reading `args[1]`
+     * unconditionally is what the first conversion did: `init(entryPoint)`
+     * type-checked and threw on `entryPoint.config` (TD-41).
      */
-    init(name: string, entryPoint: EmbeddedEntryPoint): Promise<boolean>;
-    broadcast(): void;
-    joinChannel(channel: any, connectionId: any): {
-        channel: any;
-        connectionId: any;
-    };
-    leaveChannel(channel: any, connectionId: any): {
-        channel: any;
-        connectionId: any;
-    };
-    notify(): void;
+    static entryPointOf(args: Protocol.InitArgs): NetworkEntryPoint;
+    constructor(name?: string);
+    /**
+     * Initializes the protocol against the entry point that owns it.
+     *
+     * Two call shapes reach this method, and only one of them is alive:
+     *
+     *  - `init(entryPoint)` — what `entryPoint.js` calls on every protocol, and
+     *    what a subclass should call on `super`;
+     *  - `init(null, entryPoint)` — what the three in-tree subclasses currently
+     *    call, and what a third-party protocol written against an older version
+     *    still calls. Kept working, hence the implementation signature below.
+     *
+     * A *string* first argument is **not** a third shape. The parameter was
+     * deprecated in #1645 (2020-06-16) by an assert that reads
+     * `assert(this.name && !name)`, so passing a name here has thrown ever since
+     * — including when no name was given to the constructor, which is the only
+     * case the deprecation was meant to still allow. The signature says `null`
+     * because `null` is what this method can accept. Widening it to
+     * `string | null`, as the first TypeScript conversion did, advertised a call
+     * that throws. ADR-0001, TD-41 (#2728).
+     *
+     * The assert is left exactly as it is: fixing it would re-open a path that
+     * has been closed for five years, which is a decision about the plugin API,
+     * not about this method's type.
+     */
+    init(entryPoint: NetworkEntryPoint): Promise<boolean>;
+    /** @deprecated pass the name to the constructor and call `init(entryPoint)` */
+    init(name: null, entryPoint: NetworkEntryPoint): Promise<boolean>;
+    broadcast(data?: unknown): void;
+    joinChannel(channel: string, connectionId: string): {
+        channel: string;
+        connectionId: string;
+    } | void;
+    leaveChannel(channel: string, connectionId: string): {
+        channel: string;
+        connectionId: string;
+    } | void;
+    notify(data?: unknown): void;
 }
+declare namespace Protocol {
+    /**
+     * The two shapes `Protocol.init` accepts, as one tuple union — see `init`.
+     * A subclass overriding `init` declares the same two overloads and takes
+     * this as its implementation signature, which is what makes the override
+     * assignable to the base method.
+     *
+     * It lives in a namespace merged with the class because `export =` leaves
+     * no room for a second export.
+     */
+    type InitArgs = [entryPoint: NetworkEntryPoint] | [name: null, entryPoint: NetworkEntryPoint];
+}
+export = Protocol;