kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/network/httpRouter/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,23 +19,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { Request } = require("../../../api/request");
-const { KuzzleError } = require("../../../kerror/errors");
-const RoutePart = require("./routePart");
-const { has } = require("../../../util/safeObject");
-const kerror = require("../../../kerror").wrap("network", "http");
-const debug = require("../../../util/debug")("kuzzle:http:router");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const request_1 = require("../../../api/request");
+const kerror_1 = require("../../../kerror");
+const errors_1 = require("../../../kerror/errors");
+const debug_1 = __importDefault(require("../../../util/debug"));
+const routePart_1 = __importDefault(require("./routePart"));
+const kerror = (0, kerror_1.wrap)("network", "http");
+const debug = (0, debug_1.default)("kuzzle:http:router");
 /**
- * Attach handler to routes and dispatch a HTTP
- * message to the right handler
+ * Attach handler to routes and dispatch a HTTP message to the right handler
  *
  * Handlers will be called with the following arguments:
  *   - request: received HTTP request
  *   - response: HTTP response object
  *   - data: URL query arguments and/or POST data, if any
- *
- * @class Router
  */
 class Router {
     constructor() {
@@ -51,69 +52,51 @@ class Router {
             this.defaultHeaders["Accept-Encoding"] = "gzip,deflate,identity";
         }
         this.routes = {
-            DELETE: new RoutePart(),
-            GET: new RoutePart(),
-            HEAD: new RoutePart(),
-            PATCH: new RoutePart(),
-            POST: new RoutePart(),
-            PUT: new RoutePart(),
+            DELETE: new routePart_1.default(),
+            GET: new routePart_1.default(),
+            HEAD: new routePart_1.default(),
+            PATCH: new routePart_1.default(),
+            POST: new routePart_1.default(),
+            PUT: new routePart_1.default(),
         };
         // Add an automatic HEAD route on the '/' url, answering with default headers
         attach("/", (request, cb) => {
-            request.setResult({}, 200);
+            request.response.configure({ result: {}, status: 200 });
             cb(request);
         }, this.routes.HEAD);
     }
     /**
      * Attach a handler to a GET HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
     get(path, handler) {
         attach(path, handler, this.routes.GET);
     }
     /**
      * Attach a handler to a POST HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
     post(path, handler) {
         attach(path, handler, this.routes.POST);
     }
     /**
      * Attach a handler to a PUT HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
     put(path, handler) {
         attach(path, handler, this.routes.PUT);
     }
     /**
      * Attach a handler to a PATCH HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
     patch(path, handler) {
         attach(path, handler, this.routes.PATCH);
     }
     /**
      * Attach a handler to a DELETE HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
     delete(path, handler) {
         attach(path, handler, this.routes.DELETE);
     }
     /**
      * Attach a handler to a HEAD HTTP route
-     *
-     * @param {string} path
-     * @param {Function} handler
      */
     head(path, handler) {
         attach(path, handler, this.routes.HEAD);
@@ -121,30 +104,33 @@ class Router {
     /**
      * Route an incoming HTTP message to the right handler
      *
-     * @param {HttpMessage} message - Parsed HTTP message
-     * @param {function} cb
+     * @param message - Parsed HTTP message
      */
     route(message, cb) {
         debug("Routing HTTP message: %a", message);
-        if (!has(this.routes, message.method)) {
+        const method = message.method;
+        if (!isHttpVerb(method)) {
             this.routeUnhandledHttpMethod(message, cb);
             return;
         }
         let routeHandler;
         try {
-            routeHandler = this.routes[message.method].getHandler(message);
+            routeHandler = this.routes[method].getHandler(message);
             // Set Headers if not present
             routeHandler.request.response.setHeaders(this.defaultHeaders, true);
             applyACAOHeader(message, routeHandler.request);
-            if (routeHandler.handler === null) {
+            // Read once and invoke here: `invokeHandler` used to re-read the field
+            // this check had just proved non-null, one call away from the proof.
+            const handler = routeHandler.handler;
+            if (handler === null) {
                 throw kerror.get("url_not_found", routeHandler.url);
             }
-            routeHandler.invokeHandler(cb);
+            handler(routeHandler.request, cb);
         }
         catch (err) {
             let request;
-            if (!routeHandler || !routeHandler._request) {
-                request = new Request({ requestId: message.requestId }, {});
+            if (!routeHandler?._request) {
+                request = new request_1.Request({ requestId: message.requestId }, {});
                 // Set Headers if not present
                 request.response.setHeaders(this.defaultHeaders, true);
                 applyACAOHeader(message, request);
@@ -152,7 +138,7 @@ class Router {
             else {
                 request = routeHandler.request;
             }
-            const e = err instanceof KuzzleError
+            const e = err instanceof errors_1.KuzzleError
                 ? err
                 : kerror.getFrom(err, "unexpected_error", err.message);
             replyWithError(cb, request, e);
@@ -161,17 +147,15 @@ class Router {
     /**
      * Route HTTP messages using an HTTP method that is not handled by Kuzzle's
      * API, such as OPTIONS.
-     * @param  {HttpMessage} message
-     * @param {function} cb
      */
     routeUnhandledHttpMethod(message, cb) {
-        const requestContext = global.kuzzle.router.connections.get(message.connection.id), request = new Request({ requestId: message.requestId }, requestContext && requestContext.toJSON());
+        const requestContext = global.kuzzle.router.connections.get(message.connection.id), request = new request_1.Request({ requestId: message.requestId }, requestContext?.toJSON());
         // Set Headers if not present
         request.response.setHeaders(this.defaultHeaders, true);
         applyACAOHeader(message, request);
         if (message.method === "OPTIONS") {
             request.input.headers = message.headers;
-            request.setResult({}, 200);
+            request.response.configure({ result: {}, status: 200 });
             global.kuzzle.pipe("http:options", request, (error, result) => {
                 if (error) {
                     replyWithError(cb, request, error);
@@ -186,46 +170,55 @@ class Router {
     }
 }
 /**
- * Set the Header Access-Control-Allow-Origin based on the kuzzle configuration and request origin
- *
- * @param {HttpMessage} message
- * @param {Request} request
+ * Set the Header Access-Control-Allow-Origin based on the kuzzle configuration
+ * and request origin
  */
 function applyACAOHeader(message, request) {
-    if (message.headers && message.headers.origin) {
+    if (message.headers?.origin) {
         request.response.setHeaders({
             "Access-Control-Allow-Origin": message.headers.origin,
             Vary: "Origin",
         }, true);
     }
 }
+/** The HTTP verbs this router attaches handlers for. */
+const HTTP_VERBS = ["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"];
+/** The same list as a set, which is what `isHttpVerb` asks. */
+const HTTP_VERB_SET = new Set(HTTP_VERBS);
 /**
- * Attach a handler to an path and stores it to the target object
- *
- * @param {string} path
- * @param {Function} handler
- * @param {RoutePart} target
+ * Whether an incoming message names one of them. `has(this.routes, method)`
+ * answered the same question, without telling the compiler which key it had
+ * just proved — so the six named route parts had to be `RoutePart |
+ * undefined` for its sake.
+ */
+function isHttpVerb(method) {
+    return HTTP_VERB_SET.has(method);
+}
+/**
+ * Attach a handler to a path and stores it to the target object
  */
 function attach(path, handler, target) {
-    const sanitized = path[path.length - 1] === "/" ? path.slice(0, -1) : path;
+    const sanitized = path.at(-1) === "/" ? path.slice(0, -1) : path;
     if (!attachParts(sanitized.split("/"), handler, target)) {
         throw kerror.get("duplicate_url", sanitized);
     }
 }
 /**
- *
- * @param {Array<string>} parts
- * @param {Function} routeHandler
- * @param {RoutePart} target
- * @param {Array<string>} placeholders
- * @returns {Boolean} If false, failed to attach because of a duplicate
+ * @returns If false, failed to attach because of a duplicate
  */
 function attachParts(parts, handler, target, placeholders = []) {
     let part;
     do {
         part = parts.shift();
-    } while (parts.length > 0 && part.length === 0);
-    if (part && part[0] === ":") {
+        // `part?.length`: an exhausted list answers undefined, which is not an
+        // empty part to skip over — it is the end of the loop.
+    } while (parts.length > 0 && part?.length === 0);
+    if (part === undefined) {
+        // `attach()` splits a path, so there is always a first part — the empty
+        // string for "/". Nothing to attach here.
+        return false;
+    }
+    if (part.startsWith(":")) {
         placeholders.push(part.substring(1));
         part = "*";
     }
@@ -242,17 +235,10 @@ function attachParts(parts, handler, target, placeholders = []) {
 }
 /**
  * Reply to a callback function with an HTTP error
- *
- * @param {function} cb
- * @param {Request} request
- * @param {Error} error
  */
 function replyWithError(cb, request, error) {
     request.setError(error);
     cb(request);
 }
-/**
- * @type {Router}
- */
 module.exports = Router;
 //# sourceMappingURL=index.js.map

package/dist/lib/core/network/httpRouter/routeHandler.d.ts

@@ -1,46 +1,31 @@
-export = RouteHandler;
+import type { JSONObject } from "../../../types/JSONObject";
+import { Request } from "../../../api/request";
+import type HttpMessage from "../protocols/httpMessage";
+import type { RouteHandlerFunction } from "./routeTypes";
 /**
- * Object returned by routePart.getHandler(),
- * containing the information gathered about
- * a requested route and the corresponding handler
- * to invoke
+ * Object returned by routePart.getHandler(), containing the information
+ * gathered about a requested route and the corresponding handler to invoke
  *
- * @class RouteHandler
- * @param {string} url - parsed URL
- * @param {object} query - parsed query string
- * @param {HttpMessage} message
  * @throws {BadRequestError} If x-kuzzle-volatile HTTP header can not be parsed
  *                           in JSON format
  */
 declare class RouteHandler {
-    constructor(url: any, query: any, message: any);
-    handler: any;
-    _request: Request;
-    url: any;
-    data: any;
+    handler: RouteHandlerFunction | null;
+    url: string;
+    data: JSONObject;
     connection: {
-        connection: {
-            headers: any;
-            id: any;
-            ips: any;
-            path: any;
-            protocol: string;
-            url: any;
-            verb: any;
-        };
+        connection: JSONObject;
     };
+    _request: Request | null;
+    constructor(url: string, query: JSONObject, message: HttpMessage);
     get request(): Request;
     /**
      * Add a parametric argument to the request object
-     * @param {string} name
-     * @param {string} value
-     */
-    addArgument(name: string, value: string): void;
-    /**
-     * Invokes the registered handler
      *
-     * @param {Function} callback
+     * `value` is optional because its only caller pairs a route's placeholder
+     * names with the values collected during the descent, and a name with no
+     * value has always been written through as `undefined` rather than skipped.
      */
-    invokeHandler(callback: Function): void;
+    addArgument(name: string, value: string | undefined): void;
 }
-import { Request } from "../../../api/request/kuzzleRequest";
+export = RouteHandler;

package/dist/lib/core/network/httpRouter/routeHandler.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,19 +19,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { Request } = require("../../../api/request");
-const kerror = require("../../../kerror").wrap("network", "http");
+const request_1 = require("../../../api/request");
+const kerror_1 = require("../../../kerror");
+const kerror = (0, kerror_1.wrap)("network", "http");
 /**
- * Object returned by routePart.getHandler(),
- * containing the information gathered about
- * a requested route and the corresponding handler
- * to invoke
+ * Object returned by routePart.getHandler(), containing the information
+ * gathered about a requested route and the corresponding handler to invoke
  *
- * @class RouteHandler
- * @param {string} url - parsed URL
- * @param {object} query - parsed query string
- * @param {HttpMessage} message
  * @throws {BadRequestError} If x-kuzzle-volatile HTTP header can not be parsed
  *                           in JSON format
  */
@@ -51,51 +46,46 @@ class RouteHandler {
                 ips: message.ips,
                 path: message.path,
                 protocol: "http",
-                // @deprecated use "path" instead
-                url: message.url,
+                // the request context's own deprecated alias of "path"
+                url: message.path,
                 verb: message.method,
             },
         };
-        for (const k of Object.keys(message.headers)) {
-            if (k.toLowerCase() === "authorization" &&
-                message.headers[k].toLowerCase().startsWith("bearer ")) {
-                this.data.jwt = message.headers[k].substring("Bearer ".length);
+        // `Object.entries` rather than `Object.keys` + three indexed reads: the
+        // value comes back with the key, so there is nothing to look up twice and
+        // nothing for `noUncheckedIndexedAccess` to object to.
+        for (const [name, value] of Object.entries(message.headers)) {
+            if (name.toLowerCase() === "authorization" &&
+                value.toLowerCase().startsWith("bearer ")) {
+                this.data.jwt = value.substring("Bearer ".length);
             }
-            else if (k.toLowerCase() === "x-kuzzle-volatile") {
+            else if (name.toLowerCase() === "x-kuzzle-volatile") {
                 try {
-                    this.data.volatile = JSON.parse(message.headers[k]);
+                    this.data.volatile = JSON.parse(value);
                 }
                 catch (e) {
-                    throw kerror.getFrom(e, "volatile_parse_failed", e.message);
+                    // A malformed header is whatever JSON.parse threw, which is a
+                    // SyntaxError in practice but is not typed as one.
+                    const error = e instanceof Error ? e : new Error(String(e));
+                    throw kerror.getFrom(error, "volatile_parse_failed", error.message);
                 }
             }
         }
     }
     get request() {
-        if (this._request === null) {
-            this._request = new Request(this.data, this.connection);
-        }
+        this._request ?? (this._request = new request_1.Request(this.data, this.connection));
         return this._request;
     }
     /**
      * Add a parametric argument to the request object
-     * @param {string} name
-     * @param {string} value
+     *
+     * `value` is optional because its only caller pairs a route's placeholder
+     * names with the values collected during the descent, and a name with no
+     * value has always been written through as `undefined` rather than skipped.
      */
     addArgument(name, value) {
         this.data[name] = value;
     }
-    /**
-     * Invokes the registered handler
-     *
-     * @param {Function} callback
-     */
-    invokeHandler(callback) {
-        this.handler(this.request, callback);
-    }
 }
-/**
- * @type {RouteHandler}
- */
 module.exports = RouteHandler;
 //# sourceMappingURL=routeHandler.js.map

package/dist/lib/core/network/httpRouter/routePart.d.ts

@@ -1,35 +1,26 @@
-export = RoutePart;
+import type HttpMessage from "../protocols/httpMessage";
+import RouteHandler from "./routeHandler";
+import type { RouteHandlerFunction } from "./routeTypes";
 /**
  * Defines a new route part
- *
- * @class RoutePart
  */
 declare class RoutePart {
-    subparts: {};
-    placeholders: any;
-    handler: any;
+    subparts: Record<string, RoutePart>;
+    placeholders: string[] | null;
+    handler: RouteHandlerFunction | null;
+    constructor();
     /**
      * Checks if an url part already exists
-     *
-     * @param {string} part
-     * @returns {boolean}
      */
     exists(part: string): boolean;
     /**
-     * Gets the next element of an URL part, creating a new
-     * tree leaf if necessary
-     *
-     * @param {string} part
-     * @returns {RoutePart}
+     * Gets the next element of an URL part, creating a new tree leaf if necessary
      */
     getNext(part: string): RoutePart;
     /**
      * Returns a RouteHandler instance corresponding to the provided URL
      * Returns null if no handler was found
-     *
-     * @param {HttpMessage} message
-     * @returns {RouteHandler} registered function handler
      */
     getHandler(message: HttpMessage): RouteHandler;
 }
-import RouteHandler = require("./routeHandler");
+export = RoutePart;

package/dist/lib/core/network/httpRouter/routePart.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,100 +19,117 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const URL = require("url");
-const querystring = require("querystring");
-const RouteHandler = require("./routeHandler");
-const { has } = require("../../../util/safeObject");
+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 querystring = __importStar(require("node:querystring"));
+const URL = __importStar(require("node:url"));
+const routeHandler_1 = __importDefault(require("./routeHandler"));
 /**
  * Defines a new route part
- *
- * @class RoutePart
  */
 class RoutePart {
     constructor() {
-        this.subparts = {};
+        // Null-prototype: URL parts are attacker-controlled, and `{}` answers
+        // `subparts["toString"]` with a function. That is why every read below used
+        // to go through `has()` first; with no prototype to inherit from, a single
+        // indexed read is both safe and honest — it is `RoutePart | undefined`, and
+        // nothing has to be taken on trust between the check and the use.
+        this.subparts = Object.create(null);
         this.placeholders = null;
         this.handler = null;
     }
     /**
      * Checks if an url part already exists
-     *
-     * @param {string} part
-     * @returns {boolean}
      */
     exists(part) {
-        return (this.subparts[part] !== undefined && this.subparts[part].handler !== null);
+        const subpart = this.subparts[part];
+        return subpart !== undefined && subpart.handler !== null;
     }
     /**
-     * Gets the next element of an URL part, creating a new
-     * tree leaf if necessary
-     *
-     * @param {string} part
-     * @returns {RoutePart}
+     * Gets the next element of an URL part, creating a new tree leaf if necessary
      */
     getNext(part) {
-        if (!has(this.subparts, part)) {
-            this.subparts[part] = new RoutePart();
+        let subpart = this.subparts[part];
+        if (subpart === undefined) {
+            subpart = new RoutePart();
+            this.subparts[part] = subpart;
         }
-        return this.subparts[part];
+        return subpart;
     }
     /**
      * Returns a RouteHandler instance corresponding to the provided URL
      * Returns null if no handler was found
-     *
-     * @param {HttpMessage} message
-     * @returns {RouteHandler} registered function handler
      */
     getHandler(message) {
         // Do not use WHATWG API yet, stick with the legacy (and deprecated) URL
         // There are two issues:
         //   - Heavy performance impact: https://github.com/nodejs/node/issues/30334
         //   - Double slash bug: https://github.com/nodejs/node/issues/30776
-        const parsed = URL.parse(message.url, true);
+        const parsed = URL.parse(message.path, true);
         let pathname = parsed.pathname || ""; // pathname is set to null if empty
-        if (pathname[pathname.length - 1] === "/") {
+        if (pathname.at(-1) === "/") {
             pathname = pathname.slice(0, -1);
         }
-        const routeHandler = new RouteHandler(pathname, parsed.query, message);
+        const routeHandler = new routeHandler_1.default(pathname, parsed.query, message);
         return getHandlerPart(this, pathname.split("/"), routeHandler);
     }
 }
 /**
  * Populate the routeHandler argument with parametric values, if any
  *
- * @param {RoutePart} routePart - tree leaf to scan
- * @param {Array<string>} parts
- * @param {RouteHandler} routeHandler - registered function handler
- * @param {Array<string>} placeholders - sorted array to populate the list of parametric values
- * @returns {RouteHandler} registered function handler
+ * @param routePart - tree leaf to scan
+ * @param routeHandler - registered function handler
+ * @param placeholders - sorted array to populate the list of parametric values
  */
 function getHandlerPart(routePart, parts, routeHandler, placeholders = []) {
-    let part;
-    do {
+    let part = parts.shift();
+    while (part?.length === 0 && parts.length > 0) {
         part = parts.shift();
-    } while (parts.length > 0 && part.length === 0);
+    }
     if (part === undefined) {
         routeHandler.handler = routePart.handler;
         if (routePart.placeholders !== null) {
-            for (const i of Object.keys(routePart.placeholders)) {
-                routeHandler.addArgument(routePart.placeholders[i], placeholders[i]);
+            for (const [i, name] of routePart.placeholders.entries()) {
+                routeHandler.addArgument(name, placeholders[i]);
             }
         }
         return routeHandler;
     }
     part = querystring.unescape(part);
-    if (has(routePart.subparts, part)) {
-        return getHandlerPart(routePart.subparts[part], parts, routeHandler, placeholders);
+    const subpart = routePart.subparts[part];
+    if (subpart !== undefined) {
+        return getHandlerPart(subpart, parts, routeHandler, placeholders);
     }
-    if (routePart.subparts["*"]) {
+    const wildcard = routePart.subparts["*"];
+    if (wildcard !== undefined) {
         placeholders.push(part);
-        return getHandlerPart(routePart.subparts["*"], parts, routeHandler, placeholders);
+        return getHandlerPart(wildcard, parts, routeHandler, placeholders);
     }
     return routeHandler;
 }
-/**
- * @type {RoutePart}
- */
 module.exports = RoutePart;
 //# sourceMappingURL=routePart.js.map

package/dist/lib/core/network/httpRouter/routeTypes.d.ts

@@ -0,0 +1,3 @@
+import type { Request } from "../../../api/request";
+export type RouteCallback = (request: Request) => void;
+export type RouteHandlerFunction = (request: Request, callback: RouteCallback) => void;