kuzzle 2.19.2 → 2.19.3

package/lib/core/plugin/privilegedContext.js

@@ -19,9 +19,9 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { PluginContext } = require('./pluginContext');
+const { PluginContext } = require("./pluginContext");
 
 /**
  * @class PrivilegedPluginContext
@@ -33,7 +33,7 @@ class PrivilegedPluginContext extends PluginContext {
    * @param {string} pluginName
    * @constructor
    */
-  constructor (pluginName) {
+  constructor(pluginName) {
     super(pluginName);
 
     this.accessors.kuzzle = global.kuzzle;

package/lib/core/realtime/actionEnum.js

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 /**
  * @typedef {number} notifyActionEnum

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

@@ -1,4 +1,4 @@
-import { RealtimeScope, RealtimeUsers } from '../../types';
+import { RealtimeScope, RealtimeUsers } from "../../types";
 /**
  * A channel define how notifications should be send for a particular realtime
  * room.

package/lib/core/realtime/channel.js

@@ -45,7 +45,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
 const kerror = __importStar(require("../../kerror"));
-const realtimeError = kerror.wrap('core', 'realtime');
+const realtimeError = kerror.wrap("core", "realtime");
 /**
  * A channel define how notifications should be send for a particular realtime
  * room.
@@ -68,15 +68,15 @@ const realtimeError = kerror.wrap('core', 'realtime');
  * @property cluster
  */
 class Channel {
-    constructor(roomId, { scope = 'all', users = 'none', propagate = true, } = {}) {
+    constructor(roomId, { scope = "all", users = "none", propagate = true, } = {}) {
         this.scope = scope;
         this.users = users;
         this.cluster = propagate;
         if (!Channel.SCOPE_ALLOWED_VALUES.includes(this.scope)) {
-            throw realtimeError.get('invalid_scope');
+            throw realtimeError.get("invalid_scope");
         }
         if (!Channel.USERS_ALLOWED_VALUES.includes(this.users)) {
-            throw realtimeError.get('invalid_users');
+            throw realtimeError.get("invalid_users");
         }
         this.name = `${roomId}-${Channel.hash(this)}`;
     }
@@ -86,44 +86,44 @@ class Channel {
      * This is 10x faster than murmur.
      */
     static hash(channel) {
-        let str = '';
+        let str = "";
         switch (channel.users) {
-            case 'all':
-                str += '1';
+            case "all":
+                str += "1";
                 break;
-            case 'in':
-                str += '2';
+            case "in":
+                str += "2";
                 break;
-            case 'out':
-                str += '3';
+            case "out":
+                str += "3";
                 break;
-            case 'none':
-                str += '3';
+            case "none":
+                str += "3";
                 break;
         }
         switch (channel.cluster) {
             case true:
-                str += '1';
+                str += "1";
                 break;
             case false:
-                str += '2';
+                str += "2";
                 break;
         }
         switch (channel.scope) {
-            case 'all':
-                str += '1';
+            case "all":
+                str += "1";
                 break;
-            case 'in':
-                str += '2';
+            case "in":
+                str += "2";
                 break;
-            case 'out':
-                str += '3';
+            case "out":
+                str += "3";
                 break;
         }
         return str;
     }
 }
 exports.Channel = Channel;
-Channel.USERS_ALLOWED_VALUES = ['all', 'in', 'out', 'none'];
+Channel.USERS_ALLOWED_VALUES = ["all", "in", "out", "none"];
 Channel.SCOPE_ALLOWED_VALUES = Channel.USERS_ALLOWED_VALUES;
 //# sourceMappingURL=channel.js.map

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

@@ -1,4 +1,4 @@
-import { JSONObject } from 'kuzzle-sdk';
+import { JSONObject } from "kuzzle-sdk";
 /**
  * Each connection can subscribe to many rooms with different sets of volatile
  * data.

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

@@ -1,5 +1,5 @@
-import { KuzzleRequest } from '../../api/request';
-import { User, RoomList } from '../../types';
+import { KuzzleRequest } from "../../api/request";
+import { User, RoomList } from "../../types";
 /**
  * The HotelClerk is responsible of keeping the list of rooms and subscriptions
  * made to those rooms.

package/lib/core/realtime/hotelClerk.js

@@ -56,8 +56,8 @@ const channel_1 = require("./channel");
 const connectionRooms_1 = require("./connectionRooms");
 const room_1 = require("./room");
 const subscription_1 = require("./subscription");
-const realtimeError = kerror.wrap('core', 'realtime');
-const debug = (0, debug_1.default)('kuzzle:realtime:hotelClerk');
+const realtimeError = kerror.wrap("core", "realtime");
+const debug = (0, debug_1.default)("kuzzle:realtime:hotelClerk");
 /**
  * The HotelClerk is responsible of keeping the list of rooms and subscriptions
  * made to those rooms.
@@ -114,13 +114,13 @@ class HotelClerk {
          * @param {string} roomId
          * @returns {boolean} status indicating if the room was created or not
          */
-        global.kuzzle.onAsk('core:realtime:room:create', (index, collection, roomId) => this.newRoom(index, collection, roomId));
+        global.kuzzle.onAsk("core:realtime:room:create", (index, collection, roomId) => this.newRoom(index, collection, roomId));
         /**
          * Joins an existing room.
          * @param  {Request} request
          * @returns {Promise}
          */
-        global.kuzzle.onAsk('core:realtime:join', request => this.join(request));
+        global.kuzzle.onAsk("core:realtime:join", (request) => this.join(request));
         /**
          * Return the list of index, collection, rooms (+ their users count)
          * on all index/collection pairs that the requesting user is allowed to
@@ -130,25 +130,25 @@ class HotelClerk {
          * @return {number}
          * @throws {NotFoundError} If the roomId does not exist
          */
-        global.kuzzle.onAsk('core:realtime:list', user => this.list(user));
+        global.kuzzle.onAsk("core:realtime:list", (user) => this.list(user));
         /**
          * Given an index, returns the list of collections having subscriptions
          * on them.
          * @param  {string} index
          * @return {Array.<string>}
          */
-        global.kuzzle.onAsk('core:realtime:collections:get', index => this.listCollections(index));
+        global.kuzzle.onAsk("core:realtime:collections:get", (index) => this.listCollections(index));
         /**
          * Removes a user and all their subscriptions.
          * @param  {string} connectionId
          */
-        global.kuzzle.onAsk('core:realtime:connection:remove', connectionId => this.removeConnection(connectionId));
+        global.kuzzle.onAsk("core:realtime:connection:remove", (connectionId) => this.removeConnection(connectionId));
         /**
          * Adds a new user subscription
          * @param  {Request} request
          * @return {Object|null}
          */
-        global.kuzzle.onAsk('core:realtime:subscribe', request => this.subscribe(request));
+        global.kuzzle.onAsk("core:realtime:subscribe", (request) => this.subscribe(request));
         /**
          * Unsubscribes a user from a room
          * @param {string} connectionId
@@ -156,24 +156,23 @@ class HotelClerk {
          * @param {string} kuid
          * @param {boolean} [notify]
          */
-        global.kuzzle.onAsk('core:realtime:unsubscribe', (connectionId, roomId, notify) => {
+        global.kuzzle.onAsk("core:realtime:unsubscribe", (connectionId, roomId, notify) => {
             return this.unsubscribe(connectionId, roomId, notify);
         });
         /**
          * Returns inner metrics from the HotelClerk
          * @return {{rooms: number, subscriptions: number}}
          */
-        global.kuzzle.onAsk('core:realtime:hotelClerk:metrics', () => this.metrics());
+        global.kuzzle.onAsk("core:realtime:hotelClerk:metrics", () => this.metrics());
         /**
          * Clear the hotel clerk and properly disconnect connections.
          */
-        global.kuzzle.on('kuzzle:shutdown', () => this.clearConnections());
+        global.kuzzle.on("kuzzle:shutdown", () => this.clearConnections());
         /**
          * Clear subscriptions when a connection is dropped
          */
-        global.kuzzle.on('connection:remove', connection => {
-            this.removeConnection(connection.id)
-                .catch(err => global.kuzzle.log.info(err));
+        global.kuzzle.on("connection:remove", (connection) => {
+            this.removeConnection(connection.id).catch((err) => global.kuzzle.log.info(err));
         });
     }
     /**
@@ -191,10 +190,10 @@ class HotelClerk {
     async subscribe(request) {
         const { index, collection } = request.input.resource;
         if (!index) {
-            return kerror.reject('api', 'assert', 'missing_argument', 'index');
+            return kerror.reject("api", "assert", "missing_argument", "index");
         }
         if (!collection) {
-            return kerror.reject('api', 'assert', 'missing_argument', 'collection');
+            return kerror.reject("api", "assert", "missing_argument", "collection");
         }
         /*
          * /!\ This check is a duplicate to the one already made by the
@@ -215,7 +214,7 @@ class HotelClerk {
             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.message);
         }
         this.createRoom(normalized);
         /**
@@ -235,10 +234,10 @@ class HotelClerk {
          */
         const afterSubscribeCallback = async (subscribed) => {
             if (subscribed) {
-                global.kuzzle.call('core:realtime:subscribe:after', normalized.id);
+                global.kuzzle.call("core:realtime:subscribe:after", normalized.id);
                 // @deprecated -- to be removed in next major version
                 // we have to recreate the old "diff" object
-                await global.kuzzle.pipe('core:hotelClerk:addSubscription', {
+                await global.kuzzle.pipe("core:hotelClerk:addSubscription", {
                     changed: subscribed,
                     collection,
                     connectionId: request.context.connection.id,
@@ -250,7 +249,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);
-        global.kuzzle.emit('core:realtime:user:subscribe:after', subscription);
+        global.kuzzle.emit("core:realtime:user:subscribe:after", subscription);
         return {
             channel,
             roomId: normalized.id,
@@ -271,9 +270,9 @@ class HotelClerk {
     async join(request) {
         const roomId = request.input.body.roomId;
         if (!this.rooms.has(roomId)) {
-            const normalized = await global.kuzzle.ask('cluster:realtime:filters:get', roomId);
+            const normalized = await global.kuzzle.ask("cluster:realtime:filters:get", roomId);
             if (!normalized) {
-                throw realtimeError.get('room_not_found', roomId);
+                throw realtimeError.get("room_not_found", roomId);
             }
             this.createRoom(normalized);
         }
@@ -294,7 +293,7 @@ class HotelClerk {
          */
         const afterSubscribeCallback = async (subscribed, cluster) => {
             if (cluster && subscribed) {
-                global.kuzzle.call('core:realtime:subscribe:after', roomId);
+                global.kuzzle.call("core:realtime:subscribe:after", roomId);
             }
         };
         const { channel } = await this.subscribeToRoom(roomId, request, afterSubscribeCallback);
@@ -312,14 +311,14 @@ class HotelClerk {
         // We need the room list from the cluster's full state, NOT the one stored
         // in Koncorde: the latter also contains subscriptions created by the
         // framework (or by plugins), and we don't want those to appear in the API
-        const fullStateRooms = await global.kuzzle.ask('cluster:realtime:room:list');
+        const fullStateRooms = await global.kuzzle.ask("cluster:realtime:room:list");
         const isAllowedRequest = new request_1.KuzzleRequest({
-            action: 'subscribe',
-            controller: 'realtime',
+            action: "subscribe",
+            controller: "realtime",
         }, {});
         for (const [index, collections] of Object.entries(fullStateRooms)) {
             isAllowedRequest.input.resource.index = index;
-            const toRemove = await bluebird_1.default.filter(Object.keys(collections), collection => {
+            const toRemove = await bluebird_1.default.filter(Object.keys(collections), (collection) => {
                 isAllowedRequest.input.resource.collection = collection;
                 return !user.isActionAllowed(isAllowedRequest);
             });
@@ -340,7 +339,7 @@ class HotelClerk {
             // No need to raise an error if the connection does not have room subscriptions
             return;
         }
-        await bluebird_1.default.map(connectionRooms.roomIds, (roomId) => (this.unsubscribe(connectionId, roomId, notify).catch(global.kuzzle.log.error)));
+        await bluebird_1.default.map(connectionRooms.roomIds, (roomId) => this.unsubscribe(connectionId, roomId, notify).catch(global.kuzzle.log.error));
     }
     /**
      * Clear all connections made to this node:
@@ -348,7 +347,7 @@ class HotelClerk {
      *   - send user exit room notifications
      */
     async clearConnections() {
-        await bluebird_1.default.map(this.subscriptions.keys(), (connectionId) => (this.removeConnection(connectionId, false)));
+        await bluebird_1.default.map(this.subscriptions.keys(), (connectionId) => this.removeConnection(connectionId, false));
     }
     /**
      * Register a new subscription
@@ -356,7 +355,7 @@ class HotelClerk {
      *  - add the connection to the list of active connections of the room
      */
     registerSubscription(connectionId, roomId, volatile) {
-        debug('Add room %s for connection %s', roomId, connectionId);
+        debug("Add room %s for connection %s", roomId, connectionId);
         let connectionRooms = this.subscriptions.get(connectionId);
         if (!connectionRooms) {
             connectionRooms = new connectionRooms_1.ConnectionRooms();
@@ -378,12 +377,12 @@ class HotelClerk {
         }
         const roomsLimit = global.kuzzle.config.limits.subscriptionRooms;
         if (roomsLimit > 0 && this.roomsCount >= roomsLimit) {
-            throw realtimeError.get('too_many_rooms');
+            throw realtimeError.get("too_many_rooms");
         }
         this.koncorde.store(normalized);
-        global.kuzzle.call('core:realtime:room:create:after', normalized);
+        global.kuzzle.call("core:realtime:room:create:after", normalized);
         // @deprecated -- to be removed in the next major version of kuzzle
-        global.kuzzle.emit('room:new', { collection, index, roomId });
+        global.kuzzle.emit("room:new", { collection, index, roomId });
         /*
           In some very rare cases, the room may have been created between
           the beginning of the function executed at the end of normalize,
@@ -405,14 +404,14 @@ class HotelClerk {
     async unsubscribe(connectionId, roomId, notify = true) {
         const connectionRooms = this.subscriptions.get(connectionId);
         const requestContext = new request_1.RequestContext({
-            connection: { id: connectionId }
+            connection: { id: connectionId },
         });
         if (!connectionRooms) {
-            throw realtimeError.get('not_subscribed', connectionId, roomId);
+            throw realtimeError.get("not_subscribed", connectionId, roomId);
         }
         const volatile = connectionRooms.getVolatile(roomId);
         if (volatile === undefined) {
-            throw realtimeError.get('not_subscribed', connectionId, roomId);
+            throw realtimeError.get("not_subscribed", connectionId, roomId);
         }
         if (connectionRooms.count > 1) {
             connectionRooms.removeRoom(roomId);
@@ -423,7 +422,7 @@ class HotelClerk {
         const room = this.rooms.get(roomId);
         if (!room) {
             global.kuzzle.log.error(`Cannot remove room "${roomId}": room not found`);
-            throw realtimeError.get('room_not_found', roomId);
+            throw realtimeError.get("room_not_found", roomId);
         }
         for (const channel of Object.keys(room.channels)) {
             global.kuzzle.entryPoint.leaveChannel(channel, connectionId);
@@ -441,21 +440,21 @@ class HotelClerk {
         // even if the room is deleted for this node, another one may need the
         // notification
         const request = new request_1.Request({
-            action: 'unsubscribe',
+            action: "unsubscribe",
             collection: room.collection,
-            controller: 'realtime',
+            controller: "realtime",
             index: room.index,
             volatile,
         }, requestContext);
         // Do not send an unsubscription notification if the room has been destroyed
         // because the other nodes already had destroyed it in the full state
-        if (notify
-            && this.rooms.has(roomId)
-            && room.channels.size > 0
-            && !roomDeleted) {
-            global.kuzzle.call('core:realtime:unsubscribe:after', roomId);
+        if (notify &&
+            this.rooms.has(roomId) &&
+            room.channels.size > 0 &&
+            !roomDeleted) {
+            global.kuzzle.call("core:realtime:unsubscribe:after", roomId);
             // @deprecated -- to be removed in next major version
-            await global.kuzzle.pipe('core:hotelClerk:removeRoomForCustomer', {
+            await global.kuzzle.pipe("core:hotelClerk:removeRoomForCustomer", {
                 requestContext,
                 room: {
                     collection: room.collection,
@@ -464,10 +463,12 @@ class HotelClerk {
                 },
             });
         }
-        await this.module.notifier.notifyUser(roomId, request, 'out', { count: room.size });
+        await this.module.notifier.notifyUser(roomId, request, "out", {
+            count: room.size,
+        });
         const kuid = global.kuzzle.tokenManager.getKuidFromConnection(connectionId);
         const subscription = new subscription_1.Subscription(room.index, room.collection, undefined, roomId, connectionId, { _id: kuid });
-        global.kuzzle.emit('core:realtime:user:unsubscribe:after', {
+        global.kuzzle.emit("core:realtime:user:unsubscribe:after", {
             /* @deprecated */
             requestContext,
             /* @deprecated */
@@ -499,10 +500,10 @@ class HotelClerk {
         // The cluster will also remove the room from Koncorde if no other node
         // uses it.
         // (this node may have no subscribers on it, but other nodes might)
-        await global.kuzzle.ask('cluster:realtime:room:remove', roomId);
+        await global.kuzzle.ask("cluster:realtime:room:remove", roomId);
         // @deprecated -- to be removed in the next major version
         try {
-            await global.kuzzle.pipe('room:remove', roomId);
+            await global.kuzzle.pipe("room:remove", roomId);
         }
         catch (e) {
             return;
@@ -526,7 +527,9 @@ class HotelClerk {
         if (!connectionRooms || !connectionRooms.hasRoom(roomId)) {
             subscribed = true;
             this.registerSubscription(connectionId, roomId, request.input.volatile);
-            notifyPromise = this.module.notifier.notifyUser(roomId, request, 'in', { count: room.size });
+            notifyPromise = this.module.notifier.notifyUser(roomId, request, "in", {
+                count: room.size,
+            });
         }
         else {
             notifyPromise = bluebird_1.default.resolve();

package/lib/core/realtime/index.js

@@ -19,18 +19,18 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Notifier = require('./notifier');
-const { HotelClerk } = require('./hotelClerk');
+const Notifier = require("./notifier");
+const { HotelClerk } = require("./hotelClerk");
 
 class RealtimeModule {
-  constructor () {
+  constructor() {
     this.notifier = new Notifier(this);
     this.hotelClerk = new HotelClerk(this);
   }
 
-  async init () {
+  async init() {
     await this.notifier.init();
     await this.hotelClerk.init();
   }

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

@@ -19,33 +19,33 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { InternalError } = require('../../../kerror/errors');
+const { InternalError } = require("../../../kerror/errors");
 
-function getEvent (action) {
+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 "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 "delete":
+    case "deleteByQuery":
+    case "mDelete":
+      return "delete";
 
-    case 'publish':
-      return 'publish';
+    case "publish":
+      return "publish";
 
     default:
       throw new InternalError(`Unknown event type for action "${action}"`);
@@ -57,8 +57,8 @@ function getEvent (action) {
  * @class DocumentNotification
  */
 class DocumentNotification {
-  constructor (opts) {
-    this.type = 'document';
+  constructor(opts) {
+    this.type = "document";
 
     this.status = opts.status;
     this.action = opts.action;
@@ -87,7 +87,7 @@ class DocumentNotification {
    * @param {result} content - Notification content
    * @returns {DocumentNotification}
    */
-  static fromRequest (request, scope, action, result) {
+  static fromRequest(request, scope, action, result) {
     return new DocumentNotification({
       action,
       collection: request.input.resource.collection,

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

@@ -19,10 +19,10 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 module.exports = {
-  DocumentNotification: require('./document'),
-  ServerNotification: require('./server'),
-  UserNotification: require('./user')
+  DocumentNotification: require("./document"),
+  ServerNotification: require("./server"),
+  UserNotification: require("./user"),
 };

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

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 /**
  * Creates a notification response from a given room, request object, and content.
@@ -30,9 +30,9 @@
  * @param {string} message - Notification message
  */
 class ServerNotification {
-  constructor (type, message) {
+  constructor(type, message) {
     this.status = 200;
-    this.info = 'This is an automated server notification';
+    this.info = "This is an automated server notification";
     this.message = message;
     this.type = type;
     this.node = global.kuzzle.id;

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

@@ -19,7 +19,7 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
 /**
  * User notification document
@@ -27,8 +27,8 @@
  * @class UserNotification
  */
 class UserNotification {
-  constructor (opts) {
-    this.type = 'user';
+  constructor(opts) {
+    this.type = "user";
 
     this.status = opts.status;
     this.user = opts.user;
@@ -50,7 +50,7 @@ class UserNotification {
    * @param {object} content - Notification content
    * returns {UserNotification}
    */
-  static fromRequest (request, user, result) {
+  static fromRequest(request, user, result) {
     return new UserNotification({
       action: request.input.action,
       collection: request.input.resource.collection,