kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/plugin/privilegedContext.d.ts

@@ -1,14 +1,9 @@
-export = PrivilegedPluginContext;
+import { PluginContext } from "./pluginContext";
 /**
- * @class PrivilegedPluginContext
- * @extends PluginContext
+ * The context handed to a plugin declared `privileged` in its manifest: the
+ * same surface as a regular plugin's, plus the Kuzzle instance itself.
  */
 declare class PrivilegedPluginContext extends PluginContext {
-    /**
-     * @param {Kuzzle} kuzzle
-     * @param {string} pluginName
-     * @constructor
-     */
     constructor(pluginName: string);
 }
-import { PluginContext } from "./pluginContext";
+export = PrivilegedPluginContext;

package/dist/lib/core/plugin/privilegedContext.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,18 +19,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { PluginContext } = require("./pluginContext");
+const pluginContext_1 = require("./pluginContext");
 /**
- * @class PrivilegedPluginContext
- * @extends PluginContext
+ * The context handed to a plugin declared `privileged` in its manifest: the
+ * same surface as a regular plugin's, plus the Kuzzle instance itself.
  */
-class PrivilegedPluginContext extends PluginContext {
-    /**
-     * @param {Kuzzle} kuzzle
-     * @param {string} pluginName
-     * @constructor
-     */
+class PrivilegedPluginContext extends pluginContext_1.PluginContext {
     constructor(pluginName) {
         super(pluginName);
         this.accessors.kuzzle = global.kuzzle;

package/dist/lib/core/realtime/actionEnum.d.ts

@@ -1,25 +1,16 @@
-export = actionEnum;
-/**
- * Enum for the document's notification "action" option
- */
-type actionEnum = notifyActionEnum;
 /**
- * @typedef {number} notifyActionEnum
- */
-/**
- * Enum for the document's notification "action" option
- * @readOnly
- * @enum {notifyActionEnum}
+ * Enum for the document's notification "action" option.
+ *
+ * `as const` is type-only (no runtime change) and is what gives the members
+ * literal types, so `NotifyActionEnum` below is a real union instead of
+ * widening to `number`.
  */
 declare const actionEnum: Readonly<{
-    CREATE: 1;
-    DELETE: 2;
-    REPLACE: 3;
-    UPDATE: 4;
-    UPSERT: 5;
-    WRITE: 6;
+    readonly CREATE: 1;
+    readonly DELETE: 2;
+    readonly REPLACE: 3;
+    readonly UPDATE: 4;
+    readonly UPSERT: 5;
+    readonly WRITE: 6;
 }>;
-declare namespace actionEnum {
-    export { notifyActionEnum };
-}
-type notifyActionEnum = number;
+export = actionEnum;

package/dist/lib/core/realtime/actionEnum.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,14 +19,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
 /**
- * @typedef {number} notifyActionEnum
- */
-/**
- * Enum for the document's notification "action" option
- * @readOnly
- * @enum {notifyActionEnum}
+ * Enum for the document's notification "action" option.
+ *
+ * `as const` is type-only (no runtime change) and is what gives the members
+ * literal types, so `NotifyActionEnum` below is a real union instead of
+ * widening to `number`.
  */
 const actionEnum = Object.freeze({
     CREATE: 1,

package/dist/lib/core/realtime/channel.d.ts

@@ -1,4 +1,10 @@
-import { RealtimeScope, RealtimeUsers } from "../../types";
+import type { RealtimeScope, RealtimeUsers } from "../../types";
+/**
+ * A channel's document scope. Wider than `RealtimeScope`, which also types a
+ * document *notification* and so cannot hold `"none"`: a `"none"`-scoped
+ * channel takes user events and no document event (TD-74).
+ */
+export type ChannelScope = RealtimeScope | "none";
 /**
  * A channel define how notifications should be send for a particular realtime
  * room.
@@ -27,8 +33,8 @@ export declare class Channel {
      * This is 10x faster than murmur.
      */
     static hash(channel: Channel): string;
-    static USERS_ALLOWED_VALUES: string[];
-    static SCOPE_ALLOWED_VALUES: string[];
+    static readonly USERS_ALLOWED_VALUES: string[];
+    static readonly SCOPE_ALLOWED_VALUES: readonly string[];
     /**
      * Identifier of the channel.
      *
@@ -41,7 +47,7 @@ export declare class Channel {
      *
      * @default "all"
      */
-    scope: RealtimeScope;
+    scope: ChannelScope;
     /**
      * Define if notification should be send when users join or leave the channel.
      *
@@ -57,7 +63,7 @@ export declare class Channel {
      */
     cluster: boolean;
     constructor(roomId: string, { scope, users, propagate, }?: {
-        scope?: RealtimeScope;
+        scope?: ChannelScope;
         users?: RealtimeUsers;
         propagate?: boolean;
     });

package/dist/lib/core/realtime/channel.js

@@ -82,8 +82,13 @@ class Channel {
             case "in":
                 str += "2";
                 break;
+            // "out" and "none" both hashed to "3", so two subscriptions to one room
+            // that differed only there shared a channel, and the second got the
+            // first one's configuration (`Room.createChannel` keeps the first).
+            // "none" keeps "3" — it is the default, and every default channel keeps
+            // its name — and "out" takes the next free digit (TD-74).
             case "out":
-                str += "3";
+                str += "4";
                 break;
             case "none":
                 str += "3";
@@ -107,6 +112,9 @@ class Channel {
             case "out":
                 str += "3";
                 break;
+            // No case for "none", on purpose: it adds no digit, and since every
+            // other field always adds exactly one, a two-digit suffix is already
+            // unique to it. A case would only rename those channels (TD-74).
         }
         return str;
     }
@@ -125,5 +133,12 @@ class Channel {
 }
 exports.Channel = Channel;
 Channel.USERS_ALLOWED_VALUES = ["all", "in", "out", "none"];
-Channel.SCOPE_ALLOWED_VALUES = Channel.USERS_ALLOWED_VALUES;
+// Its own array: it used to be `USERS_ALLOWED_VALUES` itself, which is how
+// `"none"` became a valid scope without the type or the hash knowing.
+Channel.SCOPE_ALLOWED_VALUES = [
+    "all",
+    "in",
+    "out",
+    "none",
+];
 //# sourceMappingURL=channel.js.map

package/dist/lib/core/realtime/connectionRooms.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 /**
  * Each connection can subscribe to many rooms with different sets of volatile
  * data.
@@ -24,5 +24,5 @@ export declare class ConnectionRooms {
     /**
      * Returns the volatile data for this room subscription
      */
-    getVolatile(roomId: string): JSONObject;
+    getVolatile(roomId: string): JSONObject | undefined;
 }

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

@@ -1,6 +1,7 @@
 import { KuzzleRequest } from "../../api/request";
-import { RoomList } from "../../types";
-import { User } from "../../model/security/user";
+import type { RoomList } from "../../types";
+import { Room } from "./room";
+import type { User } from "../../model/security/user";
 /**
  * The HotelClerk is responsible of keeping the list of rooms and subscriptions
  * made to those rooms.
@@ -31,7 +32,12 @@ export declare class HotelClerk {
      *
      * Map<roomId, Room>
      */
-    private rooms;
+    /**
+     * Not `private`: `core/realtime/notifier` reads it directly
+     * (`this.module.hotelClerk.rooms.get(room)`) to resolve a room's channels.
+     * The modifier never matched that long-standing cross-class access.
+     */
+    rooms: Map<string, Room>;
     /**
      * Current subscribing connections handled by the HotelClerk.
      *
@@ -68,7 +74,7 @@ export declare class HotelClerk {
     subscribe(request: KuzzleRequest): Promise<{
         channel: string;
         roomId: string;
-    }>;
+    } | null>;
     /**
      * Returns the list of collections of an index with realtime rooms.
      */
@@ -80,8 +86,8 @@ export declare class HotelClerk {
      * filters will be fetched from the cluster.
      */
     join(request: KuzzleRequest): Promise<{
-        channel: any;
-        roomId: any;
+        channel: string;
+        roomId: string;
     }>;
     /**
      * Return the list of index, collection, rooms and subscribing connections

package/dist/lib/core/realtime/hotelClerk.js

@@ -88,6 +88,11 @@ class HotelClerk {
          *
          * Map<roomId, Room>
          */
+        /**
+         * Not `private`: `core/realtime/notifier` reads it directly
+         * (`this.module.hotelClerk.rooms.get(room)`) to resolve a room's channels.
+         * The modifier never matched that long-standing cross-class access.
+         */
         this.rooms = new Map();
         /**
          * Current subscribing connections handled by the HotelClerk.
@@ -207,15 +212,19 @@ class HotelClerk {
          * is made on the very last moment and is essential to ensure
          * that no zombie subscription can be performed
          */
-        if (!global.kuzzle.router.isConnectionAlive(request.context)) {
+        const connectionId = request.context.connection.id;
+        // A subscription is keyed by the connection that made it, so no connection
+        // id is the same dead connection this check is here to catch.
+        if (connectionId === null ||
+            !global.kuzzle.router.isConnectionAlive(request.context)) {
             return null;
         }
         let normalized;
         try {
-            normalized = this.koncorde.normalize(request.input.body, (0, koncordeCompat_1.toKoncordeIndex)(index, collection));
+            normalized = this.koncorde.normalize(request.input.body ?? {}, (0, koncordeCompat_1.toKoncordeIndex)(index, collection));
         }
         catch (e) {
-            throw kerror.get("api", "assert", "koncorde_dsl_error", e.message);
+            throw kerror.get("api", "assert", "koncorde_dsl_error", e instanceof Error ? e.message : String(e));
         }
         this.createRoom(normalized);
         /**
@@ -249,7 +258,7 @@ class HotelClerk {
             }
         };
         const { channel } = await this.subscribeToRoom(normalized.id, request, afterSubscribeCallback);
-        const subscription = new subscription_1.Subscription(index, collection, request.input.body, normalized.id, request.context.connection.id, request.context.user);
+        const subscription = new subscription_1.Subscription(index, collection, request.input.body ?? {}, normalized.id, connectionId, request.context.user);
         global.kuzzle.emit("core:realtime:user:subscribe:after", subscription);
         return {
             channel,
@@ -269,7 +278,7 @@ class HotelClerk {
      * filters will be fetched from the cluster.
      */
     async join(request) {
-        const roomId = request.input.body.roomId;
+        const roomId = request.input.body?.roomId;
         if (!this.rooms.has(roomId)) {
             const normalized = await global.kuzzle.ask("cluster:realtime:filters:get", roomId);
             if (!normalized) {
@@ -322,15 +331,16 @@ class HotelClerk {
             const toRemove = [];
             const collectionNames = Object.keys(collections);
             // Iterate from the end so we process the most recently added collections first
-            for (let i = collectionNames.length - 1; i >= 0; i--) {
-                const collection = collectionNames[i];
+            // Reversed copy rather than a backwards index loop: same order, and the
+            // entries come out of it already narrowed.
+            for (const collection of [...collectionNames].reverse()) {
                 isAllowedRequest.input.resource.collection = collection;
                 if (!(await user.isActionAllowed(isAllowedRequest))) {
                     toRemove.push(collection);
                 }
             }
             for (const collection of toRemove) {
-                delete fullStateRooms[index][collection];
+                delete fullStateRooms[index]?.[collection];
             }
         }
         return fullStateRooms;
@@ -369,7 +379,7 @@ class HotelClerk {
             this.subscriptions.set(connectionId, connectionRooms);
         }
         connectionRooms.addRoom(roomId, volatile);
-        this.rooms.get(roomId).addConnection(connectionId);
+        this.rooms.get(roomId)?.addConnection(connectionId);
     }
     /**
      * Create new room if needed
@@ -512,7 +522,7 @@ class HotelClerk {
         try {
             await global.kuzzle.pipe("room:remove", roomId);
         }
-        catch (e) {
+        catch {
             return;
         }
     }
@@ -528,12 +538,20 @@ class HotelClerk {
         let notifyPromise;
         const { scope, users, propagate } = request.input.args;
         const connectionId = request.context.connection.id;
+        // Same as `subscribe`: a room is joined by a connection, and there is none.
+        if (connectionId === null) {
+            throw kerror.get("core", "realtime", "not_subscribed", "", roomId);
+        }
         const channel = new channel_1.Channel(roomId, { propagate, scope, users });
         const connectionRooms = this.subscriptions.get(connectionId);
         const room = this.rooms.get(roomId);
+        // Every caller creates or fetches the room before subscribing to it.
+        if (room === undefined) {
+            throw kerror.get("core", "realtime", "room_not_found", roomId);
+        }
         if (!connectionRooms || !connectionRooms.hasRoom(roomId)) {
             subscribed = true;
-            this.registerSubscription(connectionId, roomId, request.input.volatile);
+            this.registerSubscription(connectionId, roomId, request.input.volatile ?? {});
             notifyPromise = this.module.notifier.notifyUser(roomId, request, "in", {
                 count: room.size,
             });

package/dist/lib/core/realtime/index.d.ts

@@ -1,8 +1,13 @@
-export = RealtimeModule;
+import Notifier from "./notifier";
+import { HotelClerk } from "./hotelClerk";
+/**
+ * Wires the realtime components together. Both receive this module: the
+ * notifier reads `module.hotelClerk.rooms` to resolve a room's channels.
+ */
 declare class RealtimeModule {
     notifier: Notifier;
     hotelClerk: HotelClerk;
+    constructor();
     init(): Promise<void>;
 }
-import Notifier = require("./notifier");
-import { HotelClerk } from "./hotelClerk";
+export = RealtimeModule;

package/dist/lib/core/realtime/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,13 +19,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const Notifier = require("./notifier");
-const { HotelClerk } = require("./hotelClerk");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const notifier_1 = __importDefault(require("./notifier"));
+const hotelClerk_1 = require("./hotelClerk");
+/**
+ * Wires the realtime components together. Both receive this module: the
+ * notifier reads `module.hotelClerk.rooms` to resolve a room's channels.
+ */
 class RealtimeModule {
     constructor() {
-        this.notifier = new Notifier(this);
-        this.hotelClerk = new HotelClerk(this);
+        this.notifier = new notifier_1.default(this);
+        this.hotelClerk = new hotelClerk_1.HotelClerk(this);
     }
     async init() {
         await this.notifier.init();

package/dist/lib/core/realtime/notification/document.d.ts

@@ -1,34 +1,63 @@
-export = DocumentNotification;
+import type { JSONObject } from "../../../types/JSONObject";
+import type { KuzzleRequest } from "../../../api/request";
+import type { RealtimeScope } from "../../../types";
+import "../../../types/Global";
+/**
+ * Coarse event a document action belongs to. Subscribers filter on it, so the
+ * mapping below is part of the realtime contract.
+ */
+type DocumentNotificationEvent = "write" | "delete" | "publish";
+/**
+ * Constructor payload. Two producers fill it: `fromRequest` below, and
+ * `cluster/subscriber` when it rebuilds a notification from a decoded protobuf
+ * message — hence the wide `result` and `volatile`.
+ */
+interface DocumentNotificationOptions {
+    status: number;
+    action: string;
+    scope: RealtimeScope;
+    result: JSONObject;
+    node: string;
+    requestId?: string;
+    timestamp: number;
+    /**
+     * Nullable, like the other four below: they come straight off the request,
+     * where each is nullable, and a notification built from a request without one
+     * has always been emitted — and received — with `null` in that field.
+     */
+    volatile: JSONObject | null;
+    index: string;
+    collection: string;
+    controller: string | null;
+    protocol: string | null;
+}
 /**
  * Document notification document
- *
- * @class DocumentNotification
  */
 declare class DocumentNotification {
+    type: string;
+    status: number;
+    action: string;
+    scope: RealtimeScope;
+    result: JSONObject;
+    node: string;
+    event: DocumentNotificationEvent;
+    requestId?: string;
+    timestamp: number;
+    volatile: JSONObject | null;
+    index: string;
+    collection: string;
+    controller: string | null;
+    protocol: string | null;
+    constructor(opts: DocumentNotificationOptions);
     /**
      * Instantiates a DocumentNotification object from a KuzzleRequest
      *
-     * @param {Request} request - the request object from which the notification is issued
-     * @param {string} scope - The scope of the notification (in or out)
-     * @param {state} state - The document state (pending or done)
-     * @param {action} action - Action performed on the document
-     * @param {result} content - Notification content
-     * @returns {DocumentNotification}
+     * @param request - the request object from which the notification is issued
+     * @param scope - The scope of the notification (in or out)
+     * @param action - Action performed on the document
+     * @param result - Notification content
      */
-    static fromRequest(request: Request, scope: string, action: any, result: any): DocumentNotification;
-    constructor(opts: any);
-    type: string;
-    status: any;
-    action: any;
-    scope: any;
-    result: any;
-    node: any;
-    event: string;
-    requestId: any;
-    timestamp: any;
-    volatile: any;
-    index: any;
-    collection: any;
-    controller: any;
-    protocol: any;
+    static fromRequest(request: KuzzleRequest, scope: RealtimeScope, action: string, result: JSONObject): DocumentNotification;
 }
+export = DocumentNotification;

package/dist/lib/core/realtime/notification/document.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,8 +19,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { InternalError } = require("../../../kerror/errors");
+const errors_1 = require("../../../kerror/errors");
+require("../../../types/Global");
 function getEvent(action) {
     switch (action) {
         case "create":
@@ -42,13 +43,11 @@ function getEvent(action) {
         case "publish":
             return "publish";
         default:
-            throw new InternalError(`Unknown event type for action "${action}"`);
+            throw new errors_1.InternalError(`Unknown event type for action "${action}"`);
     }
 }
 /**
  * Document notification document
- *
- * @class DocumentNotification
  */
 class DocumentNotification {
     constructor(opts) {
@@ -70,19 +69,17 @@ class DocumentNotification {
     /**
      * Instantiates a DocumentNotification object from a KuzzleRequest
      *
-     * @param {Request} request - the request object from which the notification is issued
-     * @param {string} scope - The scope of the notification (in or out)
-     * @param {state} state - The document state (pending or done)
-     * @param {action} action - Action performed on the document
-     * @param {result} content - Notification content
-     * @returns {DocumentNotification}
+     * @param request - the request object from which the notification is issued
+     * @param scope - The scope of the notification (in or out)
+     * @param action - Action performed on the document
+     * @param result - Notification content
      */
     static fromRequest(request, scope, action, result) {
         return new DocumentNotification({
             action,
-            collection: request.input.resource.collection,
+            collection: request.input.args.collection,
             controller: request.input.controller,
-            index: request.input.resource.index,
+            index: request.input.args.index,
             node: global.kuzzle.id,
             protocol: request.context.connection.protocol,
             requestId: request.id,

package/dist/lib/core/realtime/notification/index.d.ts

@@ -1,3 +1,9 @@
-export let DocumentNotification: typeof import("./document");
-export let ServerNotification: typeof import("./server");
-export let UserNotification: typeof import("./user");
+import DocumentNotification from "./document";
+import ServerNotification from "./server";
+import UserNotification from "./user";
+declare const _default: {
+    DocumentNotification: typeof DocumentNotification;
+    ServerNotification: typeof ServerNotification;
+    UserNotification: typeof UserNotification;
+};
+export = _default;

package/dist/lib/core/realtime/notification/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,10 +19,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const document_1 = __importDefault(require("./document"));
+const server_1 = __importDefault(require("./server"));
+const user_1 = __importDefault(require("./user"));
 module.exports = {
-    DocumentNotification: require("./document"),
-    ServerNotification: require("./server"),
-    UserNotification: require("./user"),
+    DocumentNotification: document_1.default,
+    ServerNotification: server_1.default,
+    UserNotification: user_1.default,
 };
 //# sourceMappingURL=index.js.map

package/dist/lib/core/realtime/notification/server.d.ts

@@ -1,17 +1,14 @@
-export = ServerNotification;
+import "../../../types/Global";
 /**
- * Creates a notification response from a given room, request object, and content.
- *
- * @class ServerNotification
- * @param {Request} request - the request object from which the notification is issued
- * @param {string} type - Notification type
- * @param {string} message - Notification message
+ * A notification issued by the server itself rather than by a request —
+ * currently only "TokenExpired".
  */
 declare class ServerNotification {
-    constructor(type: any, message: any);
     status: number;
     info: string;
-    message: any;
-    type: any;
+    message: string;
+    type: string;
     node: string;
+    constructor(type: string, message: string);
 }
+export = ServerNotification;

package/dist/lib/core/realtime/notification/server.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,14 +19,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
+require("../../../types/Global");
 /**
- * Creates a notification response from a given room, request object, and content.
- *
- * @class ServerNotification
- * @param {Request} request - the request object from which the notification is issued
- * @param {string} type - Notification type
- * @param {string} message - Notification message
+ * A notification issued by the server itself rather than by a request —
+ * currently only "TokenExpired".
  */
 class ServerNotification {
     constructor(type, message) {