kuzzle 2.49.1 → 2.50.0-beta.4

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

@@ -0,0 +1,14 @@
+export = PrivilegedPluginContext;
+/**
+ * @class PrivilegedPluginContext
+ * @extends PluginContext
+ */
+declare class PrivilegedPluginContext extends PluginContext {
+    /**
+     * @param {Kuzzle} kuzzle
+     * @param {string} pluginName
+     * @constructor
+     */
+    constructor(pluginName: string);
+}
+import { PluginContext } from "./pluginContext";

package/{lib → dist/lib}/core/plugin/privilegedContext.js

@@ -18,26 +18,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const { PluginContext } = require("./pluginContext");
-
 /**
  * @class PrivilegedPluginContext
  * @extends PluginContext
  */
 class PrivilegedPluginContext extends PluginContext {
-  /**
-   * @param {Kuzzle} kuzzle
-   * @param {string} pluginName
-   * @constructor
-   */
-  constructor(pluginName) {
-    super(pluginName);
-
-    this.accessors.kuzzle = global.kuzzle;
-  }
+    /**
+     * @param {Kuzzle} kuzzle
+     * @param {string} pluginName
+     * @constructor
+     */
+    constructor(pluginName) {
+        super(pluginName);
+        this.accessors.kuzzle = global.kuzzle;
+    }
 }
-
 module.exports = PrivilegedPluginContext;
+//# sourceMappingURL=privilegedContext.js.map

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

@@ -0,0 +1,25 @@
+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}
+ */
+declare const actionEnum: Readonly<{
+    CREATE: 1;
+    DELETE: 2;
+    REPLACE: 3;
+    UPDATE: 4;
+    UPSERT: 5;
+    WRITE: 6;
+}>;
+declare namespace actionEnum {
+    export { notifyActionEnum };
+}
+type notifyActionEnum = number;

package/{lib → dist/lib}/core/realtime/actionEnum.js

@@ -18,25 +18,22 @@
  * 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}
  */
 const actionEnum = Object.freeze({
-  CREATE: 1,
-  DELETE: 2,
-  REPLACE: 3,
-  UPDATE: 4,
-  UPSERT: 5,
-  WRITE: 6, // create or replace
+    CREATE: 1,
+    DELETE: 2,
+    REPLACE: 3,
+    UPDATE: 4,
+    UPSERT: 5,
+    WRITE: 6, // create or replace
 });
-
 module.exports = actionEnum;
+//# sourceMappingURL=actionEnum.js.map

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

@@ -0,0 +1,8 @@
+export = RealtimeModule;
+declare class RealtimeModule {
+    notifier: Notifier;
+    hotelClerk: HotelClerk;
+    init(): Promise<void>;
+}
+import Notifier = require("./notifier");
+import { HotelClerk } from "./hotelClerk";

package/{lib → dist/lib}/core/realtime/index.js

@@ -18,22 +18,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const Notifier = require("./notifier");
 const { HotelClerk } = require("./hotelClerk");
-
 class RealtimeModule {
-  constructor() {
-    this.notifier = new Notifier(this);
-    this.hotelClerk = new HotelClerk(this);
-  }
-
-  async init() {
-    await this.notifier.init();
-    await this.hotelClerk.init();
-  }
+    constructor() {
+        this.notifier = new Notifier(this);
+        this.hotelClerk = new HotelClerk(this);
+    }
+    async init() {
+        await this.notifier.init();
+        await this.hotelClerk.init();
+    }
 }
-
 module.exports = RealtimeModule;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,34 @@
+export = DocumentNotification;
+/**
+ * Document notification document
+ *
+ * @class DocumentNotification
+ */
+declare 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}
+     */
+    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;
+}

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

