kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,29 +1,53 @@
-export = UserNotification;
+import type { JSONObject } from "../../../types/JSONObject";
+import type { KuzzleRequest } from "../../../api/request";
+import type { RealtimeUsers } from "../../../types";
+import "../../../types/Global";
+/**
+ * Constructor payload. Filled either by `fromRequest` below or by
+ * `cluster/subscriber` from a decoded protobuf message.
+ */
+interface UserNotificationOptions {
+    status: number;
+    user: RealtimeUsers;
+    result: JSONObject;
+    node: 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;
+    action: string | null;
+    protocol: string | null;
+}
 /**
  * User notification document
- *
- * @class UserNotification
  */
 declare class UserNotification {
+    type: string;
+    status: number;
+    user: RealtimeUsers;
+    result: JSONObject;
+    node: string;
+    timestamp: number;
+    volatile: JSONObject | null;
+    index: string;
+    collection: string;
+    controller: string | null;
+    action: string | null;
+    protocol: string | null;
+    constructor(opts: UserNotificationOptions);
     /**
      * Instantiates a UserNotification object from a KuzzleRequest
-     * @param {Request} request - the request object from which the notification is issued
-     * @param {string} user - The scope of the notification (in or out)
-     * @param {object} content - Notification content
-     * returns {UserNotification}
+     *
+     * @param request - the request object from which the notification is issued
+     * @param user - Whether the user is entering or leaving the room
+     * @param result - Notification content
      */
-    static fromRequest(request: Request, user: string, result: any): UserNotification;
-    constructor(opts: any);
-    type: string;
-    status: any;
-    user: any;
-    result: any;
-    node: any;
-    timestamp: any;
-    volatile: any;
-    index: any;
-    collection: any;
-    controller: any;
-    action: any;
-    protocol: any;
+    static fromRequest(request: KuzzleRequest, user: RealtimeUsers, result: JSONObject): UserNotification;
 }
