kuzzle 2.19.2 → 2.19.3

package/lib/core/network/protocols/httpwsProtocol.js

@@ -19,28 +19,28 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const querystring = require('querystring');
-const url = require('url');
-const zlib = require('zlib');
+const querystring = require("querystring");
+const url = require("url");
+const zlib = require("zlib");
 
-const uWS = require('uWebSockets.js');
+const uWS = require("uWebSockets.js");
 
-const { HttpStream } = require('../../../types');
-const { Request } = require('../../../api/request');
-const { KuzzleError } = require('../../../kerror/errors');
-const Protocol = require('./protocol');
-const ClientConnection = require('../clientConnection');
-const { removeStacktrace } = require('../../../util/stackTrace');
-const debug = require('../../../util/debug');
-const kerror = require('../../../kerror');
-const HttpMessage = require('./httpMessage');
+const { HttpStream } = require("../../../types");
+const { Request } = require("../../../api/request");
+const { KuzzleError } = require("../../../kerror/errors");
+const Protocol = require("./protocol");
+const ClientConnection = require("../clientConnection");
+const { removeStacktrace } = require("../../../util/stackTrace");
+const debug = require("../../../util/debug");
+const kerror = require("../../../kerror");
+const HttpMessage = require("./httpMessage");
 
-const kerrorWS = kerror.wrap('network', 'websocket');
-const kerrorHTTP = kerror.wrap('network', 'http');
-const debugWS = debug('kuzzle:network:protocols:websocket');
-const debugHTTP = debug('kuzzle:network:protocols:http');
+const kerrorWS = kerror.wrap("network", "websocket");
+const kerrorHTTP = kerror.wrap("network", "http");
+const debugWS = debug("kuzzle:network:protocols:websocket");
+const debugHTTP = debug("kuzzle:network:protocols:http");
 
 // The idleTimeout option should never be deactivated, so instead we use
 // a default value for backward-compatibility
@@ -65,31 +65,35 @@ const JSON_ENDER = '"}';
 
 // Pre-computed messages & errors
 const WS_FORCED_TERMINATION_CODE = 1011;
-const WS_BACKPRESSURE_MESSAGE = Buffer.from('too much backpressure: client is too slow');
-const WS_GENERIC_CLOSE_MESSAGE = Buffer.from('Connection closed by remote host');
-const WS_RATE_LIMIT_EXCEEDED_ERROR = kerrorWS.get('ratelimit_exceeded');
-const HTTP_REQUEST_TOO_LARGE_ERROR = kerrorHTTP.get('request_too_large');
-const HTTP_FILE_TOO_LARGE_ERROR = kerrorHTTP.get('file_too_large');
+const WS_BACKPRESSURE_MESSAGE = Buffer.from(
+  "too much backpressure: client is too slow"
+);
+const WS_GENERIC_CLOSE_MESSAGE = Buffer.from(
+  "Connection closed by remote host"
+);
+const WS_RATE_LIMIT_EXCEEDED_ERROR = kerrorWS.get("ratelimit_exceeded");
+const HTTP_REQUEST_TOO_LARGE_ERROR = kerrorHTTP.get("request_too_large");
+const HTTP_FILE_TOO_LARGE_ERROR = kerrorHTTP.get("file_too_large");
 
 // HTTP-related constants
 const HTTP_ALLOWED_CONTENT_TYPES = [
-  'application/json',
-  'application/x-www-form-urlencoded',
-  'multipart/form-data',
+  "application/json",
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
 ];