@@ -0,0 +1,98 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+const { InternalError } = require("../../../kerror/errors");
+function getEvent(action) {
+    switch (action) {
+        case "create":
+        case "mCreate":
+        case "createOrReplace":
+        case "mCreateOrReplace":
+        case "replace":
+        case "mReplace":
+        case "update":
+        case "updateByQuery":
+        case "mUpdate":
+        case "write":
+        case "mWrite":
+        case "upsert":
+            return "write";
+        case "delete":
+        case "deleteByQuery":
+        case "mDelete":
+            return "delete";
+        case "publish":
+            return "publish";
+        default:
+            throw new InternalError(`Unknown event type for action "${action}"`);
+    }
+}
+/**
+ * Document notification document
+ *
+ * @class DocumentNotification
+ */
+class DocumentNotification {
+    constructor(opts) {
+        this.type = "document";
+        this.status = opts.status;
+        this.action = opts.action;
+        this.scope = opts.scope;
+        this.result = opts.result;
+        this.node = opts.node;
+        this.event = getEvent(this.action);
+        this.requestId = opts.requestId;
+        this.timestamp = opts.timestamp;
+        this.volatile = opts.volatile;
+        this.index = opts.index;
+        this.collection = opts.collection;
+        this.controller = opts.controller;
+        this.protocol = opts.protocol;
+    }
+    /**
+     * 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}
+     */
+    static fromRequest(request, scope, action, result) {
+        return new DocumentNotification({
+            action,
+            collection: request.input.resource.collection,
+            controller: request.input.controller,
+            index: request.input.resource.index,
+            node: global.kuzzle.id,
+            protocol: request.context.connection.protocol,
+            requestId: request.id,
+            result,
+            scope,
+            status: 200,
+            timestamp: request.timestamp,
+            volatile: request.input.volatile,
+        });
+    }
+}
+module.exports = DocumentNotification;
+//# sourceMappingURL=document.js.map

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

@@ -0,0 +1,3 @@
+export let DocumentNotification: typeof import("./document");
+export let ServerNotification: typeof import("./server");
+export let UserNotification: typeof import("./user");

package/{lib → dist/lib}/core/realtime/notification/index.js

@@ -18,11 +18,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 module.exports = {
-  DocumentNotification: require("./document"),
-  ServerNotification: require("./server"),
-  UserNotification: require("./user"),
+    DocumentNotification: require("./document"),
+    ServerNotification: require("./server"),
+    UserNotification: require("./user"),
 };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,17 @@
+export = ServerNotification;
+/**
+ * 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
+ */
+declare class ServerNotification {
+    constructor(type: any, message: any);
+    status: number;
+    info: string;
+    message: any;
+    type: any;
+    node: string;
+}

package/{lib → dist/lib}/core/realtime/notification/server.js

@@ -18,9 +18,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 /**
  * Creates a notification response from a given room, request object, and content.
  *
@@ -30,13 +28,13 @@
  * @param {string} message - Notification message
  */
 class ServerNotification {
-  constructor(type, message) {
-    this.status = 200;
-    this.info = "This is an automated server notification";
-    this.message = message;
-    this.type = type;
-    this.node = global.kuzzle.id;
-  }
+    constructor(type, message) {
+        this.status = 200;
+        this.info = "This is an automated server notification";
+        this.message = message;
+        this.type = type;
+        this.node = global.kuzzle.id;
+    }
 }
-
 module.exports = ServerNotification;
+//# sourceMappingURL=server.js.map

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

@@ -0,0 +1,29 @@
+export = UserNotification;
+/**
+ * User notification document
+ *
+ * @class UserNotification
+ */
+declare 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}
+     */
+    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;
+}

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

@@ -0,0 +1,66 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+/**
+ * User notification document
+ *
+ * @class UserNotification
+ */
+class UserNotification {
+    constructor(opts) {
+        this.type = "user";
+        this.status = opts.status;
+        this.user = opts.user;
+        this.result = opts.result;
+        this.node = opts.node;
+        this.timestamp = opts.timestamp;
+        this.volatile = opts.volatile;
+        this.index = opts.index;
+        this.collection = opts.collection;
+        this.controller = opts.controller;
+        this.action = opts.action;
+        this.protocol = opts.protocol;
+    }
+    /**
+     * 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}
+     */
+    static fromRequest(request, user, result) {
+        return new UserNotification({
+            action: request.input.action,
+            collection: request.input.resource.collection,
+            controller: request.input.controller,
+            index: request.input.resource.index,
+            node: global.kuzzle.id,
+            protocol: request.context.connection.protocol,
+            result,
+            status: 200,
+            timestamp: request.timestamp,
+            user,
+            volatile: request.input.volatile,
+        });
+    }
+}
+module.exports = UserNotification;
+//# sourceMappingURL=user.js.map

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