+export = UserNotification;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,11 +19,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
+require("../../../types/Global");
 /**
  * User notification document
- *
- * @class UserNotification
  */
 class UserNotification {
     constructor(opts) {
@@ -41,17 +40,17 @@ class UserNotification {
     }
     /**
      * Instantiates a UserNotification object from a KuzzleRequest
-     * @param {Request} request - the request object from which the notification is issued
-     * @param {string} user - The scope of the notification (in or out)
-     * @param {object} content - Notification content
-     * returns {UserNotification}
+     *
+     * @param request - the request object from which the notification is issued
+     * @param user - Whether the user is entering or leaving the room
+     * @param result - Notification content
      */
     static fromRequest(request, user, result) {
         return new UserNotification({
             action: request.input.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,
             result,

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

@@ -1,4 +1,33 @@
-export = NotifierController;
+import type { JSONObject } from "../../types/JSONObject";
+import Bluebird from "bluebird";
+import type { KuzzleRequest } from "../../api/request";
+import type { RealtimeScope, RealtimeUsers } from "../../types";
+import actionEnum from "./actionEnum";
+/**
+ * One of `actionEnum`'s members. Derived from the frozen object so the two
+ * cannot drift.
+ */
+type NotifyAction = (typeof actionEnum)[keyof typeof actionEnum];
+import type { Logger } from "../../kuzzle/Logger";
+import "../../types/Global";
+import type { HotelClerk } from "./hotelClerk";
+interface RealtimeModule {
+    hotelClerk: HotelClerk;
+}
+/**
+ * The slice of a written document this controller needs: its id, the source to
+ * match against subscription filters, and — for the WRITE/UPSERT actions, which
+ * cover both cases — whether the write created the document or updated it.
+ */
+interface DocumentChanges {
+    _id: string;
+    _source?: JSONObject;
+    created?: boolean;
+    action?: string;
+}
+declare const DocumentNotification: typeof import("./notification/document"), UserNotification: typeof import("./notification/user");
+type DocumentNotificationType = InstanceType<typeof DocumentNotification>;
+type UserNotificationType = InstanceType<typeof UserNotification>;
 /**
  * @typedef {Object} DocumentChanges
  * @property {string}  _id              of the document
@@ -11,10 +40,10 @@ export = NotifierController;
  * @class NotifierController
  */
 declare class NotifierController {
-    constructor(realtimeModule: any);
-    module: any;
-    ttl: number;
-    logger: import("../../kuzzle/Logger").Logger;
+    private readonly module;
+    private readonly ttl;
+    logger: Logger;
+    constructor(realtimeModule: RealtimeModule);
     init(): Promise<void>;
     /**
      * Broadcasts a notification about a document change or a
@@ -27,7 +56,7 @@ declare class NotifierController {
      *
      * @returns {Promise}
      */
-    notifyDocument(rooms: any[], request: Request, scope: string, action: any, content: object): Promise<any>;
+    notifyDocument(rooms: string[], request: KuzzleRequest, scope: RealtimeScope, action: string, content: JSONObject): Promise<void>;
     /**
      * Broadcast a notification about a user entering or leaving
      * the provided room
@@ -39,21 +68,21 @@ declare class NotifierController {
      *
      * @returns {Promise}
      */
-    notifyUser(room: string, request: Request, scope: string, content: object): Promise<any>;
+    notifyUser(room: string, request: KuzzleRequest, scope: RealtimeUsers, content: JSONObject): Promise<void>;
     /**
      * Send a "token expired" notification to the target user
      *
      * @param {string} connectionId - User's connection identifier
      * @returns {Promise}
      */
-    notifyTokenExpired(connectionId: string): Promise<any>;
+    notifyTokenExpired(connectionId: string): Promise<void>;
     /**
      * Publish the content of the provided request to listening subscribers
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    publish(request: Request): Promise<any>;
+    publish(request: KuzzleRequest): Promise<void> | Bluebird<null>;
     /**
      * Notify about a created document
      *
@@ -61,7 +90,7 @@ declare class NotifierController {
      * @param {DocumentChanges} document created
      * @returns {Promise.<Array.<string>>} list of matched rooms
      */
-    notifyDocumentCreate(request: Request, document: DocumentChanges): Promise<Array<string>>;
+    notifyDocumentCreate(request: KuzzleRequest, document: DocumentChanges): Promise<string[]>;
     /**
      * Notify about a replaced document
      *
@@ -70,7 +99,7 @@ declare class NotifierController {
      * @param {string} cache notification content for that document
      * @returns {Promise.<Array.<string>} list of matched rooms
      */
-    notifyDocumentReplace(request: Request, document: DocumentChanges, cache?: string): Promise<Array<string>>;
+    notifyDocumentReplace(request: KuzzleRequest, document: DocumentChanges, cache?: string | null): Promise<string[]>;
     /**
      * Computes document notifications and sends them to subscribed users.
      * @param  {Request} request
@@ -78,7 +107,7 @@ declare class NotifierController {
      * @param  {Array.<DocumentChanges>} documents
      * @return {Promise}
      */
-    notifyDocuments(request: Request, action: notifyActionEnum, documents: Array<DocumentChanges>): Promise<any>;
+    notifyDocuments(request: KuzzleRequest, action: NotifyAction, documents: DocumentChanges[]): Promise<void>;
     /**
      * Notify rooms on a document update
      * @param {Request} request
@@ -86,7 +115,7 @@ declare class NotifierController {
      * @param {string} cache notification content for that document
      * @returns {Promise.<Array.<string>} list of matched rooms
      */
-    notifyDocumentUpdate(request: Request, document: DocumentChanges, cache?: string): Promise<Array<string>>;
+    notifyDocumentUpdate(request: KuzzleRequest, document: DocumentChanges, cache?: string | null): Promise<string[]>;
     /**
      * Notify about a document deletion
      *
@@ -94,7 +123,7 @@ declare class NotifierController {
      * @param {DocumentChanges} document
      * @returns {Promise.<Array>} returns an empty array ("no room match anymore")
      */
-    notifyDocumentDelete(request: Request, document: DocumentChanges): Promise<any[]>;
+    notifyDocumentDelete(request: KuzzleRequest, document: DocumentChanges): Promise<string[]>;
     /**
      * Trigger a notify global event and, if accepted by plugins,
      * dispatch the payload to subscribers
@@ -107,7 +136,7 @@ declare class NotifierController {
      *
      * @returns {Promise}
      */
-    _dispatch(event: any, channels: any[], notification: Notification.User | Notification.Document | Notification.Server, connectionId?: string): Promise<any>;
+    _dispatch(event: string, channels: string[], notification: unknown, connectionId?: string): Promise<void>;
     /**
      * Broadcasts a notification about a document change or a
      * real-time message.
@@ -125,7 +154,9 @@ declare class NotifierController {
      *
      * @returns {Promise}
      */
-    _notifyDocument(rooms: any[], notification: typeof import("./notification/document"), { fromCluster }?: object): Promise<any>;
+    _notifyDocument(rooms: string[], notification: DocumentNotificationType, { fromCluster }?: {
+        fromCluster?: boolean;
+    }): Promise<void>;
     /**
      * Broadcast a notification about a user entering or leaving
      * the provided room
@@ -136,7 +167,9 @@ declare class NotifierController {
      *
      * @returns {Promise}
      */
-    _notifyUser(room: string, notification: typeof import("./notification/user"), { fromCluster }?: object): Promise<any>;
+    _notifyUser(room: string, notification: UserNotificationType, { fromCluster }?: {
+        fromCluster?: boolean;
+    }): Promise<void>;
     /**
      * DRYification for calls to Koncorde's test method from a Request object
      * @param {Request} request
@@ -145,27 +178,6 @@ declare class NotifierController {
      *
      * @returns {Array.<string>}
      */
-    _test(request: Request, source?: any, id?: string): Array<string>;
+    _test(request: KuzzleRequest, source?: JSONObject | null, id?: string | null): string[];
 }
-declare namespace NotifierController {
-    export { DocumentChanges };
-}
-type DocumentChanges = {
-    /**
-     * of the document
-     */
-    _id: string;
-    /**
-     * of the document
-     */
-    _source?: any;
-    /**
-     * applied to the document (for updates)
-     */
-    _updatedFields?: any;
-    /**
-     * -- tells if this is a CREATE or REPLACE
-     *         (for actionEnum.WRITE)
-     */
-    created?: boolean;
-};
+export = NotifierController;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,13 +19,43 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { difference } = require("lodash");
-const Bluebird = require("bluebird");
-const kerror = require("../../kerror");
-const actionEnum = require("./actionEnum");
-const { koncordeTest } = require("../../util/koncordeCompat");
-const { DocumentNotification, ServerNotification, UserNotification, } = require("./notification");
+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 lodash_1 = require("lodash");
+const bluebird_1 = __importDefault(require("bluebird"));
+const kerror = __importStar(require("../../kerror"));
+const actionEnum_1 = __importDefault(require("./actionEnum"));
+const koncordeCompat_1 = require("../../util/koncordeCompat");
+require("../../types/Global");
+// The barrel ships `export = { ... }`: a named import cannot target that
+// (TS2497), but a default one can under `esModuleInterop` — and it also loads
+// under vitest, which `import x = require(...)` does not (step 07, PR G2).
+const notification_1 = __importDefault(require("./notification"));
+const { DocumentNotification, ServerNotification, UserNotification } = notification_1.default;
 /**
  * Notification are meant to be dispatched on "channels" created when subscribing.
  * But some notification like TokenExpired don't have a specific channel to be received on,
@@ -159,7 +190,7 @@ class NotifierController {
     publish(request) {
         const rooms = this._test(request);
         if (rooms.length === 0) {
-            return Bluebird.resolve(null);
+            return bluebird_1.default.resolve(null);
         }
         return this.notifyDocument(rooms, request, "in", "publish", {
             _id: request.input.args._id,
@@ -194,7 +225,7 @@ class NotifierController {
             await this.notifyDocument(rooms, request, "in", "replace", document);
         }
         if (cache !== null) {
-            const stopListening = difference(JSON.parse(cache), rooms);
+            const stopListening = (0, lodash_1.difference)(JSON.parse(cache), rooms);
             await this.notifyDocument(stopListening, request, "out", "replace", document);
         }
         return rooms;
@@ -208,9 +239,9 @@ class NotifierController {
      */
     async notifyDocuments(request, action, documents) {
         const prefix = getCachePrefix(request);
-        let cached = action === actionEnum.REPLACE || action === actionEnum.UPDATE;
+        let cached = action === actionEnum_1.default.REPLACE || action === actionEnum_1.default.UPDATE;
         const cacheIds = documents.map((doc) => {
-            if ((action === actionEnum.WRITE || action === actionEnum.UPSERT) &&
+            if ((action === actionEnum_1.default.WRITE || action === actionEnum_1.default.UPSERT) &&
                 !cached) {
                 cached = doc.created !== true; // force a bool value if undefined
             }
@@ -219,21 +250,21 @@ class NotifierController {
         const cache = cached
             ? await global.kuzzle.ask("core:cache:internal:mget", cacheIds)
             : [];
-        const result = await Bluebird.map(documents, (doc, index) => {
+        const result = await bluebird_1.default.map(documents, (doc, index) => {
             switch (action) {
-                case actionEnum.CREATE:
+                case actionEnum_1.default.CREATE:
                     return this.notifyDocumentCreate(request, doc);
-                case actionEnum.DELETE:
+                case actionEnum_1.default.DELETE:
                     return this.notifyDocumentDelete(request, doc);
-                case actionEnum.REPLACE:
+                case actionEnum_1.default.REPLACE:
                     return this.notifyDocumentReplace(request, doc, cache[index]);
-                case actionEnum.UPDATE:
+                case actionEnum_1.default.UPDATE:
                     return this.notifyDocumentUpdate(request, doc, cache[index]);
-                case actionEnum.UPSERT:
+                case actionEnum_1.default.UPSERT:
                     return doc.created
                         ? this.notifyDocumentCreate(request, doc)
                         : this.notifyDocumentUpdate(request, doc, cache[index]);
-                case actionEnum.WRITE:
+                case actionEnum_1.default.WRITE:
                     return doc.created
                         ? this.notifyDocumentCreate(request, doc)
                         : this.notifyDocumentReplace(request, doc, cache[index]);
@@ -242,11 +273,15 @@ class NotifierController {
             }
         });
         const toDelete = [];
-        await Bluebird.map(result, (rooms, index) => {
+        // Walk the ids, not the results: `cacheIds`, `documents` and `result` are
+        // the same length by construction, and this is the array whose element the
+        // body needs non-optionally.
+        await bluebird_1.default.map(cacheIds, (cacheId, index) => {
+            const rooms = result[index] ?? [];
             if (rooms.length > 0) {
-                return global.kuzzle.ask("core:cache:internal:store", cacheIds[index], JSON.stringify(rooms), { ttl: this.ttl });
+                return global.kuzzle.ask("core:cache:internal:store", cacheId, JSON.stringify(rooms), { ttl: this.ttl });
             }
-            toDelete.push(cacheIds[index]);
+            toDelete.push(cacheId);
             return null;
         });
         if (toDelete.length > 0) {
@@ -266,7 +301,7 @@ class NotifierController {
             await this.notifyDocument(rooms, request, "in", "update", document);
         }
         if (cache !== null) {
-            const stopListening = difference(JSON.parse(cache), rooms);
+            const stopListening = (0, lodash_1.difference)(JSON.parse(cache), rooms);
             await this.notifyDocument(stopListening, request, "out", "update", document);
         }
         return rooms;
@@ -353,7 +388,7 @@ class NotifierController {
             }
         }
         if (channels.length === 0) {
-            return Bluebird.resolve();
+            return bluebird_1.default.resolve();
         }
         return this._dispatch("notify:document", channels, notification);
     }
@@ -380,7 +415,7 @@ class NotifierController {
             }
         }
         if (channels.length === 0) {
-            return Bluebird.resolve();
+            return bluebird_1.default.resolve();
         }
         return this._dispatch("notify:user", channels, notification);
     }
@@ -393,7 +428,7 @@ class NotifierController {
      * @returns {Array.<string>}
      */
     _test(request, source = null, id = null) {
-        return koncordeTest(global.kuzzle.koncorde, request.input.args.index, request.input.args.collection, source || request.input.body || {}, id || request.input.args._id);
+        return (0, koncordeCompat_1.koncordeTest)(global.kuzzle.koncorde, request.input.args.index, request.input.args.collection, source || request.input.body || {}, id || request.input.args._id);
     }
 }
 function getCachePrefix(request) {

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

@@ -1,4 +1,4 @@
-import { Channel } from "./channel";
+import type { Channel } from "./channel";
 /**
  * A room represents a subscription scope made on a combination of:
  *  - index

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

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 /**
  * Represents a realtime subscription of a connection to a room.
  *
@@ -17,9 +17,14 @@ export declare class Subscription {
     roomId: string;
     index: string;
     collection: string;
-    filters: JSONObject;
-    kuid: string;
-    constructor(index: string, collection: string, filters: JSONObject, roomId: string, connectionId: string, user: {
-        _id: string;
-    });
+    filters: JSONObject | undefined;
+    /** Null for an anonymous subscription — `user._id` is what fills it. */
+    kuid: string | null;
+    constructor(index: string, collection: string, 
+    /** Absent for an unsubscribe, which reports the room it left, not a filter. */
+    filters: JSONObject | undefined, roomId: string, connectionId: string, 
+    /** Absent or null when the connection carried no user — `kuid` is then null. */
+    user?: {
+        _id: string | null;
+    } | null);
 }

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

@@ -35,7 +35,11 @@ exports.Subscription = void 0;
  * @property kuid
  */
 class Subscription {
-    constructor(index, collection, filters, roomId, connectionId, user) {
+    constructor(index, collection, 
+    /** Absent for an unsubscribe, which reports the room it left, not a filter. */
+    filters, roomId, connectionId, 
+    /** Absent or null when the connection carried no user — `kuid` is then null. */
+    user) {
         this.connectionId = connectionId;
         this.roomId = roomId;
         this.index = index;

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

@@ -1,14 +1,22 @@
-export = SecurityModule;
+import RoleRepository from "./roleRepository";
+import { ProfileRepository } from "./profileRepository";
+import { TokenRepository } from "./tokenRepository";
+import UserRepository from "./userRepository";
+import SecurityLoader from "./securityLoader";
+/**
+ * Wires the security repositories together and initialises them in order.
+ *
+ * The repositories that reach a sibling (`role` -> `profile`, `user` ->
+ * `profile`/`token`) receive this module; the token repository and the loader
+ * do not, and their constructors take no argument.
+ */
 declare class SecurityModule {
     role: RoleRepository;
     profile: ProfileRepository;
     token: TokenRepository;
     user: UserRepository;
     loader: SecurityLoader;
+    constructor();
     init(): Promise<void>;
 }
-import RoleRepository = require("./roleRepository");
-import { ProfileRepository } from "./profileRepository";
-import { TokenRepository } from "./tokenRepository";
-import UserRepository = require("./userRepository");
-import SecurityLoader = require("./securityLoader");
+export = SecurityModule;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,25 +19,38 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const RoleRepository = require("./roleRepository");
-const { ProfileRepository } = require("./profileRepository");
-const { TokenRepository } = require("./tokenRepository");
-const UserRepository = require("./userRepository");
-const SecurityLoader = require("./securityLoader");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const roleRepository_1 = __importDefault(require("./roleRepository"));
+const profileRepository_1 = require("./profileRepository");
+const tokenRepository_1 = require("./tokenRepository");
+const userRepository_1 = __importDefault(require("./userRepository"));
+const securityLoader_1 = __importDefault(require("./securityLoader"));
+/**
+ * Wires the security repositories together and initialises them in order.
+ *
+ * The repositories that reach a sibling (`role` -> `profile`, `user` ->
+ * `profile`/`token`) receive this module; the token repository and the loader
+ * do not, and their constructors take no argument.
+ */
 class SecurityModule {
     constructor() {
-        this.role = new RoleRepository(this);
-        this.profile = new ProfileRepository(this);
-        this.token = new TokenRepository();
-        this.user = new UserRepository(this);
-        this.loader = new SecurityLoader();
+        this.role = new roleRepository_1.default(this);
+        this.profile = new profileRepository_1.ProfileRepository(this);
+        this.token = new tokenRepository_1.TokenRepository();
+        this.user = new userRepository_1.default(this);
+        this.loader = new securityLoader_1.default();
     }
     async init() {
-        await this.role.init();
-        await this.profile.init();
+        // `role.init()` and `profile.init()` are synchronous: they only register
+        // `onAsk` handlers.
+        this.role.init();
+        this.profile.init();
         await this.token.init();
         await this.user.init();
+        // Last: the loader replays security fixtures through the API, so every
+        // repository it writes through must already be up.
         await this.loader.init();
     }
 }