-const HTTP_SKIPPED_HEADERS = [
-  'content-length',
-];
-const HTTP_HEADER_CONNECTION = Buffer.from('Connection');
-const HTTP_HEADER_CONTENT_LENGTH = Buffer.from('Content-Length');
-const HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN = Buffer.from('Access-Control-Allow-Origin');
-const HTTP_HEADER_VARY = Buffer.from('Vary');
-const HTTP_HEADER_TRANSFER_ENCODING = Buffer.from('Transfer-Encoding');
-const CHUNKED = Buffer.from('chunked');
-const WILDCARD = Buffer.from('*');
-const ORIGIN = Buffer.from('Origin');
-const X_KUZZLE_REQUEST_ID = Buffer.from('X-Kuzzle-Request-Id');
-const CLOSE = Buffer.from('close');
+const HTTP_SKIPPED_HEADERS = ["content-length"];
+const HTTP_HEADER_CONNECTION = Buffer.from("Connection");
+const HTTP_HEADER_CONTENT_LENGTH = Buffer.from("Content-Length");
+const HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN = Buffer.from(
+  "Access-Control-Allow-Origin"
+);
+const HTTP_HEADER_VARY = Buffer.from("Vary");
+const HTTP_HEADER_TRANSFER_ENCODING = Buffer.from("Transfer-Encoding");
+const CHUNKED = Buffer.from("chunked");
+const WILDCARD = Buffer.from("*");
+const ORIGIN = Buffer.from("Origin");
+const X_KUZZLE_REQUEST_ID = Buffer.from("X-Kuzzle-Request-Id");
+const CLOSE = Buffer.from("close");
 const CHARSET_REGEX = /charset=([\w-]+)/i;
 
 /**
@@ -97,8 +101,8 @@ const CHARSET_REGEX = /charset=([\w-]+)/i;
  * Handles both HTTP and WebSocket connections
  */
 class HttpWsProtocol extends Protocol {
-  constructor () {
-    super('websocket');
+  constructor() {
+    super("websocket");
 
     this.server = null;
     this.wsConfig = null;
@@ -120,7 +124,7 @@ class HttpWsProtocol extends Protocol {
     this.socketByConnectionId = new Map();
   }
 
-  async init (entrypoint) {
+  async init(entrypoint) {
     super.init(null, entrypoint);
 
     this.config = entrypoint.config.protocols;
@@ -128,7 +132,7 @@ class HttpWsProtocol extends Protocol {
     this.wsConfig = this.parseWebSocketOptions();
     this.httpConfig = this.parseHttpOptions();
 
-    if (! this.wsConfig.enabled && ! this.httpConfig.enabled) {
+    if (!this.wsConfig.enabled && !this.httpConfig.enabled) {
       return false;
     }
 
@@ -143,18 +147,20 @@ class HttpWsProtocol extends Protocol {
       this.initHttp();
     }
 
-    this.server.listen(entrypoint.config.port, socket => {
-      if (! socket) {
-        throw new Error(`[http/websocket] fatal: unable to listen to port ${entrypoint.config.port}`);
+    this.server.listen(entrypoint.config.port, (socket) => {
+      if (!socket) {
+        throw new Error(
+          `[http/websocket] fatal: unable to listen to port ${entrypoint.config.port}`
+        );
       }
     });
 
     return true;
   }
 
-  initWebSocket () {
+  initWebSocket() {
     /* eslint-disable sort-keys */
-    this.server.ws('/*', {
+    this.server.ws("/*", {
       ...this.wsConfig.opts,
       maxBackPressure: WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE,
       upgrade: this.wsOnUpgradeHandler.bind(this),
@@ -166,11 +172,11 @@ class HttpWsProtocol extends Protocol {
     /* eslint-enable sort-keys */
   }
 
-  initHttp () {
-    this.server.any('/*', this.httpOnMessageHandler.bind(this));
+  initHttp() {
+    this.server.any("/*", this.httpOnMessageHandler.bind(this));
   }
 
-  broadcast (data) {
+  broadcast(data) {
     const stringified = JSON.stringify(data.payload);
     const payloadByteSize = Buffer.from(stringified).byteLength;
     // 255 bytes should be enough to hold the following:
@@ -197,16 +203,20 @@ class HttpWsProtocol extends Protocol {
 
       payload.copy(payloadSafeCopy, 0, 0, payloadLength);
 
-      debugWS('Publishing to channel "realtime/%s": %s', channel, payloadSafeCopy);
+      debugWS(
+        'Publishing to channel "realtime/%s": %s',
+        channel,
+        payloadSafeCopy
+      );
       this.server.publish(`realtime/${channel}`, payloadSafeCopy, false);
     }
   }
 
-  notify (data) {
+  notify(data) {
     const socket = this.socketByConnectionId.get(data.connectionId);
-    debugWS('notify: %a', data);
+    debugWS("notify: %a", data);
 
-    if (! socket) {
+    if (!socket) {
       return;
     }
 
@@ -218,44 +228,53 @@ class HttpWsProtocol extends Protocol {
     }
   }
 
-  joinChannel (channel, connectionId) {
+  joinChannel(channel, connectionId) {
     const socket = this.socketByConnectionId.get(connectionId);
 
-    if (! socket) {
+    if (!socket) {
       return;
     }
 
-    debugWS('Subscribing connection ID "%s" to channel "realtime/%s"', connectionId, channel);
+    debugWS(
+      'Subscribing connection ID "%s" to channel "realtime/%s"',
+      connectionId,
+      channel
+    );
     socket.subscribe(`realtime/${channel}`);
   }
 
-  leaveChannel (channel, connectionId) {
+  leaveChannel(channel, connectionId) {
     const socket = this.socketByConnectionId.get(connectionId);
 
-    if (! socket) {
+    if (!socket) {
       return;
     }
 
-    debugWS('Removing connection ID "%s" from channel "realtime/%s"', connectionId, channel);
+    debugWS(
+      'Removing connection ID "%s" from channel "realtime/%s"',
+      connectionId,
+      channel
+    );
 
     socket.unsubscribe(`realtime/${channel}`);
   }
 
-  disconnect (connectionId, message = null) {
-    debugWS('[%s] forced disconnect', connectionId);
+  disconnect(connectionId, message = null) {
+    debugWS("[%s] forced disconnect", connectionId);
 
     const socket = this.socketByConnectionId.get(connectionId);
 
-    if (! socket) {
+    if (!socket) {
       return;
     }
 
     socket.end(
       WS_FORCED_TERMINATION_CODE,
-      message ? Buffer.from(message) : WS_GENERIC_CLOSE_MESSAGE);
+      message ? Buffer.from(message) : WS_GENERIC_CLOSE_MESSAGE
+    );
   }
 
-  wsOnUpgradeHandler (res, req, context) {
+  wsOnUpgradeHandler(res, req, context) {
     const headers = {};
     // Extract headers from uWS request
     req.forEach((header, value) => {
@@ -266,20 +285,16 @@ class HttpWsProtocol extends Protocol {
       {
         headers,
       },
-      req.getHeader('sec-websocket-key'),
-      req.getHeader('sec-websocket-protocol'),
-      req.getHeader('sec-websocket-extensions'),
+      req.getHeader("sec-websocket-key"),
+      req.getHeader("sec-websocket-protocol"),
+      req.getHeader("sec-websocket-extensions"),
       context
     );
   }
 
-  wsOnOpenHandler (socket) {
+  wsOnOpenHandler(socket) {
     const ip = Buffer.from(socket.getRemoteAddressAsText()).toString();
-    const connection = new ClientConnection(
-      this.name,
-      [ip],
-      socket.headers
-    );
+    const connection = new ClientConnection(this.name, [ip], socket.headers);
 
     this.entryPoint.newConnection(connection);
     this.connectionBySocket.set(socket, connection);
@@ -287,19 +302,20 @@ class HttpWsProtocol extends Protocol {
     this.backpressureBuffer.set(socket, []);
   }
 
-  wsOnCloseHandler (socket, code, message) {
+  wsOnCloseHandler(socket, code, message) {
     const connection = this.connectionBySocket.get(socket);
 
-    if (! connection) {
+    if (!connection) {
       return;
     }
 
     if (debugWS.enabled) {
       debugWS(
-        '[%s] received a `close` event (CODE: %d, REASON: %s)',
+        "[%s] received a `close` event (CODE: %d, REASON: %s)",
         connection.id,
         code,
-        Buffer.from(message || '').toString());
+        Buffer.from(message || "").toString()
+      );
     }
     this.entryPoint.removeConnection(connection.id);
     this.connectionBySocket.delete(socket);
@@ -307,8 +323,8 @@ class HttpWsProtocol extends Protocol {
     this.socketByConnectionId.delete(connection.id);
   }
 
-  wsOnMessageHandler (socket, data) {
-    if (! data || data.byteLength === 0) {
+  wsOnMessageHandler(socket, data) {
+    if (!data || data.byteLength === 0) {
       return;
     }
 
@@ -323,8 +339,7 @@ class HttpWsProtocol extends Protocol {
           this.wsSendError(socket, connection, WS_RATE_LIMIT_EXCEEDED_ERROR);
           return;
         }
-      }
-      else {
+      } else {
         socket.last = this.now;
         socket.count = 1;
       }
@@ -333,12 +348,11 @@ class HttpWsProtocol extends Protocol {
     let parsed;
     const message = Buffer.from(data).toString();
 
-    debugWS('[%s] client message: %s', connection.id, message);
+    debugWS("[%s] client message: %s", connection.id, message);
 
     try {
       parsed = JSON.parse(message);
-    }
-    catch (e) {
+    } catch (e) {
       /*
        we cannot add a "room" information since we need to extract
        a request ID from the incoming data, which is apparently
@@ -349,7 +363,8 @@ class HttpWsProtocol extends Protocol {
       this.wsSendError(
         socket,
         connection,
-        kerrorWS.getFrom(e, 'unexpected_error', e.message));
+        kerrorWS.getFrom(e, "unexpected_error", e.message)
+      );
       return;
     }
 
@@ -363,20 +378,18 @@ class HttpWsProtocol extends Protocol {
 
     try {
       request = new Request(parsed, { connection });
-    }
-    catch (e) {
+    } catch (e) {
       this.wsSendError(socket, connection, e, parsed.requestId);
       return;
     }
 
-    this.entryPoint.execute(connection, request, result => {
+    this.entryPoint.execute(connection, request, (result) => {
       if (result.content) {
-        if (typeof result.content === 'object') {
+        if (typeof result.content === "object") {
           result.content.room = result.requestId;
         }
-      }
-      else {
-        result.content = '';
+      } else {
+        result.content = "";
       }
 
       this.wsSend(socket, Buffer.from(JSON.stringify(result.content)));
@@ -387,12 +400,13 @@ class HttpWsProtocol extends Protocol {
    * Absorb as much of the backpressure buffer as possible
    * @param  {uWS.WebSocket} socket
    */
-  wsOnDrainHandler (socket) {
+  wsOnDrainHandler(socket) {
     socket.cork(() => {
       const buffer = this.backpressureBuffer.get(socket);
 
-      while (buffer.length > 0
-        && socket.getBufferedAmount() < WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE
+      while (
+        buffer.length > 0 &&
+        socket.getBufferedAmount() < WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE
       ) {
         const payload = buffer.shift();
         socket.send(payload);
@@ -408,7 +422,7 @@ class HttpWsProtocol extends Protocol {
    * @param  {Error} error
    * @param  {String} requestId @optional
    */
-  wsSendError (socket, connection, error, requestId) {
+  wsSendError(socket, connection, error, requestId) {
     const request = new Request({}, { connection, error });
 
     // If a requestId is provided we use it instead of the generated one
@@ -426,15 +440,14 @@ class HttpWsProtocol extends Protocol {
    * @param  {uWS.WebSocket} socket
    * @param  {Buffer} payload
    */
-  wsSend (socket, payload) {
-    if (! this.connectionBySocket.has(socket)) {
+  wsSend(socket, payload) {
+    if (!this.connectionBySocket.has(socket)) {
       return;
     }
 
     if (socket.getBufferedAmount() < WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE) {
       socket.cork(() => socket.send(payload));
-    }
-    else {
+    } else {
       const buffer = this.backpressureBuffer.get(socket);
       buffer.push(payload);
 
@@ -449,43 +462,49 @@ class HttpWsProtocol extends Protocol {
    * @param  {uWS.HttpResponse} response
    * @param  {uWS.HttpRequest} request
    */
-  httpOnMessageHandler (response, request) {
+  httpOnMessageHandler(response, request) {
     const connection = new ClientConnection(
-      'HTTP/1.1',
+      "HTTP/1.1",
       getHttpIps(response, request),
-      request.headers);
+      request.headers
+    );
     const message = new HttpMessage(connection, request);
 
-    debugHTTP('[%s] Received HTTP request: %a', connection.id, message);
+    debugHTTP("[%s] Received HTTP request: %a", connection.id, message);
 
-    if (message.headers['content-length'] > this.maxRequestSize) {
+    if (message.headers["content-length"] > this.maxRequestSize) {
       this.httpSendError(message, response, HTTP_REQUEST_TOO_LARGE_ERROR);
       return;
     }
 
-    const contentType = message.headers['content-type'];
+    const contentType = message.headers["content-type"];
 
-    if ( contentType
-      && ! HTTP_ALLOWED_CONTENT_TYPES.some(allowed => contentType.includes(allowed))
+    if (
+      contentType &&
+      !HTTP_ALLOWED_CONTENT_TYPES.some((allowed) =>
+        contentType.includes(allowed)
+      )
     ) {
       this.httpSendError(
         message,
         response,
-        kerrorHTTP.get('unsupported_content', contentType));
+        kerrorHTTP.get("unsupported_content", contentType)
+      );
       return;
     }
 
     const encoding = CHARSET_REGEX.exec(contentType);
 
-    if (encoding !== null && encoding[1].toLowerCase() !== 'utf-8') {
+    if (encoding !== null && encoding[1].toLowerCase() !== "utf-8") {
       this.httpSendError(
         message,
         response,
-        kerrorHTTP.get('unsupported_charset', encoding[1].toLowerCase()));
+        kerrorHTTP.get("unsupported_charset", encoding[1].toLowerCase())
+      );
       return;
     }
 
-    this.httpReadData(message, response, err => {
+    this.httpReadData(message, response, (err) => {
       if (err) {
         this.httpSendError(message, response, err);
         return;
@@ -502,7 +521,7 @@ class HttpWsProtocol extends Protocol {
    * @param  {uWS.HttpResponse} response
    * @param  {Function} cb
    */
-  httpReadData (message, response, cb) {
+  httpReadData(message, response, cb) {
     let payload = null;
     response.aborted = false;
 
@@ -523,7 +542,7 @@ class HttpWsProtocol extends Protocol {
         return;
       }
 
-      if (! isLast) {
+      if (!isLast) {
         return;
       }
 
@@ -549,14 +568,14 @@ class HttpWsProtocol extends Protocol {
     });
   }
 
-  httpParseContent (message, content, cb) {
-    const type = message.headers['content-type'] || '';
+  httpParseContent(message, content, cb) {
+    const type = message.headers["content-type"] || "";
 
-    if (type.includes('multipart/form-data')) {
-      const parts = uWS.getParts(content, message.headers['content-type']);
+    if (type.includes("multipart/form-data")) {
+      const parts = uWS.getParts(content, message.headers["content-type"]);
       message.content = {};
-      
-      if (! parts) {
+
+      if (!parts) {
         cb();
         return;
       }
@@ -570,24 +589,22 @@ class HttpWsProtocol extends Protocol {
         if (part.filename) {
           message.content[part.name] = {
             encoding: part.type,
-            file: Buffer.from(part.data).toString('base64'),
+            file: Buffer.from(part.data).toString("base64"),
             filename: part.filename,
           };
-        }
-        else {
+        } else {
           message.content[part.name] = Buffer.from(part.data).toString();
         }
       }
-    }
-    else if (type.includes('application/x-www-form-urlencoded')) {
+    } else if (type.includes("application/x-www-form-urlencoded")) {
       message.content = querystring.parse(content.toString());
-    }
-    else {
+    } else {
       try {
         message.content = JSON.parse(content.toString());
-      }
-      catch (e) {
-        cb(kerrorHTTP.get('body_parse_failed', content.toString().slice(0, 50)));
+      } catch (e) {
+        cb(
+          kerrorHTTP.get("body_parse_failed", content.toString().slice(0, 50))
+        );
         return;
       }
     }
@@ -595,8 +612,8 @@ class HttpWsProtocol extends Protocol {
     cb();
   }
 
-  httpProcessRequest (response, message) {
-    debugHTTP('[%s] httpProcessRequest: %a', message.connection.id, message);
+  httpProcessRequest(response, message) {
+    debugHTTP("[%s] httpProcessRequest: %a", message.connection.id, message);
 
     if (response.aborted) {
       return;
@@ -604,7 +621,7 @@ class HttpWsProtocol extends Protocol {
 
     this.entryPoint.newConnection(message.connection);
 
-    global.kuzzle.router.http.route(message, request => {
+    global.kuzzle.router.http.route(message, (request) => {
       this.entryPoint.logAccess(message.connection, request, message);
       this.entryPoint.removeConnection(message.connection.id);
 
@@ -621,26 +638,28 @@ class HttpWsProtocol extends Protocol {
 
       const data = this.httpRequestToResponse(request, message);
 
-      this.httpCompress(message, data, result => {
+      this.httpCompress(message, data, (result) => {
         if (response.aborted) {
           return;
         }
 
-        request.response.setHeader('Content-Encoding', result.encoding);
+        request.response.setHeader("Content-Encoding", result.encoding);
 
         response.cork(() => {
           this.httpWriteRequestHeaders(request, response, message);
 
-          const [ success ] = response.tryEnd(
+          const [success] = response.tryEnd(
             result.compressed,
-            result.compressed.length);
+            result.compressed.length
+          );
 
-          if (! success) {
-            response.onWritable(offset => {
+          if (!success) {
+            response.onWritable((offset) => {
               const retryData = result.compressed.subarray(offset);
-              const [ retrySuccess ] = response.tryEnd(
+              const [retrySuccess] = response.tryEnd(
                 retryData,
-                retryData.length);
+                retryData.length
+              );
 
               return retrySuccess;
             });
@@ -656,7 +675,7 @@ class HttpWsProtocol extends Protocol {
    * @param {uWS.HttpResponse} response
    * @param {HttpMessage} message
    */
-  httpWriteRequestHeaders (request, response, message) {
+  httpWriteRequestHeaders(request, response, message) {
     response.writeStatus(Buffer.from(request.response.status.toString()));
 
     response.writeHeader(HTTP_HEADER_CONNECTION, CLOSE);
@@ -670,13 +689,15 @@ class HttpWsProtocol extends Protocol {
     }
 
     // Access-Control-Allow-Origin Logic
-    if ( request.response.headers['Access-Control-Allow-Origin'] === undefined
-      && message.headers
-      && message.headers.origin
+    if (
+      request.response.headers["Access-Control-Allow-Origin"] === undefined &&
+      message.headers &&
+      message.headers.origin
     ) {
       response.writeHeader(
         HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-        Buffer.from(message.headers.origin));
+        Buffer.from(message.headers.origin)
+      );
 
       response.writeHeader(HTTP_HEADER_VARY, ORIGIN);
     }
@@ -698,14 +719,20 @@ class HttpWsProtocol extends Protocol {
    * @param {uWS.HttpResponse} response
    * @param {HttpMessage} message
    */
-  httpSendStream (request, response, httpStream, message) {
-    const streamSizeFixed = typeof httpStream.totalBytes === 'number' && httpStream.totalBytes > 0;
+  httpSendStream(request, response, httpStream, message) {
+    const streamSizeFixed =
+      typeof httpStream.totalBytes === "number" && httpStream.totalBytes > 0;
 
     if (httpStream.errored) {
       this.httpSendError(
         message,
         response,
-        kerror.get('network', 'http', 'stream_errored', httpStream.error.message)
+        kerror.get(
+          "network",
+          "http",
+          "stream_errored",
+          httpStream.error.message
+        )
       );
       return;
     }
@@ -714,29 +741,34 @@ class HttpWsProtocol extends Protocol {
       this.httpSendError(
         message,
         response,
-        kerror.get('network', 'http', 'stream_closed')
+        kerror.get("network", "http", "stream_closed")
       );
       return;
     }
 
     // Remove Content-Length header to avoid conflic with Transfer-Encoding header
-    request.response.setHeader('Content-Length', null);
+    request.response.setHeader("Content-Length", null);
 
     // Send Headers in one go
     response.cork(() => {
       this.httpWriteRequestHeaders(request, response, message);
 
       if (streamSizeFixed) {
-        response.writeHeader(HTTP_HEADER_CONTENT_LENGTH, Buffer.from(httpStream.totalBytes.toString()));
-      }
-      else {
+        response.writeHeader(
+          HTTP_HEADER_CONTENT_LENGTH,
+          Buffer.from(httpStream.totalBytes.toString())
+        );
+      } else {
         response.writeHeader(HTTP_HEADER_TRANSFER_ENCODING, CHUNKED);
       }
     });
 
-    httpStream.stream.on('data', chunk => {
+    httpStream.stream.on("data", (chunk) => {
       // Make a copy of the array buffer
-      const arrayBuffer = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+      const arrayBuffer = chunk.buffer.slice(
+        chunk.byteOffset,
+        chunk.byteOffset + chunk.byteLength
+      );
 
       const arrayBufferOffset = response.getWriteOffset();
 
@@ -748,18 +780,20 @@ class HttpWsProtocol extends Protocol {
        * If the stream has a fixed size we can use the tryEnd method
        */
       if (streamSizeFixed) {
-        const [ success, done ] = response.tryEnd(arrayBuffer, httpStream.totalBytes);
-        backpressure = ! success;
+        const [success, done] = response.tryEnd(
+          arrayBuffer,
+          httpStream.totalBytes
+        );
+        backpressure = !success;
 
         if (done) {
           httpStream.destroy();
           return;
         }
-      }
-      else {
+      } else {
         const success = response.write(arrayBuffer);
 
-        backpressure = ! success;
+        backpressure = !success;
       }
 
       // In case of backpressure we need to wait for drainage before sending more data
@@ -772,59 +806,66 @@ class HttpWsProtocol extends Protocol {
          * When the stream is drained we can resume sending data,
          * only if the is no backpressure after we wrote the missing chunk data.
          */
-        response.onWritable(offset => {
-          if (! streamSizeFixed && offset - response.arrayBufferOffset === 0) {
+        response.onWritable((offset) => {
+          if (!streamSizeFixed && offset - response.arrayBufferOffset === 0) {
             httpStream.stream.resume();
             return true;
           }
 
           let retryBackpressure = false;
-          const remainingChunkData = response.arrayBuffer.slice(offset - response.arrayBufferOffset);
+          const remainingChunkData = response.arrayBuffer.slice(
+            offset - response.arrayBufferOffset
+          );
 
           if (streamSizeFixed) {
-            const [ success ] = response.tryEnd(remainingChunkData, httpStream.totalBytes);
+            const [success] = response.tryEnd(
+              remainingChunkData,
+              httpStream.totalBytes
+            );
 
-            retryBackpressure = ! success;
-          }
-          else {
+            retryBackpressure = !success;
+          } else {
             const success = response.write(remainingChunkData);
 
-            retryBackpressure = ! success;
+            retryBackpressure = !success;
           }
 
-          if (! retryBackpressure) {
+          if (!retryBackpressure) {
             httpStream.stream.resume();
           }
 
-          return ! retryBackpressure;
+          return !retryBackpressure;
         });
       }
     });
 
-    httpStream.stream.on('end', () => {
+    httpStream.stream.on("end", () => {
       if (httpStream.destroy()) {
         response.end();
       }
     });
 
-    httpStream.stream.on('close', () => {
+    httpStream.stream.on("close", () => {
       if (httpStream.destroy()) {
         response.end();
       }
     });
 
-    httpStream.stream.on('error', err => {
+    httpStream.stream.on("error", (err) => {
       if (httpStream.destroy()) {
         response.end();
       }
 
-      debugHTTP('[%s] httpSendStream: %s', httpStream.connection.id, err.message);
+      debugHTTP(
+        "[%s] httpSendStream: %s",
+        httpStream.connection.id,
+        err.message
+      );
     });
 
     response.onAborted(() => {
       httpStream.destroy();
     });
-
   }
 
   /**
@@ -834,14 +875,15 @@ class HttpWsProtocol extends Protocol {
    * @param {uWS.HttpResponse} response
    * @param {Error} error
    */
-  httpSendError (message, response, error) {
-    const kerr = error instanceof KuzzleError
-      ? error
-      : kerrorHTTP.getFrom(error, 'unexpected_error', error.message);
+  httpSendError(message, response, error) {
+    const kerr =
+      error instanceof KuzzleError
+        ? error
+        : kerrorHTTP.getFrom(error, "unexpected_error", error.message);
 
     const content = Buffer.from(JSON.stringify(removeStacktrace(kerr)));
 
-    debugHTTP('[%s] httpSendError: %a', message.connection.id, kerr);
+    debugHTTP("[%s] httpSendError: %a", message.connection.id, kerr);
 
     this.entryPoint.logAccess(
       message.connection,
@@ -849,7 +891,8 @@ class HttpWsProtocol extends Protocol {
         connectionId: message.connection.id,
         error: kerr,
       }),
-      message);
+      message
+    );
     this.entryPoint.removeConnection(message.connection.id);
 
     if (response.aborted) {
@@ -866,10 +909,15 @@ class HttpWsProtocol extends Protocol {
       // Access-Control-Allow-Origin Logic
       if (message.headers && message.headers.origin) {
         if (global.kuzzle.config.internal.allowAllOrigins) {
-          response.writeHeader(HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN, WILDCARD);
-        }
-        else {
-          response.writeHeader(HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN, Buffer.from(message.headers.origin));
+          response.writeHeader(
+            HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+            WILDCARD
+          );
+        } else {
+          response.writeHeader(
+            HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+            Buffer.from(message.headers.origin)
+          );
           response.writeHeader(HTTP_HEADER_VARY, ORIGIN);
         }
       }
@@ -886,45 +934,42 @@ class HttpWsProtocol extends Protocol {
    * @param {HttpMessage} message
    * @returns {Buffer}
    */
-  httpRequestToResponse (request, message) {
+  httpRequestToResponse(request, message) {
     let data = removeStacktrace(request.response.toJSON());
 
     if (message.requestId !== data.requestId) {
       data.requestId = message.requestId;
 
-      if (! data.raw) {
+      if (!data.raw) {
         data.content.requestId = message.requestId;
       }
     }
 
-    debugHTTP('HTTP request response: %a', data);
+    debugHTTP("HTTP request response: %a", data);
 
     if (data.raw) {
       if (data.content === null || data.content === undefined) {
-        data = '';
-      }
-      else if (typeof data.content === 'object') {
+        data = "";
+      } else if (typeof data.content === "object") {
         /*
          This object can be either a Buffer object, a stringified Buffer object,
          or anything else.
          In the former two cases, we create a new Buffer object, and in the
          latter, we stringify t he content.
          */
-        if ( data.content instanceof Buffer
-          || (data.content.type === 'Buffer' && Array.isArray(data.content.data))
+        if (
+          data.content instanceof Buffer ||
+          (data.content.type === "Buffer" && Array.isArray(data.content.data))
         ) {
           data = data.content;
-        }
-        else {
+        } else {
           data = JSON.stringify(data.content);
         }
-      }
-      else {
+      } else {
         // scalars are sent as strings
         data = data.content.toString();
       }
-    }
-    else {
+    } else {
       let indent = 0;
       const parsedUrl = url.parse(message.url, true);
 
@@ -946,66 +991,70 @@ class HttpWsProtocol extends Protocol {
    * @param  {Buffer} data
    * @param  {Function} callback
    */
-  httpCompress (message, data, callback) {
-    if (message.headers['accept-encoding']) {
-      const encodings = message.headers['accept-encoding']
-        .split(',')
-        .map(e => e.trim().toLowerCase());
+  httpCompress(message, data, callback) {
+    if (message.headers["accept-encoding"]) {
+      const encodings = message.headers["accept-encoding"]
+        .split(",")
+        .map((e) => e.trim().toLowerCase());
 
       let algorithm;
       let priority = -1;
 
       for (const encoding of encodings) {
-        if (encoding.startsWith('gzip') || encoding.startsWith('deflate')) {
-          let [ _algorithm, _priority = 'q=0' ] = encoding.split(';');
-          _priority = Number.parseFloat(_priority.split('=')[1] || 0);
+        if (encoding.startsWith("gzip") || encoding.startsWith("deflate")) {
+          let [_algorithm, _priority = "q=0"] = encoding.split(";");
+          _priority = Number.parseFloat(_priority.split("=")[1] || 0);
 
           if (_priority > priority) {
             algorithm = _algorithm;
             priority = _priority;
           }
           // gzip should be the preferred algorithm in case of a tie
-          else if (Math.abs(priority - _priority) < 10e-3
-            && _algorithm === 'gzip'
+          else if (
+            Math.abs(priority - _priority) < 10e-3 &&
+            _algorithm === "gzip"
           ) {
-            algorithm = 'gzip';
+            algorithm = "gzip";
           }
         }
       }
 
-      if (algorithm === 'gzip') {
-        zlib.gzip(data, (err, compressed) => callback({
-          compressed: ! err ? compressed : data,
-          encoding: ! err ? 'gzip' : 'identity',
-        }));
+      if (algorithm === "gzip") {
+        zlib.gzip(data, (err, compressed) =>
+          callback({
+            compressed: !err ? compressed : data,
+            encoding: !err ? "gzip" : "identity",
+          })
+        );
         return;
-      }
-      else if (algorithm === 'deflate') {
-        zlib.deflate(data, (err, compressed) => callback({
-          compressed: ! err ? compressed : data,
-          encoding: ! err ? 'deflate' : 'identity',
-        }));
+      } else if (algorithm === "deflate") {
+        zlib.deflate(data, (err, compressed) =>
+          callback({
+            compressed: !err ? compressed : data,
+            encoding: !err ? "deflate" : "identity",
+          })
+        );
         return;
       }
     }
 
     callback({
       compressed: data,
-      encoding: 'identity',
+      encoding: "identity",
     });
   }
 
-  httpUncompress (message, payload, cb) {
-    let encodings = message.headers['content-encoding'];
-    if (! encodings) {
+  httpUncompress(message, payload, cb) {
+    let encodings = message.headers["content-encoding"];
+    if (!encodings) {
       cb(null, payload);
       return;
     }
 
-    encodings = encodings.split(',').map(e => e.trim().toLowerCase());
+    encodings = encodings.split(",").map((e) => e.trim().toLowerCase());
 
     if (encodings.length > this.httpConfig.opts.maxEncodingLayers) {
-      cb(kerrorHTTP.get('too_many_encodings'));
+      cb(kerrorHTTP.get("too_many_encodings"));
       return;
     }
 
@@ -1017,7 +1066,7 @@ class HttpWsProtocol extends Protocol {
     this.httpUncompressStep(encodings, payload, cb, 0);
   }
 
-  httpUncompressStep (encodings, payload, cb, index) {
+  httpUncompressStep(encodings, payload, cb, index) {
     if (index === encodings.length) {
       cb(null, payload);
       return;
@@ -1025,11 +1074,10 @@ class HttpWsProtocol extends Protocol {
 
     const encoding = encodings[index];
 
-    if (encoding === 'identity') {
+    if (encoding === "identity") {
       this.httpUncompressStep(encodings, payload, cb, index + 1);
-    }
-    else if (encoding === 'gzip' || encoding === 'deflate') {
-      const fn = encoding === 'gzip' ? zlib.gunzip : zlib.inflate;
+    } else if (encoding === "gzip" || encoding === "deflate") {
+      const fn = encoding === "gzip" ? zlib.gunzip : zlib.inflate;
 
       fn(payload, (err, inflated) => {
         if (err) {
@@ -1039,17 +1087,18 @@ class HttpWsProtocol extends Protocol {
 
         this.httpUncompressStep(encodings, inflated, cb, index + 1);
       });
-    }
-    else {
-      cb(kerrorHTTP.get('unsupported_compression', encoding));
+    } else {
+      cb(kerrorHTTP.get("unsupported_compression", encoding));
     }
   }
 
-  parseWebSocketOptions () {
+  parseWebSocketOptions() {
     const cfg = this.config.websocket;
 
     if (cfg === undefined) {
-      global.kuzzle.log.warn('[websocket] no configuration found for websocket: disabling it');
+      global.kuzzle.log.warn(
+        "[websocket] no configuration found for websocket: disabling it"
+      );
       return { enabled: false };
     }
 
@@ -1058,14 +1107,18 @@ class HttpWsProtocol extends Protocol {
 
     if (idleTimeout === 0 || idleTimeout < 1000) {
       idleTimeout = DEFAULT_IDLE_TIMEOUT;
-      global.kuzzle.log.warn(`[websocket] The "idleTimeout" parameter can neither be deactivated or be set with a value lower than 1000. Defaulted to ${DEFAULT_IDLE_TIMEOUT}.`);
+      global.kuzzle.log.warn(
+        `[websocket] The "idleTimeout" parameter can neither be deactivated or be set with a value lower than 1000. Defaulted to ${DEFAULT_IDLE_TIMEOUT}.`
+      );
     }
 
     /**
      * @deprecated -- to be removed in the next major version
      */
     if (cfg.heartbeat) {
-      global.kuzzle.log.warn('[websocket] The "heartbeat" parameter has been deprecated and is now ignored. The "idleTimeout" parameter should now be configured instead.');
+      global.kuzzle.log.warn(
+        '[websocket] The "heartbeat" parameter has been deprecated and is now ignored. The "idleTimeout" parameter should now be configured instead.'
+      );
     }
 
     return {
@@ -1079,20 +1132,22 @@ class HttpWsProtocol extends Protocol {
     };
   }
 
-  parseHttpOptions () {
+  parseHttpOptions() {
     const cfg = this.config.http;
 
     if (cfg === undefined) {
-      global.kuzzle.log.warn('[http] no configuration found for http: disabling it');
+      global.kuzzle.log.warn(
+        "[http] no configuration found for http: disabling it"
+      );
       return { enabled: false };
     }
 
     // precomputes default headers
     const httpCfg = global.kuzzle.config.http;
     const headers = [
-      [ 'Access-Control-Allow-Headers', httpCfg.accessControlAllowHeaders ],
-      [ 'Access-Control-Allow-Methods', httpCfg.accessControlAllowMethods ],
-      [ 'Content-Type', 'application/json' ],
+      ["Access-Control-Allow-Headers", httpCfg.accessControlAllowHeaders],
+      ["Access-Control-Allow-Methods", httpCfg.accessControlAllowMethods],
+      ["Content-Type", "application/json"],
     ];
 
     for (const header of headers) {
@@ -1120,13 +1175,13 @@ class HttpWsProtocol extends Protocol {
  * @param {uWS.HttpRequest} request
  * @return {Array.<string>}
  */
-function getHttpIps (response, request) {
+function getHttpIps(response, request) {
   const ips = [Buffer.from(response.getRemoteAddressAsText()).toString()];
 
-  const forwardHeader = request.getHeader('x-forwarded-for');
+  const forwardHeader = request.getHeader("x-forwarded-for");
 
   if (forwardHeader && forwardHeader.length > 0) {
-    for (const header of forwardHeader.split(',')) {
+    for (const header of forwardHeader.split(",")) {
       const trimmed = header.trim();
 
       if (trimmed.length > 0) {