@@ -0,0 +1,171 @@
+export = NotifierController;
+/**
+ * @typedef {Object} DocumentChanges
+ * @property {string}  _id              of the document
+ * @property {Object}  [_source]        of the document
+ * @property {Object}  [_updatedFields] applied to the document (for updates)
+ * @property {boolean} [created]        -- tells if this is a CREATE or REPLACE
+ *                                      (for actionEnum.WRITE)
+ */
+/**
+ * @class NotifierController
+ */
+declare class NotifierController {
+    constructor(realtimeModule: any);
+    module: any;
+    ttl: number;
+    logger: import("../../kuzzle/Logger").Logger;
+    init(): Promise<void>;
+    /**
+     * Broadcasts a notification about a document change or a
+     * real-time message
+     *
+     * @param {Array} rooms - Subscribed rooms to notify
+     * @param {Request} request - Request at the origin of the notification
+     * @param {string} scope - 'in' or 'out'
+     * @param {object} content - Document or message
+     *
+     * @returns {Promise}
+     */
+    notifyDocument(rooms: any[], request: Request, scope: string, action: any, content: object): Promise<any>;
+    /**
+     * Broadcast a notification about a user entering or leaving
+     * the provided room
+     *
+     * @param {string} room - Room entered or left
+     * @param {Request} request - User (un)subscription request
+     * @param {string} scope - 'in' or 'out'
+     * @param {object} content - Notification additional informations
+     *
+     * @returns {Promise}
+     */
+    notifyUser(room: string, request: Request, scope: string, content: object): Promise<any>;
+    /**
+     * Send a "token expired" notification to the target user
+     *
+     * @param {string} connectionId - User's connection identifier
+     * @returns {Promise}
+     */
+    notifyTokenExpired(connectionId: string): Promise<any>;
+    /**
+     * Publish the content of the provided request to listening subscribers
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    publish(request: Request): Promise<any>;
+    /**
+     * Notify about a created document
+     *
+     * @param {Request} request
+     * @param {DocumentChanges} document created
+     * @returns {Promise.<Array.<string>>} list of matched rooms
+     */
+    notifyDocumentCreate(request: Request, document: DocumentChanges): Promise<Array<string>>;
+    /**
+     * Notify about a replaced document
+     *
+     * @param {Request} request
+     * @param {DocumentChanges} document
+     * @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>>;
+    /**
+     * Computes document notifications and sends them to subscribed users.
+     * @param  {Request} request
+     * @param  {notifyActionEnum} action
+     * @param  {Array.<DocumentChanges>} documents
+     * @return {Promise}
+     */
+    notifyDocuments(request: Request, action: notifyActionEnum, documents: Array<DocumentChanges>): Promise<any>;
+    /**
+     * Notify rooms on a document update
+     * @param {Request} request
+     * @param {DocumentChanges} document
+     * @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>>;
+    /**
+     * Notify about a document deletion
+     *
+     * @param {Request} request
+     * @param {DocumentChanges} document
+     * @returns {Promise.<Array>} returns an empty array ("no room match anymore")
+     */
+    notifyDocumentDelete(request: Request, document: DocumentChanges): Promise<any[]>;
+    /**
+     * Trigger a notify global event and, if accepted by plugins,
+     * dispatch the payload to subscribers
+     *
+     * @param {Array} channels - Subscribers channels to notify
+     * @param {Notification.User|Notification.Document|Notification.Server} notification
+     * @param {string} [connectionId] - Notify this connection, or broadcast
+     *                                   if not provided
+     * @param {boolean} [trigger] - If set to true, triggers Kuzzle plugins
+     *
+     * @returns {Promise}
+     */
+    _dispatch(event: any, channels: any[], notification: Notification.User | Notification.Document | Notification.Server, connectionId?: string): Promise<any>;
+    /**
+     * Broadcasts a notification about a document change or a
+     * real-time message.
+     *
+     * When this method is called from the node who received
+     * the request triggering notification, then every channel is notified
+     * regardless of the "cluster" option.
+     *
+     * When this method is called from the cluster synchronization,
+     * then only the channels having the "cluster: true" option are notified
+     *
+     * @param {Array} rooms - Subscribed rooms to notify
+     * @param {DocumentNotification} notification
+     * @param {object} [options] - fromCluster (true)
+     *
+     * @returns {Promise}
+     */
+    _notifyDocument(rooms: any[], notification: typeof import("./notification/document"), { fromCluster }?: object): Promise<any>;
+    /**
+     * Broadcast a notification about a user entering or leaving
+     * the provided room
+     *
+     * @param {string} room - Room entered or left
+     * @param {UserNotification} notification
+     * @param {object} content - Notification additional informations
+     *
+     * @returns {Promise}
+     */
+    _notifyUser(room: string, notification: typeof import("./notification/user"), { fromCluster }?: object): Promise<any>;
+    /**
+     * DRYification for calls to Koncorde's test method from a Request object
+     * @param {Request} request
+     * @param {Object} source - document's source
+     * @param {String} id
+     *
+     * @returns {Array.<string>}
+     */
+    _test(request: Request, source?: any, id?: string): Array<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;
+};